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

package/src/services/issue.ts

@@ -0,0 +1,3949 @@
+// 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 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 Locked
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<Locked>()("Locked", {
+      code: S.Number,
+      message: S.String,
+    }),
+    [{ status: 423 }],
+  ) {}
+
+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 type CreateIssueRequestAssigneesList = Array<string>;
+export const CreateIssueRequestAssigneesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CreateIssueRequestAssigneesList>;
+
+/** list of label ids */
+export type CreateIssueRequestLabelsList = Array<number>;
+export const CreateIssueRequestLabelsList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<CreateIssueRequestLabelsList>;
+
+export interface CreateIssueRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** deprecated */
+  assignee?: string;
+  assignees?: CreateIssueRequestAssigneesList;
+  body?: string;
+  closed?: boolean;
+  due_date?: string;
+  /** list of label ids */
+  labels?: CreateIssueRequestLabelsList;
+  /** milestone id */
+  milestone?: number;
+  ref?: string;
+  title: string;
+}
+export const CreateIssueRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    assignee: S.optional(S.String),
+    assignees: S.optional(CreateIssueRequestAssigneesList),
+    body: S.optional(S.String),
+    closed: S.optional(S.Boolean),
+    due_date: S.optional(S.String),
+    labels: S.optional(CreateIssueRequestLabelsList),
+    milestone: S.optional(S.Number),
+    ref: S.optional(S.String),
+    title: S.String,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/repos/{owner}/{repo}/issues", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateIssueRequest",
+}) as any as S.Schema<CreateIssueRequest>;
+
+export type AttachmentType = "attachment" | "external";
+export const AttachmentType = /*@__PURE__*/ S.String;
+
+/** Attachment a generic attachment */
+export interface Attachment {
+  browser_download_url?: string;
+  created_at?: string;
+  download_count?: number;
+  id?: number;
+  name?: string;
+  size?: number;
+  type?: AttachmentType;
+  uuid?: string;
+}
+export const Attachment = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    browser_download_url: S.optional(S.String),
+    created_at: S.optional(S.String),
+    download_count: S.optional(S.Number),
+    id: S.optional(S.Number),
+    name: S.optional(S.String),
+    size: S.optional(S.Number),
+    type: S.optional(AttachmentType),
+    uuid: S.optional(S.String),
+  }),
+).annotate({ identifier: "Attachment" }) as any as S.Schema<Attachment>;
+
+export type IssueAssetsList = Array<Attachment>;
+export const IssueAssetsList = /*@__PURE__*/ S.Array(
+  Attachment,
+) as any as S.Schema<IssueAssetsList>;
+
+/** User represents a user */
+export interface User {
+  /** Is user active */
+  active?: boolean;
+  /** URL to the user's avatar */
+  avatar_url?: string;
+  created?: string;
+  /** the user's description */
+  description?: string;
+  email?: string;
+  /** user counts */
+  followers_count?: number;
+  following_count?: number;
+  /** the user's full name */
+  full_name?: string;
+  /** URL to the user's profile page */
+  html_url?: string;
+  /** the user's id */
+  id: number;
+  /** Is the user an administrator */
+  is_admin?: boolean;
+  /** User locale */
+  language?: string;
+  last_login?: string;
+  /** the user's location */
+  location?: string;
+  /** the user's username */
+  login: string;
+  /** the user's authentication sign-in name. */
+  login_name?: string;
+  /** Is user login prohibited */
+  prohibit_login?: boolean;
+  /** the user's pronouns */
+  pronouns?: string;
+  /** Is user restricted */
+  restricted?: boolean;
+  /** The ID of the user's Authentication Source */
+  source_id?: number;
+  starred_repos_count?: number;
+  /** User visibility level option: public, limited, private */
+  visibility?: string;
+  /** the user's website */
+  website?: string;
+}
+export const User = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    active: S.optional(S.Boolean),
+    avatar_url: S.optional(S.String),
+    created: S.optional(S.String),
+    description: S.optional(S.String),
+    email: S.optional(S.String),
+    followers_count: S.optional(S.Number),
+    following_count: S.optional(S.Number),
+    full_name: S.optional(S.String),
+    html_url: S.optional(S.String),
+    id: S.Number,
+    is_admin: S.optional(S.Boolean),
+    language: S.optional(S.String),
+    last_login: S.optional(S.String),
+    location: S.optional(S.String),
+    login: S.String,
+    login_name: S.optional(S.String),
+    prohibit_login: S.optional(S.Boolean),
+    pronouns: S.optional(S.String),
+    restricted: S.optional(S.Boolean),
+    source_id: S.optional(S.Number),
+    starred_repos_count: S.optional(S.Number),
+    visibility: S.optional(S.String),
+    website: S.optional(S.String),
+  }),
+).annotate({ identifier: "User" }) as any as S.Schema<User>;
+
+export type IssueAssigneesList = Array<User>;
+export const IssueAssigneesList = /*@__PURE__*/ S.Array(
+  User,
+) as any as S.Schema<IssueAssigneesList>;
+
+/** Label a label to an issue or a pr */
+export interface Label {
+  color: string;
+  description?: string;
+  exclusive?: boolean;
+  id: number;
+  is_archived?: boolean;
+  name: string;
+  url?: string;
+}
+export const Label = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    color: S.String,
+    description: S.optional(S.String),
+    exclusive: S.optional(S.Boolean),
+    id: S.Number,
+    is_archived: S.optional(S.Boolean),
+    name: S.String,
+    url: S.optional(S.String),
+  }),
+).annotate({ identifier: "Label" }) as any as S.Schema<Label>;
+
+export type IssueLabelsList = Array<Label>;
+export const IssueLabelsList = /*@__PURE__*/ S.Array(
+  Label,
+) as any as S.Schema<IssueLabelsList>;
+
+/** Milestone milestone is a collection of issues on one repository */
+export interface Milestone {
+  closed_at?: string;
+  closed_issues?: number;
+  created_at?: string;
+  description?: string;
+  due_on?: string;
+  id?: number;
+  open_issues?: number;
+  state?: string;
+  title?: string;
+  updated_at?: string;
+}
+export const Milestone = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    closed_at: S.optional(S.String),
+    closed_issues: S.optional(S.Number),
+    created_at: S.optional(S.String),
+    description: S.optional(S.String),
+    due_on: S.optional(S.String),
+    id: S.optional(S.Number),
+    open_issues: S.optional(S.Number),
+    state: S.optional(S.String),
+    title: S.optional(S.String),
+    updated_at: S.optional(S.String),
+  }),
+).annotate({ identifier: "Milestone" }) as any as S.Schema<Milestone>;
+
+/** PullRequestMeta PR info if an issue is a PR */
+export interface PullRequestMeta {
+  draft?: boolean;
+  html_url?: string;
+  merged?: boolean;
+  merged_at?: string;
+}
+export const PullRequestMeta = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    draft: S.optional(S.Boolean),
+    html_url: S.optional(S.String),
+    merged: S.optional(S.Boolean),
+    merged_at: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "PullRequestMeta",
+}) as any as S.Schema<PullRequestMeta>;
+
+/** 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>;
+
+/** Issue represents an issue in a repository */
+export interface Issue {
+  assets?: IssueAssetsList;
+  assignee?: User;
+  assignees?: IssueAssigneesList;
+  body?: string;
+  closed_at?: string;
+  comments?: number;
+  created_at?: string;
+  due_date?: string;
+  html_url?: string;
+  id?: number;
+  is_locked?: boolean;
+  labels?: IssueLabelsList;
+  milestone?: Milestone;
+  number?: number;
+  original_author?: string;
+  original_author_id?: number;
+  pin_order?: number;
+  pull_request?: PullRequestMeta;
+  ref?: string;
+  repository?: RepositoryMeta;
+  state?: string;
+  title?: string;
+  updated_at?: string;
+  url?: string;
+  user?: User;
+}
+export const Issue = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    assets: S.optional(IssueAssetsList),
+    assignee: S.optional(User),
+    assignees: S.optional(IssueAssigneesList),
+    body: S.optional(S.String),
+    closed_at: S.optional(S.String),
+    comments: S.optional(S.Number),
+    created_at: S.optional(S.String),
+    due_date: S.optional(S.String),
+    html_url: S.optional(S.String),
+    id: S.optional(S.Number),
+    is_locked: S.optional(S.Boolean),
+    labels: S.optional(IssueLabelsList),
+    milestone: S.optional(Milestone),
+    number: S.optional(S.Number),
+    original_author: S.optional(S.String),
+    original_author_id: S.optional(S.Number),
+    pin_order: S.optional(S.Number),
+    pull_request: S.optional(PullRequestMeta),
+    ref: S.optional(S.String),
+    repository: S.optional(RepositoryMeta),
+    state: S.optional(S.String),
+    title: S.optional(S.String),
+    updated_at: S.optional(S.String),
+    url: S.optional(S.String),
+    user: S.optional(User),
+  }),
+).annotate({ identifier: "Issue" }) as any as S.Schema<Issue>;
+
+export interface CreateIssueAttachmentRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** name of the attachment */
+  name?: string;
+  /** time of the attachment's creation. This is a timestamp in RFC 3339 format */
+  updated_at?: string;
+}
+export const CreateIssueAttachmentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    name: S.optional(S.String.pipe(T.Query())),
+    updated_at: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/issues/{index}/assets",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateIssueAttachmentRequest",
+}) as any as S.Schema<CreateIssueAttachmentRequest>;
+
+export interface CreateIssueBlockingRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+}
+export const CreateIssueBlockingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/issues/{index}/blocks",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateIssueBlockingRequest",
+}) as any as S.Schema<CreateIssueBlockingRequest>;
+
+export interface CreateIssueCommentAttachmentRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of the comment */
+  id: number;
+  /** name of the attachment */
+  name?: string;
+  /** time of the attachment's creation. This is a timestamp in RFC 3339 format */
+  updated_at?: string;
+}
+export const CreateIssueCommentAttachmentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+    name: S.optional(S.String.pipe(T.Query())),
+    updated_at: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/issues/comments/{id}/assets",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateIssueCommentAttachmentRequest",
+}) as any as S.Schema<CreateIssueCommentAttachmentRequest>;
+
+export interface CreateIssueDependenciesRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+}
+export const CreateIssueDependenciesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/issues/{index}/dependencies",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateIssueDependenciesRequest",
+}) as any as S.Schema<CreateIssueDependenciesRequest>;
+
+export interface DeleteIssueRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of issue to delete */
+  index: number;
+}
+export const DeleteIssueRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/{index}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteIssueRequest",
+}) as any as S.Schema<DeleteIssueRequest>;
+
+export interface DeleteIssueResponse {}
+export const DeleteIssueResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteIssueResponse",
+}) as any as S.Schema<DeleteIssueResponse>;
+
+export interface DeleteIssueAttachmentRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** id of the attachment to delete */
+  attachment_id: number;
+}
+export const DeleteIssueAttachmentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    attachment_id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/{index}/assets/{attachment_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteIssueAttachmentRequest",
+}) as any as S.Schema<DeleteIssueAttachmentRequest>;
+
+export interface DeleteIssueAttachmentResponse {}
+export const DeleteIssueAttachmentResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteIssueAttachmentResponse",
+}) as any as S.Schema<DeleteIssueAttachmentResponse>;
+
+export interface DeleteIssueCommentAttachmentRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of the comment */
+  id: number;
+  /** id of the attachment to delete */
+  attachment_id: number;
+}
+export const DeleteIssueCommentAttachmentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+    attachment_id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/comments/{id}/assets/{attachment_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteIssueCommentAttachmentRequest",
+}) as any as S.Schema<DeleteIssueCommentAttachmentRequest>;
+
+export interface DeleteIssueCommentAttachmentResponse {}
+export const DeleteIssueCommentAttachmentResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "DeleteIssueCommentAttachmentResponse",
+}) as any as S.Schema<DeleteIssueCommentAttachmentResponse>;
+
+export interface DeleteIssueReactionRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  content?: string;
+}
+export const DeleteIssueReactionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    content: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/{index}/reactions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteIssueReactionRequest",
+}) as any as S.Schema<DeleteIssueReactionRequest>;
+
+export interface DeleteIssueReactionResponse {}
+export const DeleteIssueReactionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteIssueReactionResponse",
+}) as any as S.Schema<DeleteIssueReactionResponse>;
+
+export type EditIssueRequestAssigneesList = Array<string>;
+export const EditIssueRequestAssigneesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<EditIssueRequestAssigneesList>;
+
+export interface EditIssueRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue to edit */
+  index: number;
+  /** deprecated */
+  assignee?: string;
+  assignees?: EditIssueRequestAssigneesList;
+  body?: string;
+  due_date?: string;
+  milestone?: number;
+  ref?: string;
+  state?: string;
+  title?: string;
+  unset_due_date?: boolean;
+  updated_at?: string;
+}
+export const EditIssueRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    assignee: S.optional(S.String),
+    assignees: S.optional(EditIssueRequestAssigneesList),
+    body: S.optional(S.String),
+    due_date: S.optional(S.String),
+    milestone: S.optional(S.Number),
+    ref: S.optional(S.String),
+    state: S.optional(S.String),
+    title: S.optional(S.String),
+    unset_due_date: S.optional(S.Boolean),
+    updated_at: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/repos/{owner}/{repo}/issues/{index}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "EditIssueRequest",
+}) as any as S.Schema<EditIssueRequest>;
+
+export interface EditIssueAttachmentRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** id of the attachment to edit */
+  attachment_id: number;
+  /** (Can only be set if existing attachment is of external type) */
+  browser_download_url?: string;
+  name?: string;
+}
+export const EditIssueAttachmentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    attachment_id: S.Number.pipe(T.Label()),
+    browser_download_url: S.optional(S.String),
+    name: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/repos/{owner}/{repo}/issues/{index}/assets/{attachment_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "EditIssueAttachmentRequest",
+}) as any as S.Schema<EditIssueAttachmentRequest>;
+
+export interface EditIssueCommentAttachmentRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of the comment */
+  id: number;
+  /** id of the attachment to edit */
+  attachment_id: number;
+  /** (Can only be set if existing attachment is of external type) */
+  browser_download_url?: string;
+  name?: string;
+}
+export const EditIssueCommentAttachmentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+    attachment_id: S.Number.pipe(T.Label()),
+    browser_download_url: S.optional(S.String),
+    name: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/repos/{owner}/{repo}/issues/comments/{id}/assets/{attachment_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "EditIssueCommentAttachmentRequest",
+}) as any as S.Schema<EditIssueCommentAttachmentRequest>;
+
+export interface EditIssueDeadlineRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue to create or update a deadline on */
+  index: number;
+  due_date: string;
+}
+export const EditIssueDeadlineRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    due_date: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/issues/{index}/deadline",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "EditIssueDeadlineRequest",
+}) as any as S.Schema<EditIssueDeadlineRequest>;
+
+/** IssueDeadline represents an issue deadline */
+export interface IssueDeadline {
+  due_date?: string;
+}
+export const IssueDeadline = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    due_date: S.optional(S.String),
+  }),
+).annotate({ identifier: "IssueDeadline" }) as any as S.Schema<IssueDeadline>;
+
+export interface GetIssueRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue to get */
+  index: number;
+}
+export const GetIssueRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/repos/{owner}/{repo}/issues/{index}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetIssueRequest",
+}) as any as S.Schema<GetIssueRequest>;
+
+export interface GetIssueAttachmentRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** id of the attachment to get */
+  attachment_id: number;
+}
+export const GetIssueAttachmentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    attachment_id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/repos/{owner}/{repo}/issues/{index}/assets/{attachment_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetIssueAttachmentRequest",
+}) as any as S.Schema<GetIssueAttachmentRequest>;
+
+export interface GetIssueCommentAttachmentRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of the comment */
+  id: number;
+  /** id of the attachment to get */
+  attachment_id: number;
+}
+export const GetIssueCommentAttachmentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+    attachment_id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/repos/{owner}/{repo}/issues/comments/{id}/assets/{attachment_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetIssueCommentAttachmentRequest",
+}) as any as S.Schema<GetIssueCommentAttachmentRequest>;
+
+export interface GetIssueReactionsRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const GetIssueReactionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.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: "/repos/{owner}/{repo}/issues/{index}/reactions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetIssueReactionsRequest",
+}) as any as S.Schema<GetIssueReactionsRequest>;
+
+/** Reaction contain one reaction */
+export interface Reaction {
+  content?: string;
+  created_at?: string;
+  user?: User;
+}
+export const Reaction = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    content: S.optional(S.String),
+    created_at: S.optional(S.String),
+    user: S.optional(User),
+  }),
+).annotate({ identifier: "Reaction" }) as any as S.Schema<Reaction>;
+
+export type GetIssueReactionsResponseBodyList = Array<Reaction>;
+export const GetIssueReactionsResponseBodyList = /*@__PURE__*/ S.Array(
+  Reaction,
+) as any as S.Schema<GetIssueReactionsResponseBodyList>;
+
+export type GetIssueReactionsResponse = GetIssueReactionsResponseBodyList;
+export const GetIssueReactionsResponse = /*@__PURE__*/ S.suspend(() =>
+  GetIssueReactionsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetIssueReactionsResponse",
+}) as any as S.Schema<GetIssueReactionsResponse>;
+
+/** Labels can be a list of integers representing label IDs or a list of strings representing label names */
+export type IssueAddLabelRequestLabelsList = Array<unknown>;
+export const IssueAddLabelRequestLabelsList = /*@__PURE__*/ S.Array(
+  S.Unknown,
+) as any as S.Schema<IssueAddLabelRequestLabelsList>;
+
+export interface IssueAddLabelRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** Labels can be a list of integers representing label IDs or a list of strings representing label names */
+  labels?: IssueAddLabelRequestLabelsList;
+  updated_at?: string;
+}
+export const IssueAddLabelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    labels: S.optional(IssueAddLabelRequestLabelsList),
+    updated_at: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/issues/{index}/labels",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueAddLabelRequest",
+}) as any as S.Schema<IssueAddLabelRequest>;
+
+export type IssueAddLabelResponseBodyList = Array<Label>;
+export const IssueAddLabelResponseBodyList = /*@__PURE__*/ S.Array(
+  Label,
+) as any as S.Schema<IssueAddLabelResponseBodyList>;
+
+export type IssueAddLabelResponse = IssueAddLabelResponseBodyList;
+export const IssueAddLabelResponse = /*@__PURE__*/ S.suspend(() =>
+  IssueAddLabelResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IssueAddLabelResponse",
+}) as any as S.Schema<IssueAddLabelResponse>;
+
+export interface IssueAddSubscriptionRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** user to subscribe */
+  user: string;
+}
+export const IssueAddSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    user: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/repos/{owner}/{repo}/issues/{index}/subscriptions/{user}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueAddSubscriptionRequest",
+}) as any as S.Schema<IssueAddSubscriptionRequest>;
+
+export interface IssueAddSubscriptionResponse {}
+export const IssueAddSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IssueAddSubscriptionResponse",
+}) as any as S.Schema<IssueAddSubscriptionResponse>;
+
+export interface IssueAddTimeRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  created?: string;
+  /** time in seconds */
+  time: number;
+  /** User who spent the time (optional) */
+  user_name?: string;
+}
+export const IssueAddTimeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    created: S.optional(S.String),
+    time: S.Number,
+    user_name: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/issues/{index}/times",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueAddTimeRequest",
+}) as any as S.Schema<IssueAddTimeRequest>;
+
+/** TrackedTime worked time for an issue / pr */
+export interface TrackedTime {
+  created?: string;
+  id?: number;
+  issue?: Issue;
+  /** deprecated (only for backwards compatibility) */
+  issue_id?: number;
+  /** Time in seconds */
+  time?: number;
+  /** deprecated (only for backwards compatibility) */
+  user_id?: number;
+  user_name?: string;
+}
+export const TrackedTime = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    created: S.optional(S.String),
+    id: S.optional(S.Number),
+    issue: S.optional(Issue),
+    issue_id: S.optional(S.Number),
+    time: S.optional(S.Number),
+    user_id: S.optional(S.Number),
+    user_name: S.optional(S.String),
+  }),
+).annotate({ identifier: "TrackedTime" }) as any as S.Schema<TrackedTime>;
+
+export interface IssueCheckSubscriptionRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+}
+export const IssueCheckSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/repos/{owner}/{repo}/issues/{index}/subscriptions/check",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueCheckSubscriptionRequest",
+}) as any as S.Schema<IssueCheckSubscriptionRequest>;
+
+/** WatchInfo represents an API watch status of one repository */
+export interface WatchInfo {
+  created_at?: string;
+  ignored?: boolean;
+  reason?: unknown;
+  repository_url?: string;
+  subscribed?: boolean;
+  url?: string;
+}
+export const WatchInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    created_at: S.optional(S.String),
+    ignored: S.optional(S.Boolean),
+    reason: S.optional(S.Unknown),
+    repository_url: S.optional(S.String),
+    subscribed: S.optional(S.Boolean),
+    url: S.optional(S.String),
+  }),
+).annotate({ identifier: "WatchInfo" }) as any as S.Schema<WatchInfo>;
+
+export interface IssueClearLabelsRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  updated_at?: string;
+}
+export const IssueClearLabelsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    updated_at: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/{index}/labels",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueClearLabelsRequest",
+}) as any as S.Schema<IssueClearLabelsRequest>;
+
+export interface IssueClearLabelsResponse {}
+export const IssueClearLabelsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IssueClearLabelsResponse",
+}) as any as S.Schema<IssueClearLabelsResponse>;
+
+export interface IssueCreateCommentRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** The body of the comment */
+  body: string;
+  /** The time of the comment's update, needs admin or repository owner permission */
+  updated_at?: string;
+}
+export const IssueCreateCommentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    body: S.String,
+    updated_at: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/issues/{index}/comments",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueCreateCommentRequest",
+}) as any as S.Schema<IssueCreateCommentRequest>;
+
+/** The attachments to the comment */
+export type CommentAssetsList = Array<Attachment>;
+export const CommentAssetsList = /*@__PURE__*/ S.Array(
+  Attachment,
+) as any as S.Schema<CommentAssetsList>;
+
+/** Comment represents a comment on a commit or issue */
+export interface Comment {
+  /** The attachments to the comment */
+  assets?: CommentAssetsList;
+  /** The body of the comment */
+  body?: string;
+  /** The time of the comment's creation */
+  created_at?: string;
+  /** The HTML URL of the comment */
+  html_url?: string;
+  /** The identifier of the comment */
+  id?: number;
+  /** The HTML URL of the issue if the comment is posted on an issue, else empty string */
+  issue_url?: string;
+  /** The original author that posted the comment if it was not posted locally, else empty string */
+  original_author?: string;
+  /** The ID of the original author that posted the comment if it was not posted locally, else 0 */
+  original_author_id?: number;
+  /** The HTML URL of the pull request if the comment is posted on a pull request, else empty string */
+  pull_request_url?: string;
+  /** The time of the comment's update */
+  updated_at?: string;
+  user?: User;
+}
+export const Comment = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    assets: S.optional(CommentAssetsList),
+    body: S.optional(S.String),
+    created_at: S.optional(S.String),
+    html_url: S.optional(S.String),
+    id: S.optional(S.Number),
+    issue_url: S.optional(S.String),
+    original_author: S.optional(S.String),
+    original_author_id: S.optional(S.Number),
+    pull_request_url: S.optional(S.String),
+    updated_at: S.optional(S.String),
+    user: S.optional(User),
+  }),
+).annotate({ identifier: "Comment" }) as any as S.Schema<Comment>;
+
+export interface IssueCreateLabelRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  color: string;
+  description?: string;
+  exclusive?: boolean;
+  is_archived?: boolean;
+  name: string;
+}
+export const IssueCreateLabelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    color: S.String,
+    description: S.optional(S.String),
+    exclusive: S.optional(S.Boolean),
+    is_archived: S.optional(S.Boolean),
+    name: S.String,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/repos/{owner}/{repo}/labels", code: 200 }),
+  ),
+).annotate({
+  identifier: "IssueCreateLabelRequest",
+}) as any as S.Schema<IssueCreateLabelRequest>;
+
+export type IssueCreateMilestoneRequestState = "open" | "closed";
+export const IssueCreateMilestoneRequestState = /*@__PURE__*/ S.String;
+
+export interface IssueCreateMilestoneRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  description?: string;
+  due_on?: string;
+  state?: IssueCreateMilestoneRequestState | (string & {});
+  title?: string;
+}
+export const IssueCreateMilestoneRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    description: S.optional(S.String),
+    due_on: S.optional(S.String),
+    state: S.optional(IssueCreateMilestoneRequestState),
+    title: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/milestones",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueCreateMilestoneRequest",
+}) as any as S.Schema<IssueCreateMilestoneRequest>;
+
+export interface IssueDeleteCommentRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of comment to delete */
+  id: number;
+}
+export const IssueDeleteCommentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/comments/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueDeleteCommentRequest",
+}) as any as S.Schema<IssueDeleteCommentRequest>;
+
+export interface IssueDeleteCommentResponse {}
+export const IssueDeleteCommentResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IssueDeleteCommentResponse",
+}) as any as S.Schema<IssueDeleteCommentResponse>;
+
+export interface IssueDeleteCommentReactionRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of the comment to edit */
+  id: number;
+  content?: string;
+}
+export const IssueDeleteCommentReactionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+    content: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/comments/{id}/reactions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueDeleteCommentReactionRequest",
+}) as any as S.Schema<IssueDeleteCommentReactionRequest>;
+
+export interface IssueDeleteCommentReactionResponse {}
+export const IssueDeleteCommentReactionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IssueDeleteCommentReactionResponse",
+}) as any as S.Schema<IssueDeleteCommentReactionResponse>;
+
+export interface IssueDeleteLabelRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of the label to delete */
+  id: number;
+}
+export const IssueDeleteLabelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/labels/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueDeleteLabelRequest",
+}) as any as S.Schema<IssueDeleteLabelRequest>;
+
+export interface IssueDeleteLabelResponse {}
+export const IssueDeleteLabelResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IssueDeleteLabelResponse",
+}) as any as S.Schema<IssueDeleteLabelResponse>;
+
+export interface IssueDeleteMilestoneRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** the milestone to delete, identified by ID and if not available by name */
+  id: number;
+}
+export const IssueDeleteMilestoneRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/milestones/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueDeleteMilestoneRequest",
+}) as any as S.Schema<IssueDeleteMilestoneRequest>;
+
+export interface IssueDeleteMilestoneResponse {}
+export const IssueDeleteMilestoneResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IssueDeleteMilestoneResponse",
+}) as any as S.Schema<IssueDeleteMilestoneResponse>;
+
+export interface IssueDeleteStopWatchRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue to stop the stopwatch on */
+  index: number;
+}
+export const IssueDeleteStopWatchRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/{index}/stopwatch/delete",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueDeleteStopWatchRequest",
+}) as any as S.Schema<IssueDeleteStopWatchRequest>;
+
+export interface IssueDeleteStopWatchResponse {}
+export const IssueDeleteStopWatchResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IssueDeleteStopWatchResponse",
+}) as any as S.Schema<IssueDeleteStopWatchResponse>;
+
+export interface IssueDeleteSubscriptionRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** user witch unsubscribe */
+  user: string;
+}
+export const IssueDeleteSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    user: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/{index}/subscriptions/{user}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueDeleteSubscriptionRequest",
+}) as any as S.Schema<IssueDeleteSubscriptionRequest>;
+
+export interface IssueDeleteSubscriptionResponse {}
+export const IssueDeleteSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IssueDeleteSubscriptionResponse",
+}) as any as S.Schema<IssueDeleteSubscriptionResponse>;
+
+export interface IssueDeleteTimeRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** id of time to delete */
+  id: number;
+}
+export const IssueDeleteTimeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/{index}/times/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueDeleteTimeRequest",
+}) as any as S.Schema<IssueDeleteTimeRequest>;
+
+export interface IssueDeleteTimeResponse {}
+export const IssueDeleteTimeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IssueDeleteTimeResponse",
+}) as any as S.Schema<IssueDeleteTimeResponse>;
+
+export interface IssueEditCommentRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of the comment to edit */
+  id: number;
+  /** The body of the comment */
+  body: string;
+  /** The time of the comment's update, needs admin or repository owner permission */
+  updated_at?: string;
+}
+export const IssueEditCommentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+    body: S.String,
+    updated_at: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/repos/{owner}/{repo}/issues/comments/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueEditCommentRequest",
+}) as any as S.Schema<IssueEditCommentRequest>;
+
+export interface IssueEditLabelRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of the label to edit */
+  id: number;
+  color?: string;
+  description?: string;
+  exclusive?: boolean;
+  is_archived?: boolean;
+  name?: string;
+}
+export const IssueEditLabelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+    color: S.optional(S.String),
+    description: S.optional(S.String),
+    exclusive: S.optional(S.Boolean),
+    is_archived: S.optional(S.Boolean),
+    name: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/repos/{owner}/{repo}/labels/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueEditLabelRequest",
+}) as any as S.Schema<IssueEditLabelRequest>;
+
+export interface IssueEditMilestoneRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** the milestone to edit, identified by ID and if not available by name */
+  id: number;
+  description?: string;
+  due_on?: string;
+  state?: string;
+  title?: string;
+}
+export const IssueEditMilestoneRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+    description: S.optional(S.String),
+    due_on: S.optional(S.String),
+    state: S.optional(S.String),
+    title: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/repos/{owner}/{repo}/milestones/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueEditMilestoneRequest",
+}) as any as S.Schema<IssueEditMilestoneRequest>;
+
+export interface IssueGetCommentRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of the comment */
+  id: number;
+}
+export const IssueGetCommentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/repos/{owner}/{repo}/issues/comments/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueGetCommentRequest",
+}) as any as S.Schema<IssueGetCommentRequest>;
+
+export interface IssueGetCommentReactionsRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of the comment to edit */
+  id: number;
+}
+export const IssueGetCommentReactionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/repos/{owner}/{repo}/issues/comments/{id}/reactions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueGetCommentReactionsRequest",
+}) as any as S.Schema<IssueGetCommentReactionsRequest>;
+
+export type IssueGetCommentReactionsResponseBodyList = Array<Reaction>;
+export const IssueGetCommentReactionsResponseBodyList = /*@__PURE__*/ S.Array(
+  Reaction,
+) as any as S.Schema<IssueGetCommentReactionsResponseBodyList>;
+
+export type IssueGetCommentReactionsResponse =
+  IssueGetCommentReactionsResponseBodyList;
+export const IssueGetCommentReactionsResponse = /*@__PURE__*/ S.suspend(() =>
+  IssueGetCommentReactionsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IssueGetCommentReactionsResponse",
+}) as any as S.Schema<IssueGetCommentReactionsResponse>;
+
+export interface IssueGetCommentsRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** if provided, only comments updated since the specified time are returned. */
+  since?: string;
+  /** if provided, only comments updated before the provided time are returned. */
+  before?: string;
+}
+export const IssueGetCommentsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    since: S.optional(S.String.pipe(T.Query())),
+    before: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/repos/{owner}/{repo}/issues/{index}/comments",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueGetCommentsRequest",
+}) as any as S.Schema<IssueGetCommentsRequest>;
+
+export type IssueGetCommentsResponseBodyList = Array<Comment>;
+export const IssueGetCommentsResponseBodyList = /*@__PURE__*/ S.Array(
+  Comment,
+) as any as S.Schema<IssueGetCommentsResponseBodyList>;
+
+export type IssueGetCommentsResponse = IssueGetCommentsResponseBodyList;
+export const IssueGetCommentsResponse = /*@__PURE__*/ S.suspend(() =>
+  IssueGetCommentsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IssueGetCommentsResponse",
+}) as any as S.Schema<IssueGetCommentsResponse>;
+
+export interface IssueGetCommentsAndTimelineRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** if provided, only comments updated since the specified time are returned. */
+  since?: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+  /** if provided, only comments updated before the provided time are returned. */
+  before?: string;
+}
+export const IssueGetCommentsAndTimelineRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    since: S.optional(S.String.pipe(T.Query())),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+    before: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/repos/{owner}/{repo}/issues/{index}/timeline",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueGetCommentsAndTimelineRequest",
+}) as any as S.Schema<IssueGetCommentsAndTimelineRequest>;
+
+/** Organization represents an organization */
+export interface Organization {
+  avatar_url?: string;
+  created?: string;
+  description?: string;
+  email?: string;
+  full_name?: string;
+  id: number;
+  location?: string;
+  name?: string;
+  repo_admin_change_team_access?: boolean;
+  /** deprecated */
+  username: string;
+  visibility?: string;
+  website?: string;
+}
+export const Organization = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    avatar_url: S.optional(S.String),
+    created: S.optional(S.String),
+    description: S.optional(S.String),
+    email: S.optional(S.String),
+    full_name: S.optional(S.String),
+    id: S.Number,
+    location: S.optional(S.String),
+    name: S.optional(S.String),
+    repo_admin_change_team_access: S.optional(S.Boolean),
+    username: S.String,
+    visibility: S.optional(S.String),
+    website: S.optional(S.String),
+  }),
+).annotate({ identifier: "Organization" }) as any as S.Schema<Organization>;
+
+export type TeamPermission = "none" | "read" | "write" | "admin" | "owner";
+export const TeamPermission = /*@__PURE__*/ S.String;
+
+export type TeamUnitsList = Array<string>;
+export const TeamUnitsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<TeamUnitsList>;
+
+export type TeamUnitsMapMap = { [key: string]: string | undefined };
+export const TeamUnitsMapMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<TeamUnitsMapMap>;
+
+/** Team represents a team in an organization */
+export interface Team {
+  can_create_org_repo?: boolean;
+  description?: string;
+  id: number;
+  includes_all_repositories?: boolean;
+  name: string;
+  organization?: Organization;
+  permission?: TeamPermission;
+  units?: TeamUnitsList;
+  units_map?: TeamUnitsMapMap;
+}
+export const Team = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    can_create_org_repo: S.optional(S.Boolean),
+    description: S.optional(S.String),
+    id: S.Number,
+    includes_all_repositories: S.optional(S.Boolean),
+    name: S.String,
+    organization: S.optional(Organization),
+    permission: S.optional(TeamPermission),
+    units: S.optional(TeamUnitsList),
+    units_map: S.optional(TeamUnitsMapMap),
+  }),
+).annotate({ identifier: "Team" }) as any as S.Schema<Team>;
+
+/** TimelineComment represents a timeline comment (comment of any type) on a commit or issue */
+export interface TimelineComment {
+  assignee?: User;
+  assignee_team?: Team;
+  body?: string;
+  created_at?: string;
+  dependent_issue?: Issue;
+  html_url?: string;
+  id?: number;
+  issue_url?: string;
+  label?: Label;
+  milestone?: Milestone;
+  new_ref?: string;
+  new_title?: string;
+  old_milestone?: Milestone;
+  old_project_id?: number;
+  old_ref?: string;
+  old_title?: string;
+  project_id?: number;
+  pull_request_url?: string;
+  ref_action?: string;
+  ref_comment?: Comment;
+  /** commit SHA where issue/PR was referenced */
+  ref_commit_sha?: string;
+  ref_issue?: Issue;
+  /** whether the assignees were removed or added */
+  removed_assignee?: boolean;
+  resolve_doer?: User;
+  review_id?: number;
+  tracked_time?: TrackedTime;
+  type?: string;
+  updated_at?: string;
+  user?: User;
+}
+export const TimelineComment = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    assignee: S.optional(User),
+    assignee_team: S.optional(Team),
+    body: S.optional(S.String),
+    created_at: S.optional(S.String),
+    dependent_issue: S.optional(Issue),
+    html_url: S.optional(S.String),
+    id: S.optional(S.Number),
+    issue_url: S.optional(S.String),
+    label: S.optional(Label),
+    milestone: S.optional(Milestone),
+    new_ref: S.optional(S.String),
+    new_title: S.optional(S.String),
+    old_milestone: S.optional(Milestone),
+    old_project_id: S.optional(S.Number),
+    old_ref: S.optional(S.String),
+    old_title: S.optional(S.String),
+    project_id: S.optional(S.Number),
+    pull_request_url: S.optional(S.String),
+    ref_action: S.optional(S.String),
+    ref_comment: S.optional(Comment),
+    ref_commit_sha: S.optional(S.String),
+    ref_issue: S.optional(Issue),
+    removed_assignee: S.optional(S.Boolean),
+    resolve_doer: S.optional(User),
+    review_id: S.optional(S.Number),
+    tracked_time: S.optional(TrackedTime),
+    type: S.optional(S.String),
+    updated_at: S.optional(S.String),
+    user: S.optional(User),
+  }),
+).annotate({
+  identifier: "TimelineComment",
+}) as any as S.Schema<TimelineComment>;
+
+export type IssueGetCommentsAndTimelineResponseBodyList =
+  Array<TimelineComment>;
+export const IssueGetCommentsAndTimelineResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    TimelineComment,
+  ) as any as S.Schema<IssueGetCommentsAndTimelineResponseBodyList>;
+
+export type IssueGetCommentsAndTimelineResponse =
+  IssueGetCommentsAndTimelineResponseBodyList;
+export const IssueGetCommentsAndTimelineResponse = /*@__PURE__*/ S.suspend(() =>
+  IssueGetCommentsAndTimelineResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IssueGetCommentsAndTimelineResponse",
+}) as any as S.Schema<IssueGetCommentsAndTimelineResponse>;
+
+export interface IssueGetLabelRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of the label to get */
+  id: number;
+}
+export const IssueGetLabelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/repos/{owner}/{repo}/labels/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueGetLabelRequest",
+}) as any as S.Schema<IssueGetLabelRequest>;
+
+export interface IssueGetLabelsRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+}
+export const IssueGetLabelsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/repos/{owner}/{repo}/issues/{index}/labels",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueGetLabelsRequest",
+}) as any as S.Schema<IssueGetLabelsRequest>;
+
+export type IssueGetLabelsResponseBodyList = Array<Label>;
+export const IssueGetLabelsResponseBodyList = /*@__PURE__*/ S.Array(
+  Label,
+) as any as S.Schema<IssueGetLabelsResponseBodyList>;
+
+export type IssueGetLabelsResponse = IssueGetLabelsResponseBodyList;
+export const IssueGetLabelsResponse = /*@__PURE__*/ S.suspend(() =>
+  IssueGetLabelsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IssueGetLabelsResponse",
+}) as any as S.Schema<IssueGetLabelsResponse>;
+
+export interface IssueGetMilestoneRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** the milestone to get, identified by ID and if not available by name */
+  id: number;
+}
+export const IssueGetMilestoneRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/repos/{owner}/{repo}/milestones/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueGetMilestoneRequest",
+}) as any as S.Schema<IssueGetMilestoneRequest>;
+
+export interface IssueGetMilestonesListRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** Milestone state, Recognized values are open, closed and all. Defaults to "open" */
+  state?: string;
+  /** filter by milestone name */
+  name?: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const IssueGetMilestonesListRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    state: S.optional(S.String.pipe(T.Query())),
+    name: 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: "/repos/{owner}/{repo}/milestones",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueGetMilestonesListRequest",
+}) as any as S.Schema<IssueGetMilestonesListRequest>;
+
+export type IssueGetMilestonesListResponseBodyList = Array<Milestone>;
+export const IssueGetMilestonesListResponseBodyList = /*@__PURE__*/ S.Array(
+  Milestone,
+) as any as S.Schema<IssueGetMilestonesListResponseBodyList>;
+
+export type IssueGetMilestonesListResponse =
+  IssueGetMilestonesListResponseBodyList;
+export const IssueGetMilestonesListResponse = /*@__PURE__*/ S.suspend(() =>
+  IssueGetMilestonesListResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IssueGetMilestonesListResponse",
+}) as any as S.Schema<IssueGetMilestonesListResponse>;
+
+export interface IssueGetRepoCommentsRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** if provided, only comments updated since the provided time are returned. */
+  since?: string;
+  /** if provided, only comments updated before the provided time are returned. */
+  before?: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const IssueGetRepoCommentsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    since: S.optional(S.String.pipe(T.Query())),
+    before: 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: "/repos/{owner}/{repo}/issues/comments",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueGetRepoCommentsRequest",
+}) as any as S.Schema<IssueGetRepoCommentsRequest>;
+
+export type IssueGetRepoCommentsResponseBodyList = Array<Comment>;
+export const IssueGetRepoCommentsResponseBodyList = /*@__PURE__*/ S.Array(
+  Comment,
+) as any as S.Schema<IssueGetRepoCommentsResponseBodyList>;
+
+export type IssueGetRepoCommentsResponse = IssueGetRepoCommentsResponseBodyList;
+export const IssueGetRepoCommentsResponse = /*@__PURE__*/ S.suspend(() =>
+  IssueGetRepoCommentsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IssueGetRepoCommentsResponse",
+}) as any as S.Schema<IssueGetRepoCommentsResponse>;
+
+export interface IssueListBlocksRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const IssueListBlocksRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.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: "/repos/{owner}/{repo}/issues/{index}/blocks",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueListBlocksRequest",
+}) as any as S.Schema<IssueListBlocksRequest>;
+
+export type IssueListBlocksResponseBodyList = Array<Issue>;
+export const IssueListBlocksResponseBodyList = /*@__PURE__*/ S.Array(
+  Issue,
+) as any as S.Schema<IssueListBlocksResponseBodyList>;
+
+export type IssueListBlocksResponse = IssueListBlocksResponseBodyList;
+export const IssueListBlocksResponse = /*@__PURE__*/ S.suspend(() =>
+  IssueListBlocksResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IssueListBlocksResponse",
+}) as any as S.Schema<IssueListBlocksResponse>;
+
+export type IssueListLabelsRequestSort =
+  | "mostissues"
+  | "leastissues"
+  | "reversealphabetically";
+export const IssueListLabelsRequestSort = /*@__PURE__*/ S.String;
+
+export interface IssueListLabelsRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** Specifies the sorting method: mostissues, leastissues, or reversealphabetically. */
+  sort?: IssueListLabelsRequestSort | (string & {});
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const IssueListLabelsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    sort: S.optional(IssueListLabelsRequestSort.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: "/repos/{owner}/{repo}/labels", code: 200 }),
+  ),
+).annotate({
+  identifier: "IssueListLabelsRequest",
+}) as any as S.Schema<IssueListLabelsRequest>;
+
+export type IssueListLabelsResponseBodyList = Array<Label>;
+export const IssueListLabelsResponseBodyList = /*@__PURE__*/ S.Array(
+  Label,
+) as any as S.Schema<IssueListLabelsResponseBodyList>;
+
+export type IssueListLabelsResponse = IssueListLabelsResponseBodyList;
+export const IssueListLabelsResponse = /*@__PURE__*/ S.suspend(() =>
+  IssueListLabelsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IssueListLabelsResponse",
+}) as any as S.Schema<IssueListLabelsResponse>;
+
+export interface IssuePostCommentReactionRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of the comment to edit */
+  id: number;
+  content?: string;
+}
+export const IssuePostCommentReactionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+    content: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/issues/comments/{id}/reactions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssuePostCommentReactionRequest",
+}) as any as S.Schema<IssuePostCommentReactionRequest>;
+
+export interface IssueRemoveLabelRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** name or id of the label to remove */
+  identifier: string;
+  updated_at?: string;
+}
+export const IssueRemoveLabelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    identifier: S.String.pipe(T.Label()),
+    updated_at: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/{index}/labels/{identifier}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueRemoveLabelRequest",
+}) as any as S.Schema<IssueRemoveLabelRequest>;
+
+export interface IssueRemoveLabelResponse {}
+export const IssueRemoveLabelResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IssueRemoveLabelResponse",
+}) as any as S.Schema<IssueRemoveLabelResponse>;
+
+/** Labels can be a list of integers representing label IDs or a list of strings representing label names */
+export type IssueReplaceLabelsRequestLabelsList = Array<unknown>;
+export const IssueReplaceLabelsRequestLabelsList = /*@__PURE__*/ S.Array(
+  S.Unknown,
+) as any as S.Schema<IssueReplaceLabelsRequestLabelsList>;
+
+export interface IssueReplaceLabelsRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** Labels can be a list of integers representing label IDs or a list of strings representing label names */
+  labels?: IssueReplaceLabelsRequestLabelsList;
+  updated_at?: string;
+}
+export const IssueReplaceLabelsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    labels: S.optional(IssueReplaceLabelsRequestLabelsList),
+    updated_at: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/repos/{owner}/{repo}/issues/{index}/labels",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueReplaceLabelsRequest",
+}) as any as S.Schema<IssueReplaceLabelsRequest>;
+
+export type IssueReplaceLabelsResponseBodyList = Array<Label>;
+export const IssueReplaceLabelsResponseBodyList = /*@__PURE__*/ S.Array(
+  Label,
+) as any as S.Schema<IssueReplaceLabelsResponseBodyList>;
+
+export type IssueReplaceLabelsResponse = IssueReplaceLabelsResponseBodyList;
+export const IssueReplaceLabelsResponse = /*@__PURE__*/ S.suspend(() =>
+  IssueReplaceLabelsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IssueReplaceLabelsResponse",
+}) as any as S.Schema<IssueReplaceLabelsResponse>;
+
+export interface IssueResetTimeRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue to add tracked time to */
+  index: number;
+}
+export const IssueResetTimeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/{index}/times",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueResetTimeRequest",
+}) as any as S.Schema<IssueResetTimeRequest>;
+
+export interface IssueResetTimeResponse {}
+export const IssueResetTimeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IssueResetTimeResponse",
+}) as any as S.Schema<IssueResetTimeResponse>;
+
+export interface IssueStartStopWatchRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue to create the stopwatch on */
+  index: number;
+}
+export const IssueStartStopWatchRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/issues/{index}/stopwatch/start",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueStartStopWatchRequest",
+}) as any as S.Schema<IssueStartStopWatchRequest>;
+
+export interface IssueStartStopWatchResponse {}
+export const IssueStartStopWatchResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IssueStartStopWatchResponse",
+}) as any as S.Schema<IssueStartStopWatchResponse>;
+
+export interface IssueStopStopWatchRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue to stop the stopwatch on */
+  index: number;
+}
+export const IssueStopStopWatchRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/issues/{index}/stopwatch/stop",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueStopStopWatchRequest",
+}) as any as S.Schema<IssueStopStopWatchRequest>;
+
+export interface IssueStopStopWatchResponse {}
+export const IssueStopStopWatchResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "IssueStopStopWatchResponse",
+}) as any as S.Schema<IssueStopStopWatchResponse>;
+
+export interface IssueSubscriptionsRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const IssueSubscriptionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.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: "/repos/{owner}/{repo}/issues/{index}/subscriptions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueSubscriptionsRequest",
+}) as any as S.Schema<IssueSubscriptionsRequest>;
+
+export type IssueSubscriptionsResponseBodyList = Array<User>;
+export const IssueSubscriptionsResponseBodyList = /*@__PURE__*/ S.Array(
+  User,
+) as any as S.Schema<IssueSubscriptionsResponseBodyList>;
+
+export type IssueSubscriptionsResponse = IssueSubscriptionsResponseBodyList;
+export const IssueSubscriptionsResponse = /*@__PURE__*/ S.suspend(() =>
+  IssueSubscriptionsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IssueSubscriptionsResponse",
+}) as any as S.Schema<IssueSubscriptionsResponse>;
+
+export interface IssueTrackedTimesRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** optional filter by user (available for issue managers) */
+  user?: string;
+  /** Only show times updated after the given time. This is a timestamp in RFC 3339 format */
+  since?: string;
+  /** Only show times updated before the given time. This is a timestamp in RFC 3339 format */
+  before?: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const IssueTrackedTimesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    user: S.optional(S.String.pipe(T.Query())),
+    since: S.optional(S.String.pipe(T.Query())),
+    before: 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: "/repos/{owner}/{repo}/issues/{index}/times",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IssueTrackedTimesRequest",
+}) as any as S.Schema<IssueTrackedTimesRequest>;
+
+export type IssueTrackedTimesResponseBodyList = Array<TrackedTime>;
+export const IssueTrackedTimesResponseBodyList = /*@__PURE__*/ S.Array(
+  TrackedTime,
+) as any as S.Schema<IssueTrackedTimesResponseBodyList>;
+
+export type IssueTrackedTimesResponse = IssueTrackedTimesResponseBodyList;
+export const IssueTrackedTimesResponse = /*@__PURE__*/ S.suspend(() =>
+  IssueTrackedTimesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IssueTrackedTimesResponse",
+}) as any as S.Schema<IssueTrackedTimesResponse>;
+
+export interface ListIssueAttachmentsRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+}
+export const ListIssueAttachmentsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/repos/{owner}/{repo}/issues/{index}/assets",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListIssueAttachmentsRequest",
+}) as any as S.Schema<ListIssueAttachmentsRequest>;
+
+export type ListIssueAttachmentsResponseBodyList = Array<Attachment>;
+export const ListIssueAttachmentsResponseBodyList = /*@__PURE__*/ S.Array(
+  Attachment,
+) as any as S.Schema<ListIssueAttachmentsResponseBodyList>;
+
+export type ListIssueAttachmentsResponse = ListIssueAttachmentsResponseBodyList;
+export const ListIssueAttachmentsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIssueAttachmentsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIssueAttachmentsResponse",
+}) as any as S.Schema<ListIssueAttachmentsResponse>;
+
+export interface ListIssueCommentAttachmentsRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** id of the comment */
+  id: number;
+}
+export const ListIssueCommentAttachmentsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/repos/{owner}/{repo}/issues/comments/{id}/assets",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListIssueCommentAttachmentsRequest",
+}) as any as S.Schema<ListIssueCommentAttachmentsRequest>;
+
+export type ListIssueCommentAttachmentsResponseBodyList = Array<Attachment>;
+export const ListIssueCommentAttachmentsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    Attachment,
+  ) as any as S.Schema<ListIssueCommentAttachmentsResponseBodyList>;
+
+export type ListIssueCommentAttachmentsResponse =
+  ListIssueCommentAttachmentsResponseBodyList;
+export const ListIssueCommentAttachmentsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIssueCommentAttachmentsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIssueCommentAttachmentsResponse",
+}) as any as S.Schema<ListIssueCommentAttachmentsResponse>;
+
+export interface ListIssueDependenciesRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const ListIssueDependenciesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.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: "/repos/{owner}/{repo}/issues/{index}/dependencies",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListIssueDependenciesRequest",
+}) as any as S.Schema<ListIssueDependenciesRequest>;
+
+export type ListIssueDependenciesResponseBodyList = Array<Issue>;
+export const ListIssueDependenciesResponseBodyList = /*@__PURE__*/ S.Array(
+  Issue,
+) as any as S.Schema<ListIssueDependenciesResponseBodyList>;
+
+export type ListIssueDependenciesResponse =
+  ListIssueDependenciesResponseBodyList;
+export const ListIssueDependenciesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIssueDependenciesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIssueDependenciesResponse",
+}) as any as S.Schema<ListIssueDependenciesResponse>;
+
+export type ListIssuesRequestState = "closed" | "open" | "all";
+export const ListIssuesRequestState = /*@__PURE__*/ S.String;
+
+export type ListIssuesRequestType = "issues" | "pulls";
+export const ListIssuesRequestType = /*@__PURE__*/ S.String;
+
+export type ListIssuesRequestSort =
+  | "relevance"
+  | "latest"
+  | "oldest"
+  | "recentupdate"
+  | "leastupdate"
+  | "mostcomment"
+  | "leastcomment"
+  | "nearduedate"
+  | "farduedate";
+export const ListIssuesRequestSort = /*@__PURE__*/ S.String;
+
+export interface ListIssuesRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** whether issue is open or closed */
+  state?: ListIssuesRequestState | (string & {});
+  /** comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded */
+  labels?: string;
+  /** search string */
+  q?: string;
+  /** filter by type (issues / pulls) if set */
+  type?: ListIssuesRequestType | (string & {});
+  /** comma separated list of milestone names or ids. It uses names and fall back to ids. Fetch only issues that have any of this milestones. Non existent milestones are discarded */
+  milestones?: string;
+  /** Only show items updated after the given time. This is a timestamp in RFC 3339 format */
+  since?: string;
+  /** Only show items updated before the given time. This is a timestamp in RFC 3339 format */
+  before?: string;
+  /** Only show items which were created by the given user */
+  created_by?: string;
+  /** Only show items for which the given user is assigned */
+  assigned_by?: string;
+  /** Only show items in which the given user was mentioned */
+  mentioned_by?: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+  /** Type of sort */
+  sort?: ListIssuesRequestSort | (string & {});
+}
+export const ListIssuesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    state: S.optional(ListIssuesRequestState.pipe(T.Query())),
+    labels: S.optional(S.String.pipe(T.Query())),
+    q: S.optional(S.String.pipe(T.Query())),
+    type: S.optional(ListIssuesRequestType.pipe(T.Query())),
+    milestones: S.optional(S.String.pipe(T.Query())),
+    since: S.optional(S.String.pipe(T.Query())),
+    before: S.optional(S.String.pipe(T.Query())),
+    created_by: S.optional(S.String.pipe(T.Query())),
+    assigned_by: S.optional(S.String.pipe(T.Query())),
+    mentioned_by: S.optional(S.String.pipe(T.Query())),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+    sort: S.optional(ListIssuesRequestSort.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/repos/{owner}/{repo}/issues", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListIssuesRequest",
+}) as any as S.Schema<ListIssuesRequest>;
+
+export type ListIssuesResponseBodyList = Array<Issue>;
+export const ListIssuesResponseBodyList = /*@__PURE__*/ S.Array(
+  Issue,
+) as any as S.Schema<ListIssuesResponseBodyList>;
+
+export type ListIssuesResponse = ListIssuesResponseBodyList;
+export const ListIssuesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListIssuesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListIssuesResponse",
+}) as any as S.Schema<ListIssuesResponse>;
+
+export interface MoveIssuePinRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of issue */
+  index: number;
+  /** the new position */
+  position: number;
+}
+export const MoveIssuePinRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    position: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/repos/{owner}/{repo}/issues/{index}/pin/{position}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "MoveIssuePinRequest",
+}) as any as S.Schema<MoveIssuePinRequest>;
+
+export interface MoveIssuePinResponse {}
+export const MoveIssuePinResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "MoveIssuePinResponse",
+}) as any as S.Schema<MoveIssuePinResponse>;
+
+export interface PinIssueRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of issue to pin */
+  index: number;
+}
+export const PinIssueRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/issues/{index}/pin",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PinIssueRequest",
+}) as any as S.Schema<PinIssueRequest>;
+
+export interface PinIssueResponse {}
+export const PinIssueResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PinIssueResponse",
+}) as any as S.Schema<PinIssueResponse>;
+
+export interface PostIssueReactionRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+  content?: string;
+}
+export const PostIssueReactionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+    content: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/repos/{owner}/{repo}/issues/{index}/reactions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PostIssueReactionRequest",
+}) as any as S.Schema<PostIssueReactionRequest>;
+
+export interface RemoveIssueBlockingRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+}
+export const RemoveIssueBlockingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/{index}/blocks",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "RemoveIssueBlockingRequest",
+}) as any as S.Schema<RemoveIssueBlockingRequest>;
+
+export interface RemoveIssueDependenciesRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of the issue */
+  index: number;
+}
+export const RemoveIssueDependenciesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/{index}/dependencies",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "RemoveIssueDependenciesRequest",
+}) as any as S.Schema<RemoveIssueDependenciesRequest>;
+
+export type SearchIssuesRequestState = "open" | "closed" | "all";
+export const SearchIssuesRequestState = /*@__PURE__*/ S.String;
+
+export type SearchIssuesRequestType = "issues" | "pulls";
+export const SearchIssuesRequestType = /*@__PURE__*/ S.String;
+
+export type SearchIssuesRequestSort =
+  | "relevance"
+  | "latest"
+  | "oldest"
+  | "recentupdate"
+  | "leastupdate"
+  | "mostcomment"
+  | "leastcomment"
+  | "nearduedate"
+  | "farduedate";
+export const SearchIssuesRequestSort = /*@__PURE__*/ S.String;
+
+export interface SearchIssuesRequest {
+  /** State of the issue */
+  state?: SearchIssuesRequestState | (string & {});
+  /** Comma-separated list of label names. Fetch only issues that have any of these labels. Non existent labels are discarded. */
+  labels?: string;
+  /** Comma-separated list of milestone names. Fetch only issues that have any of these milestones. Non existent milestones are discarded. */
+  milestones?: string;
+  /** Search string */
+  q?: string;
+  /** Repository ID to prioritize in the results */
+  priority_repo_id?: number;
+  /** Filter by issue type */
+  type?: SearchIssuesRequestType | (string & {});
+  /** Only show issues updated after the given time (RFC 3339 format) */
+  since?: string;
+  /** Only show issues updated before the given time (RFC 3339 format) */
+  before?: string;
+  /** Filter issues or pulls assigned to the authenticated user */
+  assigned?: boolean;
+  /** Filter issues or pulls created by the authenticated user */
+  created?: boolean;
+  /** Filter issues or pulls mentioning the authenticated user */
+  mentioned?: boolean;
+  /** Filter pull requests where the authenticated user's review was requested */
+  review_requested?: boolean;
+  /** Filter pull requests reviewed by the authenticated user */
+  reviewed?: boolean;
+  /** Filter by repository owner */
+  owner?: string;
+  /** Filter by team (requires organization owner parameter) */
+  team?: string;
+  /** Page number of results to return (1-based) */
+  page?: number;
+  /** Number of items per page */
+  limit?: number;
+  /** Type of sort */
+  sort?: SearchIssuesRequestSort | (string & {});
+}
+export const SearchIssuesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    state: S.optional(SearchIssuesRequestState.pipe(T.Query())),
+    labels: S.optional(S.String.pipe(T.Query())),
+    milestones: S.optional(S.String.pipe(T.Query())),
+    q: S.optional(S.String.pipe(T.Query())),
+    priority_repo_id: S.optional(S.Number.pipe(T.Query())),
+    type: S.optional(SearchIssuesRequestType.pipe(T.Query())),
+    since: S.optional(S.String.pipe(T.Query())),
+    before: S.optional(S.String.pipe(T.Query())),
+    assigned: S.optional(S.Boolean.pipe(T.Query())),
+    created: S.optional(S.Boolean.pipe(T.Query())),
+    mentioned: S.optional(S.Boolean.pipe(T.Query())),
+    review_requested: S.optional(S.Boolean.pipe(T.Query())),
+    reviewed: S.optional(S.Boolean.pipe(T.Query())),
+    owner: S.optional(S.String.pipe(T.Query())),
+    team: S.optional(S.String.pipe(T.Query())),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+    sort: S.optional(SearchIssuesRequestSort.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/repos/issues/search", code: 200 })),
+).annotate({
+  identifier: "SearchIssuesRequest",
+}) as any as S.Schema<SearchIssuesRequest>;
+
+export type SearchIssuesResponseBodyList = Array<Issue>;
+export const SearchIssuesResponseBodyList = /*@__PURE__*/ S.Array(
+  Issue,
+) as any as S.Schema<SearchIssuesResponseBodyList>;
+
+export type SearchIssuesResponse = SearchIssuesResponseBodyList;
+export const SearchIssuesResponse = /*@__PURE__*/ S.suspend(() =>
+  SearchIssuesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "SearchIssuesResponse",
+}) as any as S.Schema<SearchIssuesResponse>;
+
+export interface UnpinIssueRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+  /** index of issue to unpin */
+  index: number;
+}
+export const UnpinIssueRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+    index: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/repos/{owner}/{repo}/issues/{index}/pin",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UnpinIssueRequest",
+}) as any as S.Schema<UnpinIssueRequest>;
+
+export interface UnpinIssueResponse {}
+export const UnpinIssueResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UnpinIssueResponse",
+}) as any as S.Schema<UnpinIssueResponse>;
+
+export type CreateIssueError =
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | Locked
+  | ForgejoOpError;
+/** Create an issue. If using deadline only the date will be taken into account, and time of day ignored. */
+export const createIssue: API.OperationMethod<
+  CreateIssueRequest,
+  Issue,
+  CreateIssueError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIssueRequest,
+  output: Issue,
+  errors: [Forbidden, NotFound, UnprocessableEntity, Locked],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIssueAttachmentError =
+  | BadRequest
+  | NotFound
+  | UnprocessableEntity
+  | Locked
+  | ForgejoOpError;
+/** Create an issue attachment */
+export const createIssueAttachment: API.OperationMethod<
+  CreateIssueAttachmentRequest,
+  Attachment,
+  CreateIssueAttachmentError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIssueAttachmentRequest,
+  output: Attachment,
+  errors: [BadRequest, NotFound, UnprocessableEntity, Locked],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIssueBlockingError = NotFound | ForgejoOpError;
+/** Block the issue given in the body by the issue in path */
+export const createIssueBlocking: API.OperationMethod<
+  CreateIssueBlockingRequest,
+  Issue,
+  CreateIssueBlockingError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIssueBlockingRequest,
+  output: Issue,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIssueCommentAttachmentError =
+  | BadRequest
+  | NotFound
+  | UnprocessableEntity
+  | Locked
+  | ForgejoOpError;
+/** Create a comment attachment */
+export const createIssueCommentAttachment: API.OperationMethod<
+  CreateIssueCommentAttachmentRequest,
+  Attachment,
+  CreateIssueCommentAttachmentError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIssueCommentAttachmentRequest,
+  output: Attachment,
+  errors: [BadRequest, NotFound, UnprocessableEntity, Locked],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateIssueDependenciesError = NotFound | Locked | ForgejoOpError;
+/** Make the issue in the url depend on the issue in the form. */
+export const createIssueDependencies: API.OperationMethod<
+  CreateIssueDependenciesRequest,
+  Issue,
+  CreateIssueDependenciesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateIssueDependenciesRequest,
+  output: Issue,
+  errors: [NotFound, Locked],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteIssueError = Forbidden | NotFound | ForgejoOpError;
+/** Delete an issue */
+export const deleteIssue: API.OperationMethod<
+  DeleteIssueRequest,
+  DeleteIssueResponse,
+  DeleteIssueError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteIssueRequest,
+  output: DeleteIssueResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteIssueAttachmentError = NotFound | Locked | ForgejoOpError;
+/** Delete an issue attachment */
+export const deleteIssueAttachment: API.OperationMethod<
+  DeleteIssueAttachmentRequest,
+  DeleteIssueAttachmentResponse,
+  DeleteIssueAttachmentError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteIssueAttachmentRequest,
+  output: DeleteIssueAttachmentResponse,
+  errors: [NotFound, Locked],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteIssueCommentAttachmentError =
+  | NotFound
+  | Locked
+  | ForgejoOpError;
+/** Delete a comment attachment */
+export const deleteIssueCommentAttachment: API.OperationMethod<
+  DeleteIssueCommentAttachmentRequest,
+  DeleteIssueCommentAttachmentResponse,
+  DeleteIssueCommentAttachmentError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteIssueCommentAttachmentRequest,
+  output: DeleteIssueCommentAttachmentResponse,
+  errors: [NotFound, Locked],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteIssueReactionError = Forbidden | NotFound | ForgejoOpError;
+/** Remove a reaction from an issue */
+export const deleteIssueReaction: API.OperationMethod<
+  DeleteIssueReactionRequest,
+  DeleteIssueReactionResponse,
+  DeleteIssueReactionError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteIssueReactionRequest,
+  output: DeleteIssueReactionResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EditIssueError = Forbidden | NotFound | ForgejoOpError;
+/** Edit an issue. If using deadline only the date will be taken into account, and time of day ignored. */
+export const editIssue: API.OperationMethod<
+  EditIssueRequest,
+  Issue,
+  EditIssueError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EditIssueRequest,
+  output: Issue,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EditIssueAttachmentError = NotFound | Locked | ForgejoOpError;
+/** Edit an issue attachment */
+export const editIssueAttachment: API.OperationMethod<
+  EditIssueAttachmentRequest,
+  Attachment,
+  EditIssueAttachmentError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EditIssueAttachmentRequest,
+  output: Attachment,
+  errors: [NotFound, Locked],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EditIssueCommentAttachmentError =
+  | NotFound
+  | Locked
+  | ForgejoOpError;
+/** Edit a comment attachment */
+export const editIssueCommentAttachment: API.OperationMethod<
+  EditIssueCommentAttachmentRequest,
+  Attachment,
+  EditIssueCommentAttachmentError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EditIssueCommentAttachmentRequest,
+  output: Attachment,
+  errors: [NotFound, Locked],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EditIssueDeadlineError = Forbidden | NotFound | ForgejoOpError;
+/** Set an issue deadline. If set to null, the deadline is deleted. If using deadline only the date will be taken into account, and time of day ignored. */
+export const editIssueDeadline: API.OperationMethod<
+  EditIssueDeadlineRequest,
+  IssueDeadline,
+  EditIssueDeadlineError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EditIssueDeadlineRequest,
+  output: IssueDeadline,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIssueError = NotFound | ForgejoOpError;
+/** Get an issue */
+export const getIssue: API.OperationMethod<
+  GetIssueRequest,
+  Issue,
+  GetIssueError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIssueRequest,
+  output: Issue,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIssueAttachmentError = NotFound | ForgejoOpError;
+/** Get an issue attachment */
+export const getIssueAttachment: API.OperationMethod<
+  GetIssueAttachmentRequest,
+  Attachment,
+  GetIssueAttachmentError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIssueAttachmentRequest,
+  output: Attachment,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIssueCommentAttachmentError = NotFound | ForgejoOpError;
+/** Get a comment attachment */
+export const getIssueCommentAttachment: API.OperationMethod<
+  GetIssueCommentAttachmentRequest,
+  Attachment,
+  GetIssueCommentAttachmentError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIssueCommentAttachmentRequest,
+  output: Attachment,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetIssueReactionsError = Forbidden | NotFound | ForgejoOpError;
+/** Get a list reactions of an issue */
+export const getIssueReactions: API.OperationMethod<
+  GetIssueReactionsRequest,
+  GetIssueReactionsResponse,
+  GetIssueReactionsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetIssueReactionsRequest,
+  output: GetIssueReactionsResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueAddLabelError = Forbidden | NotFound | ForgejoOpError;
+/** Add a label to an issue */
+export const issueAddLabel: API.OperationMethod<
+  IssueAddLabelRequest,
+  IssueAddLabelResponse,
+  IssueAddLabelError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueAddLabelRequest,
+  output: IssueAddLabelResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueAddSubscriptionError = NotFound | ForgejoOpError;
+/** Subscribe user to issue */
+export const issueAddSubscription: API.OperationMethod<
+  IssueAddSubscriptionRequest,
+  IssueAddSubscriptionResponse,
+  IssueAddSubscriptionError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueAddSubscriptionRequest,
+  output: IssueAddSubscriptionResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueAddTimeError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Add tracked time to a issue */
+export const issueAddTime: API.OperationMethod<
+  IssueAddTimeRequest,
+  TrackedTime,
+  IssueAddTimeError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueAddTimeRequest,
+  output: TrackedTime,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueCheckSubscriptionError = NotFound | ForgejoOpError;
+/** Check if user is subscribed to an issue */
+export const issueCheckSubscription: API.OperationMethod<
+  IssueCheckSubscriptionRequest,
+  WatchInfo,
+  IssueCheckSubscriptionError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueCheckSubscriptionRequest,
+  output: WatchInfo,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueClearLabelsError = Forbidden | NotFound | ForgejoOpError;
+/** Remove all labels from an issue */
+export const issueClearLabels: API.OperationMethod<
+  IssueClearLabelsRequest,
+  IssueClearLabelsResponse,
+  IssueClearLabelsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueClearLabelsRequest,
+  output: IssueClearLabelsResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueCreateCommentError =
+  | Forbidden
+  | NotFound
+  | Locked
+  | ForgejoOpError;
+/** Add a comment to an issue */
+export const issueCreateComment: API.OperationMethod<
+  IssueCreateCommentRequest,
+  Comment,
+  IssueCreateCommentError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueCreateCommentRequest,
+  output: Comment,
+  errors: [Forbidden, NotFound, Locked],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueCreateLabelError =
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Create a label */
+export const issueCreateLabel: API.OperationMethod<
+  IssueCreateLabelRequest,
+  Label,
+  IssueCreateLabelError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueCreateLabelRequest,
+  output: Label,
+  errors: [NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueCreateMilestoneError = NotFound | ForgejoOpError;
+/** Create a milestone */
+export const issueCreateMilestone: API.OperationMethod<
+  IssueCreateMilestoneRequest,
+  Milestone,
+  IssueCreateMilestoneError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueCreateMilestoneRequest,
+  output: Milestone,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueDeleteCommentError = Forbidden | ForgejoOpError;
+/** Delete a comment */
+export const issueDeleteComment: API.OperationMethod<
+  IssueDeleteCommentRequest,
+  IssueDeleteCommentResponse,
+  IssueDeleteCommentError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueDeleteCommentRequest,
+  output: IssueDeleteCommentResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueDeleteCommentReactionError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Remove a reaction from a comment of an issue */
+export const issueDeleteCommentReaction: API.OperationMethod<
+  IssueDeleteCommentReactionRequest,
+  IssueDeleteCommentReactionResponse,
+  IssueDeleteCommentReactionError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueDeleteCommentReactionRequest,
+  output: IssueDeleteCommentReactionResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueDeleteLabelError = NotFound | ForgejoOpError;
+/** Delete a label */
+export const issueDeleteLabel: API.OperationMethod<
+  IssueDeleteLabelRequest,
+  IssueDeleteLabelResponse,
+  IssueDeleteLabelError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueDeleteLabelRequest,
+  output: IssueDeleteLabelResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueDeleteMilestoneError = NotFound | ForgejoOpError;
+/** Delete a milestone */
+export const issueDeleteMilestone: API.OperationMethod<
+  IssueDeleteMilestoneRequest,
+  IssueDeleteMilestoneResponse,
+  IssueDeleteMilestoneError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueDeleteMilestoneRequest,
+  output: IssueDeleteMilestoneResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueDeleteStopWatchError =
+  | Forbidden
+  | NotFound
+  | Conflict
+  | ForgejoOpError;
+/** Delete an issue's existing stopwatch. */
+export const issueDeleteStopWatch: API.OperationMethod<
+  IssueDeleteStopWatchRequest,
+  IssueDeleteStopWatchResponse,
+  IssueDeleteStopWatchError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueDeleteStopWatchRequest,
+  output: IssueDeleteStopWatchResponse,
+  errors: [Forbidden, NotFound, Conflict],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueDeleteSubscriptionError = NotFound | ForgejoOpError;
+/** Unsubscribe user from issue */
+export const issueDeleteSubscription: API.OperationMethod<
+  IssueDeleteSubscriptionRequest,
+  IssueDeleteSubscriptionResponse,
+  IssueDeleteSubscriptionError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueDeleteSubscriptionRequest,
+  output: IssueDeleteSubscriptionResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueDeleteTimeError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Delete specific tracked time */
+export const issueDeleteTime: API.OperationMethod<
+  IssueDeleteTimeRequest,
+  IssueDeleteTimeResponse,
+  IssueDeleteTimeError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueDeleteTimeRequest,
+  output: IssueDeleteTimeResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueEditCommentError =
+  | Forbidden
+  | NotFound
+  | Locked
+  | ForgejoOpError;
+/** Edit a comment */
+export const issueEditComment: API.OperationMethod<
+  IssueEditCommentRequest,
+  Comment,
+  IssueEditCommentError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueEditCommentRequest,
+  output: Comment,
+  errors: [Forbidden, NotFound, Locked],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueEditLabelError =
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Update a label */
+export const issueEditLabel: API.OperationMethod<
+  IssueEditLabelRequest,
+  Label,
+  IssueEditLabelError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueEditLabelRequest,
+  output: Label,
+  errors: [NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueEditMilestoneError = NotFound | ForgejoOpError;
+/** Update a milestone */
+export const issueEditMilestone: API.OperationMethod<
+  IssueEditMilestoneRequest,
+  Milestone,
+  IssueEditMilestoneError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueEditMilestoneRequest,
+  output: Milestone,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueGetCommentError = Forbidden | NotFound | ForgejoOpError;
+/** Get a comment */
+export const issueGetComment: API.OperationMethod<
+  IssueGetCommentRequest,
+  Comment,
+  IssueGetCommentError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueGetCommentRequest,
+  output: Comment,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueGetCommentReactionsError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Get a list of reactions from a comment of an issue */
+export const issueGetCommentReactions: API.OperationMethod<
+  IssueGetCommentReactionsRequest,
+  IssueGetCommentReactionsResponse,
+  IssueGetCommentReactionsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueGetCommentReactionsRequest,
+  output: IssueGetCommentReactionsResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueGetCommentsError =
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** List all comments on an issue */
+export const issueGetComments: API.OperationMethod<
+  IssueGetCommentsRequest,
+  IssueGetCommentsResponse,
+  IssueGetCommentsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueGetCommentsRequest,
+  output: IssueGetCommentsResponse,
+  errors: [NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueGetCommentsAndTimelineError =
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** List all comments and events on an issue */
+export const issueGetCommentsAndTimeline: API.OperationMethod<
+  IssueGetCommentsAndTimelineRequest,
+  IssueGetCommentsAndTimelineResponse,
+  IssueGetCommentsAndTimelineError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueGetCommentsAndTimelineRequest,
+  output: IssueGetCommentsAndTimelineResponse,
+  errors: [NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueGetLabelError = NotFound | ForgejoOpError;
+/** Get a single label */
+export const issueGetLabel: API.OperationMethod<
+  IssueGetLabelRequest,
+  Label,
+  IssueGetLabelError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueGetLabelRequest,
+  output: Label,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueGetLabelsError = NotFound | ForgejoOpError;
+/** Get an issue's labels */
+export const issueGetLabels: API.OperationMethod<
+  IssueGetLabelsRequest,
+  IssueGetLabelsResponse,
+  IssueGetLabelsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueGetLabelsRequest,
+  output: IssueGetLabelsResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueGetMilestoneError = NotFound | ForgejoOpError;
+/** Get a milestone */
+export const issueGetMilestone: API.OperationMethod<
+  IssueGetMilestoneRequest,
+  Milestone,
+  IssueGetMilestoneError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueGetMilestoneRequest,
+  output: Milestone,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueGetMilestonesListError = NotFound | ForgejoOpError;
+/** Get all of a repository's opened milestones */
+export const issueGetMilestonesList: API.OperationMethod<
+  IssueGetMilestonesListRequest,
+  IssueGetMilestonesListResponse,
+  IssueGetMilestonesListError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueGetMilestonesListRequest,
+  output: IssueGetMilestonesListResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueGetRepoCommentsError =
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** List all comments in a repository */
+export const issueGetRepoComments: API.OperationMethod<
+  IssueGetRepoCommentsRequest,
+  IssueGetRepoCommentsResponse,
+  IssueGetRepoCommentsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueGetRepoCommentsRequest,
+  output: IssueGetRepoCommentsResponse,
+  errors: [NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueListBlocksError = NotFound | ForgejoOpError;
+/** List issues that are blocked by this issue */
+export const issueListBlocks: API.OperationMethod<
+  IssueListBlocksRequest,
+  IssueListBlocksResponse,
+  IssueListBlocksError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueListBlocksRequest,
+  output: IssueListBlocksResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueListLabelsError = Forbidden | NotFound | ForgejoOpError;
+/** Get all of a repository's labels */
+export const issueListLabels: API.OperationMethod<
+  IssueListLabelsRequest,
+  IssueListLabelsResponse,
+  IssueListLabelsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueListLabelsRequest,
+  output: IssueListLabelsResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssuePostCommentReactionError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Add a reaction to a comment of an issue */
+export const issuePostCommentReaction: API.OperationMethod<
+  IssuePostCommentReactionRequest,
+  Reaction,
+  IssuePostCommentReactionError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssuePostCommentReactionRequest,
+  output: Reaction,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueRemoveLabelError =
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Remove a label from an issue */
+export const issueRemoveLabel: API.OperationMethod<
+  IssueRemoveLabelRequest,
+  IssueRemoveLabelResponse,
+  IssueRemoveLabelError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueRemoveLabelRequest,
+  output: IssueRemoveLabelResponse,
+  errors: [Forbidden, NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueReplaceLabelsError = Forbidden | NotFound | ForgejoOpError;
+/** Replace an issue's labels */
+export const issueReplaceLabels: API.OperationMethod<
+  IssueReplaceLabelsRequest,
+  IssueReplaceLabelsResponse,
+  IssueReplaceLabelsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueReplaceLabelsRequest,
+  output: IssueReplaceLabelsResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueResetTimeError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Reset a tracked time of an issue */
+export const issueResetTime: API.OperationMethod<
+  IssueResetTimeRequest,
+  IssueResetTimeResponse,
+  IssueResetTimeError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueResetTimeRequest,
+  output: IssueResetTimeResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueStartStopWatchError =
+  | Forbidden
+  | NotFound
+  | Conflict
+  | ForgejoOpError;
+/** Start stopwatch on an issue. */
+export const issueStartStopWatch: API.OperationMethod<
+  IssueStartStopWatchRequest,
+  IssueStartStopWatchResponse,
+  IssueStartStopWatchError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueStartStopWatchRequest,
+  output: IssueStartStopWatchResponse,
+  errors: [Forbidden, NotFound, Conflict],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueStopStopWatchError =
+  | Forbidden
+  | NotFound
+  | Conflict
+  | ForgejoOpError;
+/** Stop an issue's existing stopwatch. */
+export const issueStopStopWatch: API.OperationMethod<
+  IssueStopStopWatchRequest,
+  IssueStopStopWatchResponse,
+  IssueStopStopWatchError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueStopStopWatchRequest,
+  output: IssueStopStopWatchResponse,
+  errors: [Forbidden, NotFound, Conflict],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueSubscriptionsError = NotFound | ForgejoOpError;
+/** Get users who subscribed on an issue. */
+export const issueSubscriptions: API.OperationMethod<
+  IssueSubscriptionsRequest,
+  IssueSubscriptionsResponse,
+  IssueSubscriptionsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueSubscriptionsRequest,
+  output: IssueSubscriptionsResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IssueTrackedTimesError =
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** List an issue's tracked times */
+export const issueTrackedTimes: API.OperationMethod<
+  IssueTrackedTimesRequest,
+  IssueTrackedTimesResponse,
+  IssueTrackedTimesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IssueTrackedTimesRequest,
+  output: IssueTrackedTimesResponse,
+  errors: [Forbidden, NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIssueAttachmentsError = NotFound | ForgejoOpError;
+/** List issue's attachments */
+export const listIssueAttachments: API.OperationMethod<
+  ListIssueAttachmentsRequest,
+  ListIssueAttachmentsResponse,
+  ListIssueAttachmentsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIssueAttachmentsRequest,
+  output: ListIssueAttachmentsResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIssueCommentAttachmentsError = NotFound | ForgejoOpError;
+/** List comment's attachments */
+export const listIssueCommentAttachments: API.OperationMethod<
+  ListIssueCommentAttachmentsRequest,
+  ListIssueCommentAttachmentsResponse,
+  ListIssueCommentAttachmentsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIssueCommentAttachmentsRequest,
+  output: ListIssueCommentAttachmentsResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIssueDependenciesError = NotFound | ForgejoOpError;
+/** List an issue's dependencies, i.e all issues that block this issue. */
+export const listIssueDependencies: API.OperationMethod<
+  ListIssueDependenciesRequest,
+  ListIssueDependenciesResponse,
+  ListIssueDependenciesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIssueDependenciesRequest,
+  output: ListIssueDependenciesResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListIssuesError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** List a repository's issues */
+export const listIssues: API.OperationMethod<
+  ListIssuesRequest,
+  ListIssuesResponse,
+  ListIssuesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListIssuesRequest,
+  output: ListIssuesResponse,
+  errors: [NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type MoveIssuePinError = Forbidden | NotFound | ForgejoOpError;
+/** Moves the Pin to the given Position */
+export const moveIssuePin: API.OperationMethod<
+  MoveIssuePinRequest,
+  MoveIssuePinResponse,
+  MoveIssuePinError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: MoveIssuePinRequest,
+  output: MoveIssuePinResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PinIssueError = Forbidden | NotFound | ForgejoOpError;
+/** Pin an Issue */
+export const pinIssue: API.OperationMethod<
+  PinIssueRequest,
+  PinIssueResponse,
+  PinIssueError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PinIssueRequest,
+  output: PinIssueResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PostIssueReactionError = Forbidden | NotFound | ForgejoOpError;
+/** Add a reaction to an issue */
+export const postIssueReaction: API.OperationMethod<
+  PostIssueReactionRequest,
+  Reaction,
+  PostIssueReactionError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PostIssueReactionRequest,
+  output: Reaction,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RemoveIssueBlockingError = NotFound | ForgejoOpError;
+/** Unblock the issue given in the body by the issue in path */
+export const removeIssueBlocking: API.OperationMethod<
+  RemoveIssueBlockingRequest,
+  Issue,
+  RemoveIssueBlockingError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RemoveIssueBlockingRequest,
+  output: Issue,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RemoveIssueDependenciesError = NotFound | Locked | ForgejoOpError;
+/** Remove an issue dependency */
+export const removeIssueDependencies: API.OperationMethod<
+  RemoveIssueDependenciesRequest,
+  Issue,
+  RemoveIssueDependenciesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RemoveIssueDependenciesRequest,
+  output: Issue,
+  errors: [NotFound, Locked],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SearchIssuesError =
+  | BadRequest
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Search for issues across the repositories that the user has access to */
+export const searchIssues: API.OperationMethod<
+  SearchIssuesRequest,
+  SearchIssuesResponse,
+  SearchIssuesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SearchIssuesRequest,
+  output: SearchIssuesResponse,
+  errors: [BadRequest, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UnpinIssueError = Forbidden | NotFound | ForgejoOpError;
+/** Unpin an Issue */
+export const unpinIssue: API.OperationMethod<
+  UnpinIssueRequest,
+  UnpinIssueResponse,
+  UnpinIssueError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UnpinIssueRequest,
+  output: UnpinIssueResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));