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

package/src/services/admin.ts

@@ -0,0 +1,3103 @@
+// 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 Conflict
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<Conflict>()("Conflict", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withConflictError),
+    [{ status: 409 }],
+  ) {}
+
+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 AdminAddRuleToQuotaGroupRequest {
+  /** quota group to add a rule to */
+  quotagroup: string;
+  /** the name of the quota rule to add to the group */
+  quotarule: string;
+}
+export const AdminAddRuleToQuotaGroupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    quotagroup: S.String.pipe(T.Label()),
+    quotarule: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/admin/quota/groups/{quotagroup}/rules/{quotarule}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminAddRuleToQuotaGroupRequest",
+}) as any as S.Schema<AdminAddRuleToQuotaGroupRequest>;
+
+export interface AdminAddRuleToQuotaGroupResponse {}
+export const AdminAddRuleToQuotaGroupResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AdminAddRuleToQuotaGroupResponse",
+}) as any as S.Schema<AdminAddRuleToQuotaGroupResponse>;
+
+export interface AdminAddUserToQuotaGroupRequest {
+  /** quota group to add the user to */
+  quotagroup: string;
+  /** username of the user to add to the quota group */
+  username: string;
+}
+export const AdminAddUserToQuotaGroupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    quotagroup: S.String.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/admin/quota/groups/{quotagroup}/users/{username}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminAddUserToQuotaGroupRequest",
+}) as any as S.Schema<AdminAddUserToQuotaGroupRequest>;
+
+export interface AdminAddUserToQuotaGroupResponse {}
+export const AdminAddUserToQuotaGroupResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AdminAddUserToQuotaGroupResponse",
+}) as any as S.Schema<AdminAddUserToQuotaGroupResponse>;
+
+export interface AdminAdoptRepositoryRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+}
+export const AdminAdoptRepositoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/admin/unadopted/{owner}/{repo}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminAdoptRepositoryRequest",
+}) as any as S.Schema<AdminAdoptRepositoryRequest>;
+
+export interface AdminAdoptRepositoryResponse {}
+export const AdminAdoptRepositoryResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AdminAdoptRepositoryResponse",
+}) as any as S.Schema<AdminAdoptRepositoryResponse>;
+
+/** CreateHookOptionConfig has all config options in it required are "content_type" and "url" Required */
+export type CreateHookOptionConfig = { [key: string]: string | undefined };
+export const CreateHookOptionConfig = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<CreateHookOptionConfig>;
+
+export type AdminCreateHookRequestEventsList = Array<string>;
+export const AdminCreateHookRequestEventsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<AdminCreateHookRequestEventsList>;
+
+export type AdminCreateHookRequestType =
+  | "forgejo"
+  | "dingtalk"
+  | "discord"
+  | "gitea"
+  | "gogs"
+  | "msteams"
+  | "slack"
+  | "telegram"
+  | "feishu"
+  | "wechatwork"
+  | "packagist";
+export const AdminCreateHookRequestType = /*@__PURE__*/ S.String;
+
+export interface AdminCreateHookRequest {
+  active?: boolean;
+  authorization_header?: string;
+  branch_filter?: string;
+  config: CreateHookOptionConfig;
+  events?: AdminCreateHookRequestEventsList;
+  type: AdminCreateHookRequestType | (string & {});
+}
+export const AdminCreateHookRequest = /*@__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(AdminCreateHookRequestEventsList),
+    type: AdminCreateHookRequestType,
+  }).pipe(T.Http({ method: "POST", uri: "/admin/hooks", code: 200 })),
+).annotate({
+  identifier: "AdminCreateHookRequest",
+}) as any as S.Schema<AdminCreateHookRequest>;
+
+/** 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>;
+
+/** possible values are `public` (default), `limited` or `private` */
+export type AdminCreateOrgRequestVisibility = "public" | "limited" | "private";
+export const AdminCreateOrgRequestVisibility = /*@__PURE__*/ S.String;
+
+export interface AdminCreateOrgRequest {
+  /** username of the user that will own the created organization */
+  owner: string;
+  description?: string;
+  email?: string;
+  full_name?: string;
+  location?: string;
+  repo_admin_change_team_access?: boolean;
+  username: string;
+  /** possible values are `public` (default), `limited` or `private` */
+  visibility?: AdminCreateOrgRequestVisibility | (string & {});
+  website?: string;
+}
+export const AdminCreateOrgRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    description: S.optional(S.String),
+    email: S.optional(S.String),
+    full_name: S.optional(S.String),
+    location: S.optional(S.String),
+    repo_admin_change_team_access: S.optional(S.Boolean),
+    username: S.String,
+    visibility: S.optional(AdminCreateOrgRequestVisibility),
+    website: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/admin/users/{owner}/orgs", code: 200 }),
+  ),
+).annotate({
+  identifier: "AdminCreateOrgRequest",
+}) as any as S.Schema<AdminCreateOrgRequest>;
+
+/** Organization represents an organization */
+export interface Organization {
+  avatar_url?: string;
+  created?: string;
+  description?: string;
+  email?: string;
+  full_name?: string;
+  id: number;
+  location?: string;
+  name?: string;
+  repo_admin_change_team_access?: boolean;
+  /** deprecated */
+  username: string;
+  visibility?: string;
+  website?: string;
+}
+export 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 interface AdminCreatePublicKeyRequest {
+  /** username of the user */
+  username: string;
+  /** An armored SSH key to add */
+  key: string;
+  /** Describe if the key has only read access or read/write */
+  read_only?: boolean;
+  /** Title of the key to add */
+  title: string;
+}
+export const AdminCreatePublicKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    key: S.String,
+    read_only: S.optional(S.Boolean),
+    title: S.String,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/admin/users/{username}/keys", code: 200 }),
+  ),
+).annotate({
+  identifier: "AdminCreatePublicKeyRequest",
+}) as any as S.Schema<AdminCreatePublicKeyRequest>;
+
+/** User represents a user */
+export interface User {
+  /** Is user active */
+  active?: boolean;
+  /** URL to the user's avatar */
+  avatar_url?: string;
+  created?: string;
+  /** the user's description */
+  description?: string;
+  email?: string;
+  /** user counts */
+  followers_count?: number;
+  following_count?: number;
+  /** the user's full name */
+  full_name?: string;
+  /** URL to the user's profile page */
+  html_url?: string;
+  /** the user's id */
+  id: number;
+  /** Is the user an administrator */
+  is_admin?: boolean;
+  /** User locale */
+  language?: string;
+  last_login?: string;
+  /** the user's location */
+  location?: string;
+  /** the user's username */
+  login: string;
+  /** the user's authentication sign-in name. */
+  login_name?: string;
+  /** Is user login prohibited */
+  prohibit_login?: boolean;
+  /** the user's pronouns */
+  pronouns?: string;
+  /** Is user restricted */
+  restricted?: boolean;
+  /** The ID of the user's Authentication Source */
+  source_id?: number;
+  starred_repos_count?: number;
+  /** User visibility level option: public, limited, private */
+  visibility?: string;
+  /** the user's website */
+  website?: string;
+}
+export 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>;
+
+/** 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>;
+
+/** The subjects affected by the rule */
+export type CreateQuotaRuleOptionsSubjectsList = Array<string>;
+export const CreateQuotaRuleOptionsSubjectsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CreateQuotaRuleOptionsSubjectsList>;
+
+/** CreateQuotaRuleOptions represents the options for creating a quota rule */
+export interface CreateQuotaRuleOptions {
+  /** The limit set by the rule */
+  limit?: number;
+  /** Name of the rule to create */
+  name?: string;
+  /** The subjects affected by the rule */
+  subjects?: CreateQuotaRuleOptionsSubjectsList;
+}
+export const CreateQuotaRuleOptions = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    limit: S.optional(S.Number),
+    name: S.optional(S.String),
+    subjects: S.optional(CreateQuotaRuleOptionsSubjectsList),
+  }),
+).annotate({
+  identifier: "CreateQuotaRuleOptions",
+}) as any as S.Schema<CreateQuotaRuleOptions>;
+
+/** Rules to add to the newly created group. If a rule does not exist, it will be created. */
+export type AdminCreateQuotaGroupRequestRulesList =
+  Array<CreateQuotaRuleOptions>;
+export const AdminCreateQuotaGroupRequestRulesList = /*@__PURE__*/ S.Array(
+  CreateQuotaRuleOptions,
+) as any as S.Schema<AdminCreateQuotaGroupRequestRulesList>;
+
+export interface AdminCreateQuotaGroupRequest {
+  /** Name of the quota group to create */
+  name?: string;
+  /** Rules to add to the newly created group. If a rule does not exist, it will be created. */
+  rules?: AdminCreateQuotaGroupRequestRulesList;
+}
+export const AdminCreateQuotaGroupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    rules: S.optional(AdminCreateQuotaGroupRequestRulesList),
+  }).pipe(T.Http({ method: "POST", uri: "/admin/quota/groups", code: 200 })),
+).annotate({
+  identifier: "AdminCreateQuotaGroupRequest",
+}) as any as S.Schema<AdminCreateQuotaGroupRequest>;
+
+/** 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>;
+
+/** The subjects affected by the rule */
+export type AdminCreateQuotaRuleRequestSubjectsList = Array<string>;
+export const AdminCreateQuotaRuleRequestSubjectsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<AdminCreateQuotaRuleRequestSubjectsList>;
+
+export interface AdminCreateQuotaRuleRequest {
+  /** The limit set by the rule */
+  limit?: number;
+  /** Name of the rule to create */
+  name?: string;
+  /** The subjects affected by the rule */
+  subjects?: AdminCreateQuotaRuleRequestSubjectsList;
+}
+export const AdminCreateQuotaRuleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    limit: S.optional(S.Number),
+    name: S.optional(S.String),
+    subjects: S.optional(AdminCreateQuotaRuleRequestSubjectsList),
+  }).pipe(T.Http({ method: "POST", uri: "/admin/quota/rules", code: 200 })),
+).annotate({
+  identifier: "AdminCreateQuotaRuleRequest",
+}) as any as S.Schema<AdminCreateQuotaRuleRequest>;
+
+/** ObjectFormatName of the underlying git repository */
+export type AdminCreateRepoRequestObjectFormatName = "sha1" | "sha256";
+export const AdminCreateRepoRequestObjectFormatName = /*@__PURE__*/ S.String;
+
+/** TrustModel of the repository */
+export type AdminCreateRepoRequestTrustModel =
+  | "default"
+  | "collaborator"
+  | "committer"
+  | "collaboratorcommitter";
+export const AdminCreateRepoRequestTrustModel = /*@__PURE__*/ S.String;
+
+export interface AdminCreateRepoRequest {
+  /** username of the user. This user will own the created repository */
+  username: string;
+  /** Whether the repository should be auto-initialized? */
+  auto_init?: boolean;
+  /** DefaultBranch of the repository (used when initializes and in template) */
+  default_branch?: string;
+  /** Description of the repository to create */
+  description?: string;
+  /** Gitignores to use, separated by commas */
+  gitignores?: string;
+  /** Label-Set to use */
+  issue_labels?: string;
+  /** License to use */
+  license?: string;
+  /** Name of the repository to create */
+  name: string;
+  /** ObjectFormatName of the underlying git repository */
+  object_format_name?: AdminCreateRepoRequestObjectFormatName | (string & {});
+  /** Whether the repository is private */
+  private?: boolean;
+  /** Readme of the repository to create */
+  readme?: string;
+  /** Whether the repository is template */
+  template?: boolean;
+  /** TrustModel of the repository */
+  trust_model?: AdminCreateRepoRequestTrustModel | (string & {});
+}
+export const AdminCreateRepoRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    auto_init: S.optional(S.Boolean),
+    default_branch: S.optional(S.String),
+    description: S.optional(S.String),
+    gitignores: S.optional(S.String),
+    issue_labels: S.optional(S.String),
+    license: S.optional(S.String),
+    name: S.String,
+    object_format_name: S.optional(AdminCreateRepoRequestObjectFormatName),
+    private: S.optional(S.Boolean),
+    readme: S.optional(S.String),
+    template: S.optional(S.Boolean),
+    trust_model: S.optional(AdminCreateRepoRequestTrustModel),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/admin/users/{username}/repos", code: 200 }),
+  ),
+).annotate({
+  identifier: "AdminCreateRepoRequest",
+}) as any as S.Schema<AdminCreateRepoRequest>;
+
+/** ExternalTracker represents settings for external tracker */
+export interface ExternalTracker {
+  /** External Issue Tracker URL Format. Use the placeholders {user}, {repo} and {index} for the username, repository name and issue index. */
+  external_tracker_format?: string;
+  /** External Issue Tracker issue regular expression */
+  external_tracker_regexp_pattern?: string;
+  /** External Issue Tracker Number Format, either `numeric`, `alphanumeric`, or `regexp` */
+  external_tracker_style?: string;
+  /** URL of external issue tracker. */
+  external_tracker_url?: string;
+}
+export 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>;
+
+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 interface AdminCreateUserRequest {
+  /** For explicitly setting the user creation timestamp. Useful when users are migrated from other systems. When omitted, the user's creation timestamp will be set to "now". */
+  created_at?: string;
+  email: string;
+  full_name?: string;
+  login_name?: string;
+  must_change_password?: boolean;
+  password?: string | Redacted.Redacted<string>;
+  restricted?: boolean;
+  send_notify?: boolean;
+  source_id?: number;
+  username: string;
+  visibility?: string;
+}
+export const AdminCreateUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    created_at: S.optional(S.String),
+    email: S.String,
+    full_name: S.optional(S.String),
+    login_name: S.optional(S.String),
+    must_change_password: S.optional(S.Boolean),
+    password: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    restricted: S.optional(S.Boolean),
+    send_notify: S.optional(S.Boolean),
+    source_id: S.optional(S.Number),
+    username: S.String,
+    visibility: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/admin/users", code: 200 })),
+).annotate({
+  identifier: "AdminCreateUserRequest",
+}) as any as S.Schema<AdminCreateUserRequest>;
+
+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 AdminCreateUserAccessTokenRequestRepositoriesList =
+  Array<RepoTargetOption>;
+export const AdminCreateUserAccessTokenRequestRepositoriesList =
+  /*@__PURE__*/ S.Array(
+    RepoTargetOption,
+  ) as any as S.Schema<AdminCreateUserAccessTokenRequestRepositoriesList>;
+
+export type AdminCreateUserAccessTokenRequestScopesList = Array<string>;
+export const AdminCreateUserAccessTokenRequestScopesList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<AdminCreateUserAccessTokenRequestScopesList>;
+
+export interface AdminCreateUserAccessTokenRequest {
+  /** username of user */
+  username: string;
+  name: string;
+  /** If provided and not-empty, creates an access token with access only to specified repositories. */
+  repositories?: AdminCreateUserAccessTokenRequestRepositoriesList;
+  scopes?: AdminCreateUserAccessTokenRequestScopesList;
+}
+export const AdminCreateUserAccessTokenRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    name: S.String,
+    repositories: S.optional(AdminCreateUserAccessTokenRequestRepositoriesList),
+    scopes: S.optional(AdminCreateUserAccessTokenRequestScopesList),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/admin/users/{username}/tokens",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminCreateUserAccessTokenRequest",
+}) as any as S.Schema<AdminCreateUserAccessTokenRequest>;
+
+/** 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 AdminDeleteHookRequest {
+  /** id of the hook to delete */
+  id: number;
+}
+export const AdminDeleteHookRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "DELETE", uri: "/admin/hooks/{id}", code: 200 })),
+).annotate({
+  identifier: "AdminDeleteHookRequest",
+}) as any as S.Schema<AdminDeleteHookRequest>;
+
+export interface AdminDeleteHookResponse {}
+export const AdminDeleteHookResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AdminDeleteHookResponse",
+}) as any as S.Schema<AdminDeleteHookResponse>;
+
+export interface AdminDeleteQuotaGroupRequest {
+  /** quota group to delete */
+  quotagroup: string;
+}
+export const AdminDeleteQuotaGroupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    quotagroup: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/admin/quota/groups/{quotagroup}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminDeleteQuotaGroupRequest",
+}) as any as S.Schema<AdminDeleteQuotaGroupRequest>;
+
+export interface AdminDeleteQuotaGroupResponse {}
+export const AdminDeleteQuotaGroupResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AdminDeleteQuotaGroupResponse",
+}) as any as S.Schema<AdminDeleteQuotaGroupResponse>;
+
+export interface AdminDeleteQuotaRuleRequest {
+  /** quota rule to delete */
+  quotarule: string;
+}
+export const AdminDeleteQuotaRuleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    quotarule: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/admin/quota/rules/{quotarule}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminDeleteQuotaRuleRequest",
+}) as any as S.Schema<AdminDeleteQuotaRuleRequest>;
+
+export interface AdminDeleteQuotaRuleResponse {}
+export const AdminDeleteQuotaRuleResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AdminDeleteQuotaRuleResponse",
+}) as any as S.Schema<AdminDeleteQuotaRuleResponse>;
+
+export interface AdminDeleteUnadoptedRepositoryRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+}
+export const AdminDeleteUnadoptedRepositoryRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      owner: S.String.pipe(T.Label()),
+      repo: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/admin/unadopted/{owner}/{repo}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "AdminDeleteUnadoptedRepositoryRequest",
+}) as any as S.Schema<AdminDeleteUnadoptedRepositoryRequest>;
+
+export interface AdminDeleteUnadoptedRepositoryResponse {}
+export const AdminDeleteUnadoptedRepositoryResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "AdminDeleteUnadoptedRepositoryResponse",
+}) as any as S.Schema<AdminDeleteUnadoptedRepositoryResponse>;
+
+export interface AdminDeleteUserRequest {
+  /** username of user to delete */
+  username: string;
+  /** purge the user from the system completely */
+  purge?: boolean;
+}
+export const AdminDeleteUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    purge: S.optional(S.Boolean.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "DELETE", uri: "/admin/users/{username}", code: 200 }),
+  ),
+).annotate({
+  identifier: "AdminDeleteUserRequest",
+}) as any as S.Schema<AdminDeleteUserRequest>;
+
+export interface AdminDeleteUserResponse {}
+export const AdminDeleteUserResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AdminDeleteUserResponse",
+}) as any as S.Schema<AdminDeleteUserResponse>;
+
+export interface AdminDeleteUserAccessTokenRequest {
+  /** username of user */
+  username: string;
+  /** token to be deleted, identified by ID and if not available by name */
+  token: string;
+}
+export const AdminDeleteUserAccessTokenRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    token: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/admin/users/{username}/tokens/{token}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminDeleteUserAccessTokenRequest",
+}) as any as S.Schema<AdminDeleteUserAccessTokenRequest>;
+
+export interface AdminDeleteUserAccessTokenResponse {}
+export const AdminDeleteUserAccessTokenResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AdminDeleteUserAccessTokenResponse",
+}) as any as S.Schema<AdminDeleteUserAccessTokenResponse>;
+
+/** email addresses to delete */
+export type AdminDeleteUserEmailsRequestEmailsList = Array<string>;
+export const AdminDeleteUserEmailsRequestEmailsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<AdminDeleteUserEmailsRequestEmailsList>;
+
+export interface AdminDeleteUserEmailsRequest {
+  /** username of user to delete email addresses from */
+  username: string;
+  /** email addresses to delete */
+  emails?: AdminDeleteUserEmailsRequestEmailsList;
+}
+export const AdminDeleteUserEmailsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    emails: S.optional(AdminDeleteUserEmailsRequestEmailsList),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/admin/users/{username}/emails",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminDeleteUserEmailsRequest",
+}) as any as S.Schema<AdminDeleteUserEmailsRequest>;
+
+export interface AdminDeleteUserEmailsResponse {}
+export const AdminDeleteUserEmailsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AdminDeleteUserEmailsResponse",
+}) as any as S.Schema<AdminDeleteUserEmailsResponse>;
+
+export interface AdminDeleteUserPublicKeyRequest {
+  /** username of user */
+  username: string;
+  /** id of the key to delete */
+  id: number;
+}
+export const AdminDeleteUserPublicKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/admin/users/{username}/keys/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminDeleteUserPublicKeyRequest",
+}) as any as S.Schema<AdminDeleteUserPublicKeyRequest>;
+
+export interface AdminDeleteUserPublicKeyResponse {}
+export const AdminDeleteUserPublicKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AdminDeleteUserPublicKeyResponse",
+}) as any as S.Schema<AdminDeleteUserPublicKeyResponse>;
+
+export type AdminEditHookRequestConfigMap = {
+  [key: string]: string | undefined;
+};
+export const AdminEditHookRequestConfigMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<AdminEditHookRequestConfigMap>;
+
+export type AdminEditHookRequestEventsList = Array<string>;
+export const AdminEditHookRequestEventsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<AdminEditHookRequestEventsList>;
+
+export interface AdminEditHookRequest {
+  /** id of the hook to update */
+  id: number;
+  active?: boolean;
+  authorization_header?: string;
+  branch_filter?: string;
+  config?: AdminEditHookRequestConfigMap;
+  events?: AdminEditHookRequestEventsList;
+}
+export const AdminEditHookRequest = /*@__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(AdminEditHookRequestConfigMap),
+    events: S.optional(AdminEditHookRequestEventsList),
+  }).pipe(T.Http({ method: "PATCH", uri: "/admin/hooks/{id}", code: 200 })),
+).annotate({
+  identifier: "AdminEditHookRequest",
+}) as any as S.Schema<AdminEditHookRequest>;
+
+/** The subjects affected by the rule */
+export type AdminEditQuotaRuleRequestSubjectsList = Array<string>;
+export const AdminEditQuotaRuleRequestSubjectsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<AdminEditQuotaRuleRequestSubjectsList>;
+
+export interface AdminEditQuotaRuleRequest {
+  /** Quota rule to change */
+  quotarule: string;
+  /** The limit set by the rule */
+  limit?: number;
+  /** The subjects affected by the rule */
+  subjects?: AdminEditQuotaRuleRequestSubjectsList;
+}
+export const AdminEditQuotaRuleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    quotarule: S.String.pipe(T.Label()),
+    limit: S.optional(S.Number),
+    subjects: S.optional(AdminEditQuotaRuleRequestSubjectsList),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/admin/quota/rules/{quotarule}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminEditQuotaRuleRequest",
+}) as any as S.Schema<AdminEditQuotaRuleRequest>;
+
+export interface AdminEditUserRequest {
+  /** username of user to edit */
+  username: string;
+  active?: boolean;
+  admin?: boolean;
+  allow_create_organization?: boolean;
+  allow_git_hook?: boolean;
+  allow_import_local?: boolean;
+  description?: string;
+  email?: string;
+  full_name?: string;
+  hide_email?: boolean;
+  location?: string;
+  login_name?: string;
+  max_repo_creation?: number;
+  must_change_password?: boolean;
+  password?: string | Redacted.Redacted<string>;
+  prohibit_login?: boolean;
+  pronouns?: string;
+  restricted?: boolean;
+  source_id?: number;
+  visibility?: string;
+  website?: string;
+}
+export const AdminEditUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    active: S.optional(S.Boolean),
+    admin: S.optional(S.Boolean),
+    allow_create_organization: S.optional(S.Boolean),
+    allow_git_hook: S.optional(S.Boolean),
+    allow_import_local: S.optional(S.Boolean),
+    description: S.optional(S.String),
+    email: S.optional(S.String),
+    full_name: S.optional(S.String),
+    hide_email: S.optional(S.Boolean),
+    location: S.optional(S.String),
+    login_name: S.optional(S.String),
+    max_repo_creation: S.optional(S.Number),
+    must_change_password: S.optional(S.Boolean),
+    password: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    prohibit_login: S.optional(S.Boolean),
+    pronouns: S.optional(S.String),
+    restricted: S.optional(S.Boolean),
+    source_id: S.optional(S.Number),
+    visibility: S.optional(S.String),
+    website: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "PATCH", uri: "/admin/users/{username}", code: 200 }),
+  ),
+).annotate({
+  identifier: "AdminEditUserRequest",
+}) as any as S.Schema<AdminEditUserRequest>;
+
+export interface AdminGetActionRunJobsRequest {
+  /** a comma separated list of labels to search for */
+  labels?: string;
+}
+export const AdminGetActionRunJobsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    labels: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/admin/actions/runners/jobs", code: 200 }),
+  ),
+).annotate({
+  identifier: "AdminGetActionRunJobsRequest",
+}) as any as S.Schema<AdminGetActionRunJobsRequest>;
+
+/** 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 AdminGetActionRunJobsResponseBodyList = Array<ActionRunJob>;
+export const AdminGetActionRunJobsResponseBodyList = /*@__PURE__*/ S.Array(
+  ActionRunJob,
+) as any as S.Schema<AdminGetActionRunJobsResponseBodyList>;
+
+export type AdminGetActionRunJobsResponse =
+  AdminGetActionRunJobsResponseBodyList;
+export const AdminGetActionRunJobsResponse = /*@__PURE__*/ S.suspend(() =>
+  AdminGetActionRunJobsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "AdminGetActionRunJobsResponse",
+}) as any as S.Schema<AdminGetActionRunJobsResponse>;
+
+export interface AdminGetAllEmailsRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const AdminGetAllEmailsRequest = /*@__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: "/admin/emails", code: 200 })),
+).annotate({
+  identifier: "AdminGetAllEmailsRequest",
+}) as any as S.Schema<AdminGetAllEmailsRequest>;
+
+/** Email an email address belonging to a user */
+export interface Email {
+  email?: string;
+  primary?: boolean;
+  user_id?: number;
+  username?: string;
+  verified?: boolean;
+}
+export 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 AdminGetAllEmailsResponseBodyList = Array<Email>;
+export const AdminGetAllEmailsResponseBodyList = /*@__PURE__*/ S.Array(
+  Email,
+) as any as S.Schema<AdminGetAllEmailsResponseBodyList>;
+
+export type AdminGetAllEmailsResponse = AdminGetAllEmailsResponseBodyList;
+export const AdminGetAllEmailsResponse = /*@__PURE__*/ S.suspend(() =>
+  AdminGetAllEmailsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "AdminGetAllEmailsResponse",
+}) as any as S.Schema<AdminGetAllEmailsResponse>;
+
+export interface AdminGetAllOrgsRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const AdminGetAllOrgsRequest = /*@__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: "/admin/orgs", code: 200 })),
+).annotate({
+  identifier: "AdminGetAllOrgsRequest",
+}) as any as S.Schema<AdminGetAllOrgsRequest>;
+
+export type AdminGetAllOrgsResponseBodyList = Array<Organization>;
+export const AdminGetAllOrgsResponseBodyList = /*@__PURE__*/ S.Array(
+  Organization,
+) as any as S.Schema<AdminGetAllOrgsResponseBodyList>;
+
+export type AdminGetAllOrgsResponse = AdminGetAllOrgsResponseBodyList;
+export const AdminGetAllOrgsResponse = /*@__PURE__*/ S.suspend(() =>
+  AdminGetAllOrgsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "AdminGetAllOrgsResponse",
+}) as any as S.Schema<AdminGetAllOrgsResponse>;
+
+export interface AdminGetHookRequest {
+  /** id of the hook to get */
+  id: number;
+}
+export const AdminGetHookRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/admin/hooks/{id}", code: 200 })),
+).annotate({
+  identifier: "AdminGetHookRequest",
+}) as any as S.Schema<AdminGetHookRequest>;
+
+export interface AdminGetQuotaGroupRequest {
+  /** quota group to query */
+  quotagroup: string;
+}
+export const AdminGetQuotaGroupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    quotagroup: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/admin/quota/groups/{quotagroup}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminGetQuotaGroupRequest",
+}) as any as S.Schema<AdminGetQuotaGroupRequest>;
+
+export interface AdminGetQuotaRuleRequest {
+  /** quota rule to query */
+  quotarule: string;
+}
+export const AdminGetQuotaRuleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    quotarule: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/admin/quota/rules/{quotarule}", code: 200 }),
+  ),
+).annotate({
+  identifier: "AdminGetQuotaRuleRequest",
+}) as any as S.Schema<AdminGetQuotaRuleRequest>;
+
+export interface AdminGetUserQuotaRequest {
+  /** username of user to query */
+  username: string;
+}
+export const AdminGetUserQuotaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/admin/users/{username}/quota", code: 200 }),
+  ),
+).annotate({
+  identifier: "AdminGetUserQuotaRequest",
+}) as any as S.Schema<AdminGetUserQuotaRequest>;
+
+/** 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 AdminListHooksRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const AdminListHooksRequest = /*@__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: "/admin/hooks", code: 200 })),
+).annotate({
+  identifier: "AdminListHooksRequest",
+}) as any as S.Schema<AdminListHooksRequest>;
+
+export type AdminListHooksResponseBodyList = Array<Hook>;
+export const AdminListHooksResponseBodyList = /*@__PURE__*/ S.Array(
+  Hook,
+) as any as S.Schema<AdminListHooksResponseBodyList>;
+
+export type AdminListHooksResponse = AdminListHooksResponseBodyList;
+export const AdminListHooksResponse = /*@__PURE__*/ S.suspend(() =>
+  AdminListHooksResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "AdminListHooksResponse",
+}) as any as S.Schema<AdminListHooksResponse>;
+
+export interface AdminListQuotaGroupsRequest {}
+export const AdminListQuotaGroupsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/admin/quota/groups", code: 200 }),
+  ),
+).annotate({
+  identifier: "AdminListQuotaGroupsRequest",
+}) as any as S.Schema<AdminListQuotaGroupsRequest>;
+
+export type AdminListQuotaGroupsResponse = QuotaGroupList;
+export const AdminListQuotaGroupsResponse = /*@__PURE__*/ S.suspend(() =>
+  QuotaGroupList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "AdminListQuotaGroupsResponse",
+}) as any as S.Schema<AdminListQuotaGroupsResponse>;
+
+export interface AdminListQuotaRulesRequest {}
+export const AdminListQuotaRulesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/admin/quota/rules", code: 200 }),
+  ),
+).annotate({
+  identifier: "AdminListQuotaRulesRequest",
+}) as any as S.Schema<AdminListQuotaRulesRequest>;
+
+export type AdminListQuotaRulesResponseBodyList = Array<QuotaRuleInfo>;
+export const AdminListQuotaRulesResponseBodyList = /*@__PURE__*/ S.Array(
+  QuotaRuleInfo,
+) as any as S.Schema<AdminListQuotaRulesResponseBodyList>;
+
+export type AdminListQuotaRulesResponse = AdminListQuotaRulesResponseBodyList;
+export const AdminListQuotaRulesResponse = /*@__PURE__*/ S.suspend(() =>
+  AdminListQuotaRulesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "AdminListQuotaRulesResponse",
+}) as any as S.Schema<AdminListQuotaRulesResponse>;
+
+export interface AdminListUserAccessTokensRequest {
+  /** username of user */
+  username: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const AdminListUserAccessTokensRequest = /*@__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: "/admin/users/{username}/tokens", code: 200 }),
+  ),
+).annotate({
+  identifier: "AdminListUserAccessTokensRequest",
+}) as any as S.Schema<AdminListUserAccessTokensRequest>;
+
+export type AdminListUserAccessTokensResponseBodyList = Array<AccessToken>;
+export const AdminListUserAccessTokensResponseBodyList = /*@__PURE__*/ S.Array(
+  AccessToken,
+) as any as S.Schema<AdminListUserAccessTokensResponseBodyList>;
+
+export type AdminListUserAccessTokensResponse =
+  AdminListUserAccessTokensResponseBodyList;
+export const AdminListUserAccessTokensResponse = /*@__PURE__*/ S.suspend(() =>
+  AdminListUserAccessTokensResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "AdminListUserAccessTokensResponse",
+}) as any as S.Schema<AdminListUserAccessTokensResponse>;
+
+export interface AdminListUserEmailsRequest {
+  /** username of user to get email addresses of */
+  username: string;
+}
+export const AdminListUserEmailsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/admin/users/{username}/emails", code: 200 }),
+  ),
+).annotate({
+  identifier: "AdminListUserEmailsRequest",
+}) as any as S.Schema<AdminListUserEmailsRequest>;
+
+export type AdminListUserEmailsResponseBodyList = Array<Email>;
+export const AdminListUserEmailsResponseBodyList = /*@__PURE__*/ S.Array(
+  Email,
+) as any as S.Schema<AdminListUserEmailsResponseBodyList>;
+
+export type AdminListUserEmailsResponse = AdminListUserEmailsResponseBodyList;
+export const AdminListUserEmailsResponse = /*@__PURE__*/ S.suspend(() =>
+  AdminListUserEmailsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "AdminListUserEmailsResponse",
+}) as any as S.Schema<AdminListUserEmailsResponse>;
+
+export interface AdminListUsersInQuotaGroupRequest {
+  /** quota group to list members of */
+  quotagroup: string;
+}
+export const AdminListUsersInQuotaGroupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    quotagroup: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/admin/quota/groups/{quotagroup}/users",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminListUsersInQuotaGroupRequest",
+}) as any as S.Schema<AdminListUsersInQuotaGroupRequest>;
+
+export type AdminListUsersInQuotaGroupResponseBodyList = Array<User>;
+export const AdminListUsersInQuotaGroupResponseBodyList = /*@__PURE__*/ S.Array(
+  User,
+) as any as S.Schema<AdminListUsersInQuotaGroupResponseBodyList>;
+
+export type AdminListUsersInQuotaGroupResponse =
+  AdminListUsersInQuotaGroupResponseBodyList;
+export const AdminListUsersInQuotaGroupResponse = /*@__PURE__*/ S.suspend(() =>
+  AdminListUsersInQuotaGroupResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "AdminListUsersInQuotaGroupResponse",
+}) as any as S.Schema<AdminListUsersInQuotaGroupResponse>;
+
+export interface AdminRemoveRuleFromQuotaGroupRequest {
+  /** quota group to remove a rule from */
+  quotagroup: string;
+  /** the name of the quota rule to remove from the group */
+  quotarule: string;
+}
+export const AdminRemoveRuleFromQuotaGroupRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      quotagroup: S.String.pipe(T.Label()),
+      quotarule: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/admin/quota/groups/{quotagroup}/rules/{quotarule}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "AdminRemoveRuleFromQuotaGroupRequest",
+}) as any as S.Schema<AdminRemoveRuleFromQuotaGroupRequest>;
+
+export interface AdminRemoveRuleFromQuotaGroupResponse {}
+export const AdminRemoveRuleFromQuotaGroupResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "AdminRemoveRuleFromQuotaGroupResponse",
+}) as any as S.Schema<AdminRemoveRuleFromQuotaGroupResponse>;
+
+export interface AdminRemoveUserFromQuotaGroupRequest {
+  /** quota group to remove a user from */
+  quotagroup: string;
+  /** username of the user to remove from the quota group */
+  username: string;
+}
+export const AdminRemoveUserFromQuotaGroupRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      quotagroup: S.String.pipe(T.Label()),
+      username: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/admin/quota/groups/{quotagroup}/users/{username}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "AdminRemoveUserFromQuotaGroupRequest",
+}) as any as S.Schema<AdminRemoveUserFromQuotaGroupRequest>;
+
+export interface AdminRemoveUserFromQuotaGroupResponse {}
+export const AdminRemoveUserFromQuotaGroupResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "AdminRemoveUserFromQuotaGroupResponse",
+}) as any as S.Schema<AdminRemoveUserFromQuotaGroupResponse>;
+
+export interface AdminRenameUserRequest {
+  /** existing username of user */
+  username: string;
+  /** New username for this user. This name cannot be in use yet by any other user. */
+  new_username: string;
+}
+export const AdminRenameUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    new_username: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/admin/users/{username}/rename",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminRenameUserRequest",
+}) as any as S.Schema<AdminRenameUserRequest>;
+
+export interface AdminRenameUserResponse {}
+export const AdminRenameUserResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AdminRenameUserResponse",
+}) as any as S.Schema<AdminRenameUserResponse>;
+
+export interface AdminSearchEmailsRequest {
+  /** keyword */
+  q?: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const AdminSearchEmailsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    q: 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: "/admin/emails/search", code: 200 })),
+).annotate({
+  identifier: "AdminSearchEmailsRequest",
+}) as any as S.Schema<AdminSearchEmailsRequest>;
+
+export type AdminSearchEmailsResponseBodyList = Array<Email>;
+export const AdminSearchEmailsResponseBodyList = /*@__PURE__*/ S.Array(
+  Email,
+) as any as S.Schema<AdminSearchEmailsResponseBodyList>;
+
+export type AdminSearchEmailsResponse = AdminSearchEmailsResponseBodyList;
+export const AdminSearchEmailsResponse = /*@__PURE__*/ S.suspend(() =>
+  AdminSearchEmailsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "AdminSearchEmailsResponse",
+}) as any as S.Schema<AdminSearchEmailsResponse>;
+
+export type AdminSearchUsersRequestSort =
+  | "oldest"
+  | "newest"
+  | "alphabetically"
+  | "reversealphabetically"
+  | "recentupdate"
+  | "leastupdate";
+export const AdminSearchUsersRequestSort = /*@__PURE__*/ S.String;
+
+export interface AdminSearchUsersRequest {
+  /** ID of the user's login source to search for */
+  source_id?: number;
+  /** user's login name to search for */
+  login_name?: string;
+  /** whether or not to filter users with the 2fa enabled */
+  is_2fa_enabled?: boolean;
+  /** sort order of results */
+  sort?: AdminSearchUsersRequestSort | (string & {});
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const AdminSearchUsersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    source_id: S.optional(S.Number.pipe(T.Query())),
+    login_name: S.optional(S.String.pipe(T.Query())),
+    is_2fa_enabled: S.optional(S.Boolean.pipe(T.Query())),
+    sort: S.optional(AdminSearchUsersRequestSort.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: "/admin/users", code: 200 })),
+).annotate({
+  identifier: "AdminSearchUsersRequest",
+}) as any as S.Schema<AdminSearchUsersRequest>;
+
+export type AdminSearchUsersResponseBodyList = Array<User>;
+export const AdminSearchUsersResponseBodyList = /*@__PURE__*/ S.Array(
+  User,
+) as any as S.Schema<AdminSearchUsersResponseBodyList>;
+
+export type AdminSearchUsersResponse = AdminSearchUsersResponseBodyList;
+export const AdminSearchUsersResponse = /*@__PURE__*/ S.suspend(() =>
+  AdminSearchUsersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "AdminSearchUsersResponse",
+}) as any as S.Schema<AdminSearchUsersResponse>;
+
+/** Quota groups the user shall have */
+export type AdminSetUserQuotaGroupsRequestGroupsList = Array<string>;
+export const AdminSetUserQuotaGroupsRequestGroupsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<AdminSetUserQuotaGroupsRequestGroupsList>;
+
+export interface AdminSetUserQuotaGroupsRequest {
+  /** username of the user to modify the quota groups from */
+  username: string;
+  /** Quota groups the user shall have */
+  groups: AdminSetUserQuotaGroupsRequestGroupsList;
+}
+export const AdminSetUserQuotaGroupsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    groups: AdminSetUserQuotaGroupsRequestGroupsList,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/admin/users/{username}/quota/groups",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AdminSetUserQuotaGroupsRequest",
+}) as any as S.Schema<AdminSetUserQuotaGroupsRequest>;
+
+export interface AdminSetUserQuotaGroupsResponse {}
+export const AdminSetUserQuotaGroupsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AdminSetUserQuotaGroupsResponse",
+}) as any as S.Schema<AdminSetUserQuotaGroupsResponse>;
+
+export interface DeleteAdminRunnerRequest {
+  /** ID of the runner */
+  runner_id: string;
+}
+export const DeleteAdminRunnerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    runner_id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/admin/actions/runners/{runner_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteAdminRunnerRequest",
+}) as any as S.Schema<DeleteAdminRunnerRequest>;
+
+export interface DeleteAdminRunnerResponse {}
+export const DeleteAdminRunnerResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteAdminRunnerResponse",
+}) as any as S.Schema<DeleteAdminRunnerResponse>;
+
+export interface GetAdminRunnerRequest {
+  /** ID of the runner */
+  runner_id: string;
+}
+export const GetAdminRunnerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    runner_id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/admin/actions/runners/{runner_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetAdminRunnerRequest",
+}) as any as S.Schema<GetAdminRunnerRequest>;
+
+/** 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 GetAdminRunnersRequest {
+  /** whether to include all visible runners (true) or only those that are directly owned by the instance (false) */
+  visible?: boolean;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const GetAdminRunnersRequest = /*@__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: "/admin/actions/runners", code: 200 })),
+).annotate({
+  identifier: "GetAdminRunnersRequest",
+}) as any as S.Schema<GetAdminRunnersRequest>;
+
+export type GetAdminRunnersResponseBodyList = Array<ActionRunner>;
+export const GetAdminRunnersResponseBodyList = /*@__PURE__*/ S.Array(
+  ActionRunner,
+) as any as S.Schema<GetAdminRunnersResponseBodyList>;
+
+export type GetAdminRunnersResponse = GetAdminRunnersResponseBodyList;
+export const GetAdminRunnersResponse = /*@__PURE__*/ S.suspend(() =>
+  GetAdminRunnersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetAdminRunnersResponse",
+}) as any as S.Schema<GetAdminRunnersResponse>;
+
+export interface ListAdminCronRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const ListAdminCronRequest = /*@__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: "/admin/cron", code: 200 })),
+).annotate({
+  identifier: "ListAdminCronRequest",
+}) as any as S.Schema<ListAdminCronRequest>;
+
+/** Cron represents a Cron task */
+export interface Cron {
+  exec_times?: number;
+  name?: string;
+  next?: string;
+  prev?: string;
+  schedule?: string;
+}
+export const Cron = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    exec_times: S.optional(S.Number),
+    name: S.optional(S.String),
+    next: S.optional(S.String),
+    prev: S.optional(S.String),
+    schedule: S.optional(S.String),
+  }),
+).annotate({ identifier: "Cron" }) as any as S.Schema<Cron>;
+
+export type ListAdminCronResponseBodyList = Array<Cron>;
+export const ListAdminCronResponseBodyList = /*@__PURE__*/ S.Array(
+  Cron,
+) as any as S.Schema<ListAdminCronResponseBodyList>;
+
+export type ListAdminCronResponse = ListAdminCronResponseBodyList;
+export const ListAdminCronResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAdminCronResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAdminCronResponse",
+}) as any as S.Schema<ListAdminCronResponse>;
+
+export interface ListAdminUnadoptedRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+  /** pattern of repositories to search for */
+  pattern?: string;
+}
+export const ListAdminUnadoptedRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+    pattern: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/admin/unadopted", code: 200 })),
+).annotate({
+  identifier: "ListAdminUnadoptedRequest",
+}) as any as S.Schema<ListAdminUnadoptedRequest>;
+
+export type ListAdminUnadoptedResponseBodyList = Array<string>;
+export const ListAdminUnadoptedResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListAdminUnadoptedResponseBodyList>;
+
+export type ListAdminUnadoptedResponse = ListAdminUnadoptedResponseBodyList;
+export const ListAdminUnadoptedResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAdminUnadoptedResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAdminUnadoptedResponse",
+}) as any as S.Schema<ListAdminUnadoptedResponse>;
+
+export interface RegisterAdminRunnerRequest {
+  /** Description of the runner to register. */
+  description?: string;
+  /** Register as ephemeral runner https://forgejo.org/docs/latest/admin/actions/security/#ephemeral-runner */
+  ephemeral?: boolean;
+  /** Name of the runner to register. The name of the runner does not have to be unique. */
+  name: string;
+}
+export const RegisterAdminRunnerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    ephemeral: S.optional(S.Boolean),
+    name: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/admin/actions/runners", code: 200 })),
+).annotate({
+  identifier: "RegisterAdminRunnerRequest",
+}) as any as S.Schema<RegisterAdminRunnerRequest>;
+
+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 interface RunAdminCronRequest {
+  /** task to run */
+  task: string;
+}
+export const RunAdminCronRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    task: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "POST", uri: "/admin/cron/{task}", code: 200 })),
+).annotate({
+  identifier: "RunAdminCronRequest",
+}) as any as S.Schema<RunAdminCronRequest>;
+
+export interface RunAdminCronResponse {}
+export const RunAdminCronResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "RunAdminCronResponse",
+}) as any as S.Schema<RunAdminCronResponse>;
+
+export type AdminAddRuleToQuotaGroupError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | Conflict
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Adds a rule to a quota group */
+export const adminAddRuleToQuotaGroup: API.OperationMethod<
+  AdminAddRuleToQuotaGroupRequest,
+  AdminAddRuleToQuotaGroupResponse,
+  AdminAddRuleToQuotaGroupError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminAddRuleToQuotaGroupRequest,
+  output: AdminAddRuleToQuotaGroupResponse,
+  errors: [BadRequest, Forbidden, NotFound, Conflict, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminAddUserToQuotaGroupError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | Conflict
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Add a user to a quota group */
+export const adminAddUserToQuotaGroup: API.OperationMethod<
+  AdminAddUserToQuotaGroupRequest,
+  AdminAddUserToQuotaGroupResponse,
+  AdminAddUserToQuotaGroupError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminAddUserToQuotaGroupRequest,
+  output: AdminAddUserToQuotaGroupResponse,
+  errors: [BadRequest, Forbidden, NotFound, Conflict, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminAdoptRepositoryError = Forbidden | NotFound | ForgejoOpError;
+/** Adopt unadopted files as a repository */
+export const adminAdoptRepository: API.OperationMethod<
+  AdminAdoptRepositoryRequest,
+  AdminAdoptRepositoryResponse,
+  AdminAdoptRepositoryError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminAdoptRepositoryRequest,
+  output: AdminAdoptRepositoryResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminCreateHookError = ForgejoOpError;
+/** Create a hook */
+export const adminCreateHook: API.OperationMethod<
+  AdminCreateHookRequest,
+  Hook,
+  AdminCreateHookError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminCreateHookRequest,
+  output: Hook,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminCreateOrgError =
+  | Forbidden
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Create an organization */
+export const adminCreateOrg: API.OperationMethod<
+  AdminCreateOrgRequest,
+  Organization,
+  AdminCreateOrgError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminCreateOrgRequest,
+  output: Organization,
+  errors: [Forbidden, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminCreatePublicKeyError =
+  | Forbidden
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Add an SSH public key to user's account */
+export const adminCreatePublicKey: API.OperationMethod<
+  AdminCreatePublicKeyRequest,
+  PublicKey,
+  AdminCreatePublicKeyError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminCreatePublicKeyRequest,
+  output: PublicKey,
+  errors: [Forbidden, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminCreateQuotaGroupError =
+  | BadRequest
+  | Forbidden
+  | Conflict
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Create a new quota group */
+export const adminCreateQuotaGroup: API.OperationMethod<
+  AdminCreateQuotaGroupRequest,
+  QuotaGroup,
+  AdminCreateQuotaGroupError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminCreateQuotaGroupRequest,
+  output: QuotaGroup,
+  errors: [BadRequest, Forbidden, Conflict, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminCreateQuotaRuleError =
+  | BadRequest
+  | Forbidden
+  | Conflict
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Create a new quota rule */
+export const adminCreateQuotaRule: API.OperationMethod<
+  AdminCreateQuotaRuleRequest,
+  QuotaRuleInfo,
+  AdminCreateQuotaRuleError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminCreateQuotaRuleRequest,
+  output: QuotaRuleInfo,
+  errors: [BadRequest, Forbidden, Conflict, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminCreateRepoError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | Conflict
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Create a repository on behalf of a user */
+export const adminCreateRepo: API.OperationMethod<
+  AdminCreateRepoRequest,
+  Repository,
+  AdminCreateRepoError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminCreateRepoRequest,
+  output: Repository,
+  errors: [BadRequest, Forbidden, NotFound, Conflict, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminCreateUserError =
+  | BadRequest
+  | Forbidden
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Create a user account */
+export const adminCreateUser: API.OperationMethod<
+  AdminCreateUserRequest,
+  User,
+  AdminCreateUserError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminCreateUserRequest,
+  output: User,
+  errors: [BadRequest, Forbidden, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminCreateUserAccessTokenError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Create an access token for the specified user */
+export const adminCreateUserAccessToken: API.OperationMethod<
+  AdminCreateUserAccessTokenRequest,
+  AccessToken,
+  AdminCreateUserAccessTokenError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminCreateUserAccessTokenRequest,
+  output: AccessToken,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminDeleteHookError = ForgejoOpError;
+/** Delete a hook */
+export const adminDeleteHook: API.OperationMethod<
+  AdminDeleteHookRequest,
+  AdminDeleteHookResponse,
+  AdminDeleteHookError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminDeleteHookRequest,
+  output: AdminDeleteHookResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminDeleteQuotaGroupError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Delete a quota group */
+export const adminDeleteQuotaGroup: API.OperationMethod<
+  AdminDeleteQuotaGroupRequest,
+  AdminDeleteQuotaGroupResponse,
+  AdminDeleteQuotaGroupError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminDeleteQuotaGroupRequest,
+  output: AdminDeleteQuotaGroupResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminDeleteQuotaRuleError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Deletes a quota rule */
+export const adminDeleteQuotaRule: API.OperationMethod<
+  AdminDeleteQuotaRuleRequest,
+  AdminDeleteQuotaRuleResponse,
+  AdminDeleteQuotaRuleError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminDeleteQuotaRuleRequest,
+  output: AdminDeleteQuotaRuleResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminDeleteUnadoptedRepositoryError = Forbidden | ForgejoOpError;
+/** Delete unadopted files */
+export const adminDeleteUnadoptedRepository: API.OperationMethod<
+  AdminDeleteUnadoptedRepositoryRequest,
+  AdminDeleteUnadoptedRepositoryResponse,
+  AdminDeleteUnadoptedRepositoryError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminDeleteUnadoptedRepositoryRequest,
+  output: AdminDeleteUnadoptedRepositoryResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminDeleteUserError =
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Delete user account */
+export const adminDeleteUser: API.OperationMethod<
+  AdminDeleteUserRequest,
+  AdminDeleteUserResponse,
+  AdminDeleteUserError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminDeleteUserRequest,
+  output: AdminDeleteUserResponse,
+  errors: [Forbidden, NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminDeleteUserAccessTokenError =
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Delete an access token for the specified user */
+export const adminDeleteUserAccessToken: API.OperationMethod<
+  AdminDeleteUserAccessTokenRequest,
+  AdminDeleteUserAccessTokenResponse,
+  AdminDeleteUserAccessTokenError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminDeleteUserAccessTokenRequest,
+  output: AdminDeleteUserAccessTokenResponse,
+  errors: [Forbidden, NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminDeleteUserEmailsError =
+  | Forbidden
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Delete email addresses from a user's account */
+export const adminDeleteUserEmails: API.OperationMethod<
+  AdminDeleteUserEmailsRequest,
+  AdminDeleteUserEmailsResponse,
+  AdminDeleteUserEmailsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminDeleteUserEmailsRequest,
+  output: AdminDeleteUserEmailsResponse,
+  errors: [Forbidden, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminDeleteUserPublicKeyError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Remove a public key from user's account */
+export const adminDeleteUserPublicKey: API.OperationMethod<
+  AdminDeleteUserPublicKeyRequest,
+  AdminDeleteUserPublicKeyResponse,
+  AdminDeleteUserPublicKeyError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminDeleteUserPublicKeyRequest,
+  output: AdminDeleteUserPublicKeyResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminEditHookError = ForgejoOpError;
+/** Update a hook */
+export const adminEditHook: API.OperationMethod<
+  AdminEditHookRequest,
+  Hook,
+  AdminEditHookError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminEditHookRequest,
+  output: Hook,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminEditQuotaRuleError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Change an existing quota rule */
+export const adminEditQuotaRule: API.OperationMethod<
+  AdminEditQuotaRuleRequest,
+  QuotaRuleInfo,
+  AdminEditQuotaRuleError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminEditQuotaRuleRequest,
+  output: QuotaRuleInfo,
+  errors: [BadRequest, Forbidden, NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminEditUserError =
+  | BadRequest
+  | Forbidden
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Edit an existing user */
+export const adminEditUser: API.OperationMethod<
+  AdminEditUserRequest,
+  User,
+  AdminEditUserError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminEditUserRequest,
+  output: User,
+  errors: [BadRequest, Forbidden, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminGetActionRunJobsError = Forbidden | ForgejoOpError;
+/** Get action run jobs */
+export const adminGetActionRunJobs: API.OperationMethod<
+  AdminGetActionRunJobsRequest,
+  AdminGetActionRunJobsResponse,
+  AdminGetActionRunJobsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminGetActionRunJobsRequest,
+  output: AdminGetActionRunJobsResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminGetAllEmailsError = Forbidden | ForgejoOpError;
+/** List all users' email addresses */
+export const adminGetAllEmails: API.OperationMethod<
+  AdminGetAllEmailsRequest,
+  AdminGetAllEmailsResponse,
+  AdminGetAllEmailsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminGetAllEmailsRequest,
+  output: AdminGetAllEmailsResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminGetAllOrgsError = Forbidden | ForgejoOpError;
+/** List all organizations */
+export const adminGetAllOrgs: API.OperationMethod<
+  AdminGetAllOrgsRequest,
+  AdminGetAllOrgsResponse,
+  AdminGetAllOrgsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminGetAllOrgsRequest,
+  output: AdminGetAllOrgsResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminGetHookError = ForgejoOpError;
+/** Get a hook */
+export const adminGetHook: API.OperationMethod<
+  AdminGetHookRequest,
+  Hook,
+  AdminGetHookError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminGetHookRequest,
+  output: Hook,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminGetQuotaGroupError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Get information about the quota group */
+export const adminGetQuotaGroup: API.OperationMethod<
+  AdminGetQuotaGroupRequest,
+  QuotaGroup,
+  AdminGetQuotaGroupError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminGetQuotaGroupRequest,
+  output: QuotaGroup,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminGetQuotaRuleError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Get information about a quota rule */
+export const adminGetQuotaRule: API.OperationMethod<
+  AdminGetQuotaRuleRequest,
+  QuotaRuleInfo,
+  AdminGetQuotaRuleError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminGetQuotaRuleRequest,
+  output: QuotaRuleInfo,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminGetUserQuotaError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Get the user's quota info */
+export const adminGetUserQuota: API.OperationMethod<
+  AdminGetUserQuotaRequest,
+  QuotaInfo,
+  AdminGetUserQuotaError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminGetUserQuotaRequest,
+  output: QuotaInfo,
+  errors: [BadRequest, Forbidden, NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminListHooksError = ForgejoOpError;
+/** List global (system) webhooks */
+export const adminListHooks: API.OperationMethod<
+  AdminListHooksRequest,
+  AdminListHooksResponse,
+  AdminListHooksError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminListHooksRequest,
+  output: AdminListHooksResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminListQuotaGroupsError = Forbidden | ForgejoOpError;
+/** List the available quota groups */
+export const adminListQuotaGroups: API.OperationMethod<
+  AdminListQuotaGroupsRequest,
+  AdminListQuotaGroupsResponse,
+  AdminListQuotaGroupsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminListQuotaGroupsRequest,
+  output: AdminListQuotaGroupsResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminListQuotaRulesError = Forbidden | ForgejoOpError;
+/** List the available quota rules */
+export const adminListQuotaRules: API.OperationMethod<
+  AdminListQuotaRulesRequest,
+  AdminListQuotaRulesResponse,
+  AdminListQuotaRulesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminListQuotaRulesRequest,
+  output: AdminListQuotaRulesResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminListUserAccessTokensError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** List the specified user's access tokens */
+export const adminListUserAccessTokens: API.OperationMethod<
+  AdminListUserAccessTokensRequest,
+  AdminListUserAccessTokensResponse,
+  AdminListUserAccessTokensError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminListUserAccessTokensRequest,
+  output: AdminListUserAccessTokensResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminListUserEmailsError = Forbidden | NotFound | ForgejoOpError;
+/** List all email addresses for a user */
+export const adminListUserEmails: API.OperationMethod<
+  AdminListUserEmailsRequest,
+  AdminListUserEmailsResponse,
+  AdminListUserEmailsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminListUserEmailsRequest,
+  output: AdminListUserEmailsResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminListUsersInQuotaGroupError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** List users in a quota group */
+export const adminListUsersInQuotaGroup: API.OperationMethod<
+  AdminListUsersInQuotaGroupRequest,
+  AdminListUsersInQuotaGroupResponse,
+  AdminListUsersInQuotaGroupError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminListUsersInQuotaGroupRequest,
+  output: AdminListUsersInQuotaGroupResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminRemoveRuleFromQuotaGroupError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Removes a rule from a quota group */
+export const adminRemoveRuleFromQuotaGroup: API.OperationMethod<
+  AdminRemoveRuleFromQuotaGroupRequest,
+  AdminRemoveRuleFromQuotaGroupResponse,
+  AdminRemoveRuleFromQuotaGroupError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminRemoveRuleFromQuotaGroupRequest,
+  output: AdminRemoveRuleFromQuotaGroupResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminRemoveUserFromQuotaGroupError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Remove a user from a quota group */
+export const adminRemoveUserFromQuotaGroup: API.OperationMethod<
+  AdminRemoveUserFromQuotaGroupRequest,
+  AdminRemoveUserFromQuotaGroupResponse,
+  AdminRemoveUserFromQuotaGroupError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminRemoveUserFromQuotaGroupRequest,
+  output: AdminRemoveUserFromQuotaGroupResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminRenameUserError =
+  | Forbidden
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Rename a user */
+export const adminRenameUser: API.OperationMethod<
+  AdminRenameUserRequest,
+  AdminRenameUserResponse,
+  AdminRenameUserError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminRenameUserRequest,
+  output: AdminRenameUserResponse,
+  errors: [Forbidden, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminSearchEmailsError = Forbidden | ForgejoOpError;
+/** Search users' email addresses */
+export const adminSearchEmails: API.OperationMethod<
+  AdminSearchEmailsRequest,
+  AdminSearchEmailsResponse,
+  AdminSearchEmailsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminSearchEmailsRequest,
+  output: AdminSearchEmailsResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminSearchUsersError = Forbidden | ForgejoOpError;
+/** Search users according filter conditions */
+export const adminSearchUsers: API.OperationMethod<
+  AdminSearchUsersRequest,
+  AdminSearchUsersResponse,
+  AdminSearchUsersError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminSearchUsersRequest,
+  output: AdminSearchUsersResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AdminSetUserQuotaGroupsError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Set the user's quota groups to a given list. */
+export const adminSetUserQuotaGroups: API.OperationMethod<
+  AdminSetUserQuotaGroupsRequest,
+  AdminSetUserQuotaGroupsResponse,
+  AdminSetUserQuotaGroupsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AdminSetUserQuotaGroupsRequest,
+  output: AdminSetUserQuotaGroupsResponse,
+  errors: [BadRequest, Forbidden, NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteAdminRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Delete a particular runner, no matter whether it is a global runner or scoped to an organization, user, or repository */
+export const deleteAdminRunner: API.OperationMethod<
+  DeleteAdminRunnerRequest,
+  DeleteAdminRunnerResponse,
+  DeleteAdminRunnerError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteAdminRunnerRequest,
+  output: DeleteAdminRunnerResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Get a particular runner, no matter whether it is a global runner or scoped to an organization, user, or repository */
+export const getAdminRunner: API.OperationMethod<
+  GetAdminRunnerRequest,
+  ActionRunner,
+  GetAdminRunnerError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminRunnerRequest,
+  output: ActionRunner,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAdminRunnersError = BadRequest | NotFound | ForgejoOpError;
+/** Get all runners, no matter whether they are global runners or scoped to an organization, user, or repository */
+export const getAdminRunners: API.OperationMethod<
+  GetAdminRunnersRequest,
+  GetAdminRunnersResponse,
+  GetAdminRunnersError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAdminRunnersRequest,
+  output: GetAdminRunnersResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAdminCronError = Forbidden | ForgejoOpError;
+/** List cron tasks */
+export const listAdminCron: API.OperationMethod<
+  ListAdminCronRequest,
+  ListAdminCronResponse,
+  ListAdminCronError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAdminCronRequest,
+  output: ListAdminCronResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAdminUnadoptedError = Forbidden | ForgejoOpError;
+/** List unadopted repositories */
+export const listAdminUnadopted: API.OperationMethod<
+  ListAdminUnadoptedRequest,
+  ListAdminUnadoptedResponse,
+  ListAdminUnadoptedError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAdminUnadoptedRequest,
+  output: ListAdminUnadoptedResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RegisterAdminRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Register a new global runner */
+export const registerAdminRunner: API.OperationMethod<
+  RegisterAdminRunnerRequest,
+  RegisterRunnerResponse,
+  RegisterAdminRunnerError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RegisterAdminRunnerRequest,
+  output: RegisterRunnerResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RunAdminCronError = NotFound | ForgejoOpError;
+/** Run cron task */
+export const runAdminCron: API.OperationMethod<
+  RunAdminCronRequest,
+  RunAdminCronResponse,
+  RunAdminCronError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RunAdminCronRequest,
+  output: RunAdminCronResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));