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

package/lib/services/issue.d.ts

@@ -0,0 +1,1479 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import { type ForgejoOpError, type ForgejoOpContext } from "../protocol.ts";
+export type { ForgejoOpError, ForgejoOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const Conflict_base: S.Class<Conflict, S.TaggedStruct<"Conflict", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+export declare class Conflict extends /*@__PURE__*/ Conflict_base {
+}
+declare const Forbidden_base: S.Class<Forbidden, S.TaggedStruct<"Forbidden", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        AuthError: true;
+    };
+});
+export declare class Forbidden extends /*@__PURE__*/ Forbidden_base {
+}
+declare const Locked_base: S.Class<Locked, S.TaggedStruct<"Locked", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError>;
+export declare class Locked extends /*@__PURE__*/ Locked_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+declare const UnprocessableEntity_base: S.Class<UnprocessableEntity, S.TaggedStruct<"UnprocessableEntity", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class UnprocessableEntity extends /*@__PURE__*/ UnprocessableEntity_base {
+}
+export type CreateIssueRequestAssigneesList = Array<string>;
+export declare const CreateIssueRequestAssigneesList: S.Schema<CreateIssueRequestAssigneesList>;
+/** list of label ids */
+export type CreateIssueRequestLabelsList = Array<number>;
+export declare const CreateIssueRequestLabelsList: 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 declare const CreateIssueRequest: S.Schema<CreateIssueRequest>;
+export type AttachmentType = "attachment" | "external";
+export declare const AttachmentType: any;
+/** Attachment a generic attachment */
+export interface Attachment {
+    browser_download_url?: string;
+    created_at?: string;
+    download_count?: number;
+    id?: number;
+    name?: string;
+    size?: number;
+    type?: AttachmentType;
+    uuid?: string;
+}
+export declare const Attachment: S.Schema<Attachment>;
+export type IssueAssetsList = Array<Attachment>;
+export declare const IssueAssetsList: S.Schema<IssueAssetsList>;
+/** User represents a user */
+export interface User {
+    /** Is user active */
+    active?: boolean;
+    /** URL to the user's avatar */
+    avatar_url?: string;
+    created?: string;
+    /** the user's description */
+    description?: string;
+    email?: string;
+    /** user counts */
+    followers_count?: number;
+    following_count?: number;
+    /** the user's full name */
+    full_name?: string;
+    /** URL to the user's profile page */
+    html_url?: string;
+    /** the user's id */
+    id: number;
+    /** Is the user an administrator */
+    is_admin?: boolean;
+    /** User locale */
+    language?: string;
+    last_login?: string;
+    /** the user's location */
+    location?: string;
+    /** the user's username */
+    login: string;
+    /** the user's authentication sign-in name. */
+    login_name?: string;
+    /** Is user login prohibited */
+    prohibit_login?: boolean;
+    /** the user's pronouns */
+    pronouns?: string;
+    /** Is user restricted */
+    restricted?: boolean;
+    /** The ID of the user's Authentication Source */
+    source_id?: number;
+    starred_repos_count?: number;
+    /** User visibility level option: public, limited, private */
+    visibility?: string;
+    /** the user's website */
+    website?: string;
+}
+export declare const User: S.Schema<User>;
+export type IssueAssigneesList = Array<User>;
+export declare const IssueAssigneesList: S.Schema<IssueAssigneesList>;
+/** Label a label to an issue or a pr */
+export interface Label {
+    color: string;
+    description?: string;
+    exclusive?: boolean;
+    id: number;
+    is_archived?: boolean;
+    name: string;
+    url?: string;
+}
+export declare const Label: S.Schema<Label>;
+export type IssueLabelsList = Array<Label>;
+export declare const IssueLabelsList: S.Schema<IssueLabelsList>;
+/** Milestone milestone is a collection of issues on one repository */
+export interface Milestone {
+    closed_at?: string;
+    closed_issues?: number;
+    created_at?: string;
+    description?: string;
+    due_on?: string;
+    id?: number;
+    open_issues?: number;
+    state?: string;
+    title?: string;
+    updated_at?: string;
+}
+export declare const Milestone: S.Schema<Milestone>;
+/** PullRequestMeta PR info if an issue is a PR */
+export interface PullRequestMeta {
+    draft?: boolean;
+    html_url?: string;
+    merged?: boolean;
+    merged_at?: string;
+}
+export declare const PullRequestMeta: S.Schema<PullRequestMeta>;
+/** RepositoryMeta basic repository information */
+export interface RepositoryMeta {
+    full_name?: string;
+    id?: number;
+    name?: string;
+    owner?: string;
+}
+export declare const RepositoryMeta: 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 declare const Issue: 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 declare const CreateIssueAttachmentRequest: 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 declare const CreateIssueBlockingRequest: 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 declare const CreateIssueCommentAttachmentRequest: 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 declare const CreateIssueDependenciesRequest: 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 declare const DeleteIssueRequest: S.Schema<DeleteIssueRequest>;
+export interface DeleteIssueResponse {
+}
+export declare const DeleteIssueResponse: 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 declare const DeleteIssueAttachmentRequest: S.Schema<DeleteIssueAttachmentRequest>;
+export interface DeleteIssueAttachmentResponse {
+}
+export declare const DeleteIssueAttachmentResponse: 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 declare const DeleteIssueCommentAttachmentRequest: S.Schema<DeleteIssueCommentAttachmentRequest>;
+export interface DeleteIssueCommentAttachmentResponse {
+}
+export declare const DeleteIssueCommentAttachmentResponse: 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 declare const DeleteIssueReactionRequest: S.Schema<DeleteIssueReactionRequest>;
+export interface DeleteIssueReactionResponse {
+}
+export declare const DeleteIssueReactionResponse: S.Schema<DeleteIssueReactionResponse>;
+export type EditIssueRequestAssigneesList = Array<string>;
+export declare const EditIssueRequestAssigneesList: 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 declare const EditIssueRequest: 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 declare const EditIssueAttachmentRequest: 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 declare const EditIssueCommentAttachmentRequest: 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 declare const EditIssueDeadlineRequest: S.Schema<EditIssueDeadlineRequest>;
+/** IssueDeadline represents an issue deadline */
+export interface IssueDeadline {
+    due_date?: string;
+}
+export declare const IssueDeadline: 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 declare const GetIssueRequest: 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 declare const GetIssueAttachmentRequest: 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 declare const GetIssueCommentAttachmentRequest: 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 declare const GetIssueReactionsRequest: S.Schema<GetIssueReactionsRequest>;
+/** Reaction contain one reaction */
+export interface Reaction {
+    content?: string;
+    created_at?: string;
+    user?: User;
+}
+export declare const Reaction: S.Schema<Reaction>;
+export type GetIssueReactionsResponseBodyList = Array<Reaction>;
+export declare const GetIssueReactionsResponseBodyList: S.Schema<GetIssueReactionsResponseBodyList>;
+export type GetIssueReactionsResponse = GetIssueReactionsResponseBodyList;
+export declare const GetIssueReactionsResponse: 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 declare const IssueAddLabelRequestLabelsList: 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 declare const IssueAddLabelRequest: S.Schema<IssueAddLabelRequest>;
+export type IssueAddLabelResponseBodyList = Array<Label>;
+export declare const IssueAddLabelResponseBodyList: S.Schema<IssueAddLabelResponseBodyList>;
+export type IssueAddLabelResponse = IssueAddLabelResponseBodyList;
+export declare const IssueAddLabelResponse: 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 declare const IssueAddSubscriptionRequest: S.Schema<IssueAddSubscriptionRequest>;
+export interface IssueAddSubscriptionResponse {
+}
+export declare const IssueAddSubscriptionResponse: 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 declare const IssueAddTimeRequest: 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 declare const TrackedTime: 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 declare const IssueCheckSubscriptionRequest: 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 declare const WatchInfo: 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 declare const IssueClearLabelsRequest: S.Schema<IssueClearLabelsRequest>;
+export interface IssueClearLabelsResponse {
+}
+export declare const IssueClearLabelsResponse: 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 declare const IssueCreateCommentRequest: S.Schema<IssueCreateCommentRequest>;
+/** The attachments to the comment */
+export type CommentAssetsList = Array<Attachment>;
+export declare const CommentAssetsList: S.Schema<CommentAssetsList>;
+/** Comment represents a comment on a commit or issue */
+export interface Comment {
+    /** The attachments to the comment */
+    assets?: CommentAssetsList;
+    /** The body of the comment */
+    body?: string;
+    /** The time of the comment's creation */
+    created_at?: string;
+    /** The HTML URL of the comment */
+    html_url?: string;
+    /** The identifier of the comment */
+    id?: number;
+    /** The HTML URL of the issue if the comment is posted on an issue, else empty string */
+    issue_url?: string;
+    /** The original author that posted the comment if it was not posted locally, else empty string */
+    original_author?: string;
+    /** The ID of the original author that posted the comment if it was not posted locally, else 0 */
+    original_author_id?: number;
+    /** The HTML URL of the pull request if the comment is posted on a pull request, else empty string */
+    pull_request_url?: string;
+    /** The time of the comment's update */
+    updated_at?: string;
+    user?: User;
+}
+export declare const Comment: S.Schema<Comment>;
+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 declare const IssueCreateLabelRequest: S.Schema<IssueCreateLabelRequest>;
+export type IssueCreateMilestoneRequestState = "open" | "closed";
+export declare const IssueCreateMilestoneRequestState: any;
+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 declare const IssueCreateMilestoneRequest: 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 declare const IssueDeleteCommentRequest: S.Schema<IssueDeleteCommentRequest>;
+export interface IssueDeleteCommentResponse {
+}
+export declare const IssueDeleteCommentResponse: 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 declare const IssueDeleteCommentReactionRequest: S.Schema<IssueDeleteCommentReactionRequest>;
+export interface IssueDeleteCommentReactionResponse {
+}
+export declare const IssueDeleteCommentReactionResponse: 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 declare const IssueDeleteLabelRequest: S.Schema<IssueDeleteLabelRequest>;
+export interface IssueDeleteLabelResponse {
+}
+export declare const IssueDeleteLabelResponse: 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 declare const IssueDeleteMilestoneRequest: S.Schema<IssueDeleteMilestoneRequest>;
+export interface IssueDeleteMilestoneResponse {
+}
+export declare const IssueDeleteMilestoneResponse: 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 declare const IssueDeleteStopWatchRequest: S.Schema<IssueDeleteStopWatchRequest>;
+export interface IssueDeleteStopWatchResponse {
+}
+export declare const IssueDeleteStopWatchResponse: 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 declare const IssueDeleteSubscriptionRequest: S.Schema<IssueDeleteSubscriptionRequest>;
+export interface IssueDeleteSubscriptionResponse {
+}
+export declare const IssueDeleteSubscriptionResponse: 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 declare const IssueDeleteTimeRequest: S.Schema<IssueDeleteTimeRequest>;
+export interface IssueDeleteTimeResponse {
+}
+export declare const IssueDeleteTimeResponse: 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 declare const IssueEditCommentRequest: 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 declare const IssueEditLabelRequest: 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 declare const IssueEditMilestoneRequest: 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 declare const IssueGetCommentRequest: 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 declare const IssueGetCommentReactionsRequest: S.Schema<IssueGetCommentReactionsRequest>;
+export type IssueGetCommentReactionsResponseBodyList = Array<Reaction>;
+export declare const IssueGetCommentReactionsResponseBodyList: S.Schema<IssueGetCommentReactionsResponseBodyList>;
+export type IssueGetCommentReactionsResponse = IssueGetCommentReactionsResponseBodyList;
+export declare const IssueGetCommentReactionsResponse: 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 declare const IssueGetCommentsRequest: S.Schema<IssueGetCommentsRequest>;
+export type IssueGetCommentsResponseBodyList = Array<Comment>;
+export declare const IssueGetCommentsResponseBodyList: S.Schema<IssueGetCommentsResponseBodyList>;
+export type IssueGetCommentsResponse = IssueGetCommentsResponseBodyList;
+export declare const IssueGetCommentsResponse: 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 declare const IssueGetCommentsAndTimelineRequest: 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 declare const Organization: S.Schema<Organization>;
+export type TeamPermission = "none" | "read" | "write" | "admin" | "owner";
+export declare const TeamPermission: any;
+export type TeamUnitsList = Array<string>;
+export declare const TeamUnitsList: S.Schema<TeamUnitsList>;
+export type TeamUnitsMapMap = {
+    [key: string]: string | undefined;
+};
+export declare const TeamUnitsMapMap: S.Schema<TeamUnitsMapMap>;
+/** Team represents a team in an organization */
+export interface Team {
+    can_create_org_repo?: boolean;
+    description?: string;
+    id: number;
+    includes_all_repositories?: boolean;
+    name: string;
+    organization?: Organization;
+    permission?: TeamPermission;
+    units?: TeamUnitsList;
+    units_map?: TeamUnitsMapMap;
+}
+export declare const Team: S.Schema<Team>;
+/** 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 declare const TimelineComment: S.Schema<TimelineComment>;
+export type IssueGetCommentsAndTimelineResponseBodyList = Array<TimelineComment>;
+export declare const IssueGetCommentsAndTimelineResponseBodyList: S.Schema<IssueGetCommentsAndTimelineResponseBodyList>;
+export type IssueGetCommentsAndTimelineResponse = IssueGetCommentsAndTimelineResponseBodyList;
+export declare const IssueGetCommentsAndTimelineResponse: 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 declare const IssueGetLabelRequest: 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 declare const IssueGetLabelsRequest: S.Schema<IssueGetLabelsRequest>;
+export type IssueGetLabelsResponseBodyList = Array<Label>;
+export declare const IssueGetLabelsResponseBodyList: S.Schema<IssueGetLabelsResponseBodyList>;
+export type IssueGetLabelsResponse = IssueGetLabelsResponseBodyList;
+export declare const IssueGetLabelsResponse: 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 declare const IssueGetMilestoneRequest: 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 declare const IssueGetMilestonesListRequest: S.Schema<IssueGetMilestonesListRequest>;
+export type IssueGetMilestonesListResponseBodyList = Array<Milestone>;
+export declare const IssueGetMilestonesListResponseBodyList: S.Schema<IssueGetMilestonesListResponseBodyList>;
+export type IssueGetMilestonesListResponse = IssueGetMilestonesListResponseBodyList;
+export declare const IssueGetMilestonesListResponse: 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 declare const IssueGetRepoCommentsRequest: S.Schema<IssueGetRepoCommentsRequest>;
+export type IssueGetRepoCommentsResponseBodyList = Array<Comment>;
+export declare const IssueGetRepoCommentsResponseBodyList: S.Schema<IssueGetRepoCommentsResponseBodyList>;
+export type IssueGetRepoCommentsResponse = IssueGetRepoCommentsResponseBodyList;
+export declare const IssueGetRepoCommentsResponse: 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 declare const IssueListBlocksRequest: S.Schema<IssueListBlocksRequest>;
+export type IssueListBlocksResponseBodyList = Array<Issue>;
+export declare const IssueListBlocksResponseBodyList: S.Schema<IssueListBlocksResponseBodyList>;
+export type IssueListBlocksResponse = IssueListBlocksResponseBodyList;
+export declare const IssueListBlocksResponse: S.Schema<IssueListBlocksResponse>;
+export type IssueListLabelsRequestSort = "mostissues" | "leastissues" | "reversealphabetically";
+export declare const IssueListLabelsRequestSort: any;
+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 declare const IssueListLabelsRequest: S.Schema<IssueListLabelsRequest>;
+export type IssueListLabelsResponseBodyList = Array<Label>;
+export declare const IssueListLabelsResponseBodyList: S.Schema<IssueListLabelsResponseBodyList>;
+export type IssueListLabelsResponse = IssueListLabelsResponseBodyList;
+export declare const IssueListLabelsResponse: 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 declare const IssuePostCommentReactionRequest: 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 declare const IssueRemoveLabelRequest: S.Schema<IssueRemoveLabelRequest>;
+export interface IssueRemoveLabelResponse {
+}
+export declare const IssueRemoveLabelResponse: 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 declare const IssueReplaceLabelsRequestLabelsList: 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 declare const IssueReplaceLabelsRequest: S.Schema<IssueReplaceLabelsRequest>;
+export type IssueReplaceLabelsResponseBodyList = Array<Label>;
+export declare const IssueReplaceLabelsResponseBodyList: S.Schema<IssueReplaceLabelsResponseBodyList>;
+export type IssueReplaceLabelsResponse = IssueReplaceLabelsResponseBodyList;
+export declare const IssueReplaceLabelsResponse: 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 declare const IssueResetTimeRequest: S.Schema<IssueResetTimeRequest>;
+export interface IssueResetTimeResponse {
+}
+export declare const IssueResetTimeResponse: 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 declare const IssueStartStopWatchRequest: S.Schema<IssueStartStopWatchRequest>;
+export interface IssueStartStopWatchResponse {
+}
+export declare const IssueStartStopWatchResponse: 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 declare const IssueStopStopWatchRequest: S.Schema<IssueStopStopWatchRequest>;
+export interface IssueStopStopWatchResponse {
+}
+export declare const IssueStopStopWatchResponse: 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 declare const IssueSubscriptionsRequest: S.Schema<IssueSubscriptionsRequest>;
+export type IssueSubscriptionsResponseBodyList = Array<User>;
+export declare const IssueSubscriptionsResponseBodyList: S.Schema<IssueSubscriptionsResponseBodyList>;
+export type IssueSubscriptionsResponse = IssueSubscriptionsResponseBodyList;
+export declare const IssueSubscriptionsResponse: 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 declare const IssueTrackedTimesRequest: S.Schema<IssueTrackedTimesRequest>;
+export type IssueTrackedTimesResponseBodyList = Array<TrackedTime>;
+export declare const IssueTrackedTimesResponseBodyList: S.Schema<IssueTrackedTimesResponseBodyList>;
+export type IssueTrackedTimesResponse = IssueTrackedTimesResponseBodyList;
+export declare const IssueTrackedTimesResponse: 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 declare const ListIssueAttachmentsRequest: S.Schema<ListIssueAttachmentsRequest>;
+export type ListIssueAttachmentsResponseBodyList = Array<Attachment>;
+export declare const ListIssueAttachmentsResponseBodyList: S.Schema<ListIssueAttachmentsResponseBodyList>;
+export type ListIssueAttachmentsResponse = ListIssueAttachmentsResponseBodyList;
+export declare const ListIssueAttachmentsResponse: 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 declare const ListIssueCommentAttachmentsRequest: S.Schema<ListIssueCommentAttachmentsRequest>;
+export type ListIssueCommentAttachmentsResponseBodyList = Array<Attachment>;
+export declare const ListIssueCommentAttachmentsResponseBodyList: S.Schema<ListIssueCommentAttachmentsResponseBodyList>;
+export type ListIssueCommentAttachmentsResponse = ListIssueCommentAttachmentsResponseBodyList;
+export declare const ListIssueCommentAttachmentsResponse: 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 declare const ListIssueDependenciesRequest: S.Schema<ListIssueDependenciesRequest>;
+export type ListIssueDependenciesResponseBodyList = Array<Issue>;
+export declare const ListIssueDependenciesResponseBodyList: S.Schema<ListIssueDependenciesResponseBodyList>;
+export type ListIssueDependenciesResponse = ListIssueDependenciesResponseBodyList;
+export declare const ListIssueDependenciesResponse: S.Schema<ListIssueDependenciesResponse>;
+export type ListIssuesRequestState = "closed" | "open" | "all";
+export declare const ListIssuesRequestState: any;
+export type ListIssuesRequestType = "issues" | "pulls";
+export declare const ListIssuesRequestType: any;
+export type ListIssuesRequestSort = "relevance" | "latest" | "oldest" | "recentupdate" | "leastupdate" | "mostcomment" | "leastcomment" | "nearduedate" | "farduedate";
+export declare const ListIssuesRequestSort: any;
+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 declare const ListIssuesRequest: S.Schema<ListIssuesRequest>;
+export type ListIssuesResponseBodyList = Array<Issue>;
+export declare const ListIssuesResponseBodyList: S.Schema<ListIssuesResponseBodyList>;
+export type ListIssuesResponse = ListIssuesResponseBodyList;
+export declare const ListIssuesResponse: 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 declare const MoveIssuePinRequest: S.Schema<MoveIssuePinRequest>;
+export interface MoveIssuePinResponse {
+}
+export declare const MoveIssuePinResponse: 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 declare const PinIssueRequest: S.Schema<PinIssueRequest>;
+export interface PinIssueResponse {
+}
+export declare const PinIssueResponse: 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 declare const PostIssueReactionRequest: 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 declare const RemoveIssueBlockingRequest: 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 declare const RemoveIssueDependenciesRequest: S.Schema<RemoveIssueDependenciesRequest>;
+export type SearchIssuesRequestState = "open" | "closed" | "all";
+export declare const SearchIssuesRequestState: any;
+export type SearchIssuesRequestType = "issues" | "pulls";
+export declare const SearchIssuesRequestType: any;
+export type SearchIssuesRequestSort = "relevance" | "latest" | "oldest" | "recentupdate" | "leastupdate" | "mostcomment" | "leastcomment" | "nearduedate" | "farduedate";
+export declare const SearchIssuesRequestSort: any;
+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 declare const SearchIssuesRequest: S.Schema<SearchIssuesRequest>;
+export type SearchIssuesResponseBodyList = Array<Issue>;
+export declare const SearchIssuesResponseBodyList: S.Schema<SearchIssuesResponseBodyList>;
+export type SearchIssuesResponse = SearchIssuesResponseBodyList;
+export declare const SearchIssuesResponse: 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 declare const UnpinIssueRequest: S.Schema<UnpinIssueRequest>;
+export interface UnpinIssueResponse {
+}
+export declare const UnpinIssueResponse: 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 declare const createIssue: API.OperationMethod<CreateIssueRequest, Issue, CreateIssueError, ForgejoOpContext>;
+export type CreateIssueAttachmentError = BadRequest | NotFound | UnprocessableEntity | Locked | ForgejoOpError;
+/** Create an issue attachment */
+export declare const createIssueAttachment: API.OperationMethod<CreateIssueAttachmentRequest, Attachment, CreateIssueAttachmentError, ForgejoOpContext>;
+export type CreateIssueBlockingError = NotFound | ForgejoOpError;
+/** Block the issue given in the body by the issue in path */
+export declare const createIssueBlocking: API.OperationMethod<CreateIssueBlockingRequest, Issue, CreateIssueBlockingError, ForgejoOpContext>;
+export type CreateIssueCommentAttachmentError = BadRequest | NotFound | UnprocessableEntity | Locked | ForgejoOpError;
+/** Create a comment attachment */
+export declare const createIssueCommentAttachment: API.OperationMethod<CreateIssueCommentAttachmentRequest, Attachment, CreateIssueCommentAttachmentError, ForgejoOpContext>;
+export type CreateIssueDependenciesError = NotFound | Locked | ForgejoOpError;
+/** Make the issue in the url depend on the issue in the form. */
+export declare const createIssueDependencies: API.OperationMethod<CreateIssueDependenciesRequest, Issue, CreateIssueDependenciesError, ForgejoOpContext>;
+export type DeleteIssueError = Forbidden | NotFound | ForgejoOpError;
+/** Delete an issue */
+export declare const deleteIssue: API.OperationMethod<DeleteIssueRequest, DeleteIssueResponse, DeleteIssueError, ForgejoOpContext>;
+export type DeleteIssueAttachmentError = NotFound | Locked | ForgejoOpError;
+/** Delete an issue attachment */
+export declare const deleteIssueAttachment: API.OperationMethod<DeleteIssueAttachmentRequest, DeleteIssueAttachmentResponse, DeleteIssueAttachmentError, ForgejoOpContext>;
+export type DeleteIssueCommentAttachmentError = NotFound | Locked | ForgejoOpError;
+/** Delete a comment attachment */
+export declare const deleteIssueCommentAttachment: API.OperationMethod<DeleteIssueCommentAttachmentRequest, DeleteIssueCommentAttachmentResponse, DeleteIssueCommentAttachmentError, ForgejoOpContext>;
+export type DeleteIssueReactionError = Forbidden | NotFound | ForgejoOpError;
+/** Remove a reaction from an issue */
+export declare const deleteIssueReaction: API.OperationMethod<DeleteIssueReactionRequest, DeleteIssueReactionResponse, DeleteIssueReactionError, ForgejoOpContext>;
+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 declare const editIssue: API.OperationMethod<EditIssueRequest, Issue, EditIssueError, ForgejoOpContext>;
+export type EditIssueAttachmentError = NotFound | Locked | ForgejoOpError;
+/** Edit an issue attachment */
+export declare const editIssueAttachment: API.OperationMethod<EditIssueAttachmentRequest, Attachment, EditIssueAttachmentError, ForgejoOpContext>;
+export type EditIssueCommentAttachmentError = NotFound | Locked | ForgejoOpError;
+/** Edit a comment attachment */
+export declare const editIssueCommentAttachment: API.OperationMethod<EditIssueCommentAttachmentRequest, Attachment, EditIssueCommentAttachmentError, ForgejoOpContext>;
+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 declare const editIssueDeadline: API.OperationMethod<EditIssueDeadlineRequest, IssueDeadline, EditIssueDeadlineError, ForgejoOpContext>;
+export type GetIssueError = NotFound | ForgejoOpError;
+/** Get an issue */
+export declare const getIssue: API.OperationMethod<GetIssueRequest, Issue, GetIssueError, ForgejoOpContext>;
+export type GetIssueAttachmentError = NotFound | ForgejoOpError;
+/** Get an issue attachment */
+export declare const getIssueAttachment: API.OperationMethod<GetIssueAttachmentRequest, Attachment, GetIssueAttachmentError, ForgejoOpContext>;
+export type GetIssueCommentAttachmentError = NotFound | ForgejoOpError;
+/** Get a comment attachment */
+export declare const getIssueCommentAttachment: API.OperationMethod<GetIssueCommentAttachmentRequest, Attachment, GetIssueCommentAttachmentError, ForgejoOpContext>;
+export type GetIssueReactionsError = Forbidden | NotFound | ForgejoOpError;
+/** Get a list reactions of an issue */
+export declare const getIssueReactions: API.OperationMethod<GetIssueReactionsRequest, GetIssueReactionsResponse, GetIssueReactionsError, ForgejoOpContext>;
+export type IssueAddLabelError = Forbidden | NotFound | ForgejoOpError;
+/** Add a label to an issue */
+export declare const issueAddLabel: API.OperationMethod<IssueAddLabelRequest, IssueAddLabelResponse, IssueAddLabelError, ForgejoOpContext>;
+export type IssueAddSubscriptionError = NotFound | ForgejoOpError;
+/** Subscribe user to issue */
+export declare const issueAddSubscription: API.OperationMethod<IssueAddSubscriptionRequest, IssueAddSubscriptionResponse, IssueAddSubscriptionError, ForgejoOpContext>;
+export type IssueAddTimeError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Add tracked time to a issue */
+export declare const issueAddTime: API.OperationMethod<IssueAddTimeRequest, TrackedTime, IssueAddTimeError, ForgejoOpContext>;
+export type IssueCheckSubscriptionError = NotFound | ForgejoOpError;
+/** Check if user is subscribed to an issue */
+export declare const issueCheckSubscription: API.OperationMethod<IssueCheckSubscriptionRequest, WatchInfo, IssueCheckSubscriptionError, ForgejoOpContext>;
+export type IssueClearLabelsError = Forbidden | NotFound | ForgejoOpError;
+/** Remove all labels from an issue */
+export declare const issueClearLabels: API.OperationMethod<IssueClearLabelsRequest, IssueClearLabelsResponse, IssueClearLabelsError, ForgejoOpContext>;
+export type IssueCreateCommentError = Forbidden | NotFound | Locked | ForgejoOpError;
+/** Add a comment to an issue */
+export declare const issueCreateComment: API.OperationMethod<IssueCreateCommentRequest, Comment, IssueCreateCommentError, ForgejoOpContext>;
+export type IssueCreateLabelError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Create a label */
+export declare const issueCreateLabel: API.OperationMethod<IssueCreateLabelRequest, Label, IssueCreateLabelError, ForgejoOpContext>;
+export type IssueCreateMilestoneError = NotFound | ForgejoOpError;
+/** Create a milestone */
+export declare const issueCreateMilestone: API.OperationMethod<IssueCreateMilestoneRequest, Milestone, IssueCreateMilestoneError, ForgejoOpContext>;
+export type IssueDeleteCommentError = Forbidden | ForgejoOpError;
+/** Delete a comment */
+export declare const issueDeleteComment: API.OperationMethod<IssueDeleteCommentRequest, IssueDeleteCommentResponse, IssueDeleteCommentError, ForgejoOpContext>;
+export type IssueDeleteCommentReactionError = Forbidden | NotFound | ForgejoOpError;
+/** Remove a reaction from a comment of an issue */
+export declare const issueDeleteCommentReaction: API.OperationMethod<IssueDeleteCommentReactionRequest, IssueDeleteCommentReactionResponse, IssueDeleteCommentReactionError, ForgejoOpContext>;
+export type IssueDeleteLabelError = NotFound | ForgejoOpError;
+/** Delete a label */
+export declare const issueDeleteLabel: API.OperationMethod<IssueDeleteLabelRequest, IssueDeleteLabelResponse, IssueDeleteLabelError, ForgejoOpContext>;
+export type IssueDeleteMilestoneError = NotFound | ForgejoOpError;
+/** Delete a milestone */
+export declare const issueDeleteMilestone: API.OperationMethod<IssueDeleteMilestoneRequest, IssueDeleteMilestoneResponse, IssueDeleteMilestoneError, ForgejoOpContext>;
+export type IssueDeleteStopWatchError = Forbidden | NotFound | Conflict | ForgejoOpError;
+/** Delete an issue's existing stopwatch. */
+export declare const issueDeleteStopWatch: API.OperationMethod<IssueDeleteStopWatchRequest, IssueDeleteStopWatchResponse, IssueDeleteStopWatchError, ForgejoOpContext>;
+export type IssueDeleteSubscriptionError = NotFound | ForgejoOpError;
+/** Unsubscribe user from issue */
+export declare const issueDeleteSubscription: API.OperationMethod<IssueDeleteSubscriptionRequest, IssueDeleteSubscriptionResponse, IssueDeleteSubscriptionError, ForgejoOpContext>;
+export type IssueDeleteTimeError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Delete specific tracked time */
+export declare const issueDeleteTime: API.OperationMethod<IssueDeleteTimeRequest, IssueDeleteTimeResponse, IssueDeleteTimeError, ForgejoOpContext>;
+export type IssueEditCommentError = Forbidden | NotFound | Locked | ForgejoOpError;
+/** Edit a comment */
+export declare const issueEditComment: API.OperationMethod<IssueEditCommentRequest, Comment, IssueEditCommentError, ForgejoOpContext>;
+export type IssueEditLabelError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Update a label */
+export declare const issueEditLabel: API.OperationMethod<IssueEditLabelRequest, Label, IssueEditLabelError, ForgejoOpContext>;
+export type IssueEditMilestoneError = NotFound | ForgejoOpError;
+/** Update a milestone */
+export declare const issueEditMilestone: API.OperationMethod<IssueEditMilestoneRequest, Milestone, IssueEditMilestoneError, ForgejoOpContext>;
+export type IssueGetCommentError = Forbidden | NotFound | ForgejoOpError;
+/** Get a comment */
+export declare const issueGetComment: API.OperationMethod<IssueGetCommentRequest, Comment, IssueGetCommentError, ForgejoOpContext>;
+export type IssueGetCommentReactionsError = Forbidden | NotFound | ForgejoOpError;
+/** Get a list of reactions from a comment of an issue */
+export declare const issueGetCommentReactions: API.OperationMethod<IssueGetCommentReactionsRequest, IssueGetCommentReactionsResponse, IssueGetCommentReactionsError, ForgejoOpContext>;
+export type IssueGetCommentsError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** List all comments on an issue */
+export declare const issueGetComments: API.OperationMethod<IssueGetCommentsRequest, IssueGetCommentsResponse, IssueGetCommentsError, ForgejoOpContext>;
+export type IssueGetCommentsAndTimelineError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** List all comments and events on an issue */
+export declare const issueGetCommentsAndTimeline: API.OperationMethod<IssueGetCommentsAndTimelineRequest, IssueGetCommentsAndTimelineResponse, IssueGetCommentsAndTimelineError, ForgejoOpContext>;
+export type IssueGetLabelError = NotFound | ForgejoOpError;
+/** Get a single label */
+export declare const issueGetLabel: API.OperationMethod<IssueGetLabelRequest, Label, IssueGetLabelError, ForgejoOpContext>;
+export type IssueGetLabelsError = NotFound | ForgejoOpError;
+/** Get an issue's labels */
+export declare const issueGetLabels: API.OperationMethod<IssueGetLabelsRequest, IssueGetLabelsResponse, IssueGetLabelsError, ForgejoOpContext>;
+export type IssueGetMilestoneError = NotFound | ForgejoOpError;
+/** Get a milestone */
+export declare const issueGetMilestone: API.OperationMethod<IssueGetMilestoneRequest, Milestone, IssueGetMilestoneError, ForgejoOpContext>;
+export type IssueGetMilestonesListError = NotFound | ForgejoOpError;
+/** Get all of a repository's opened milestones */
+export declare const issueGetMilestonesList: API.OperationMethod<IssueGetMilestonesListRequest, IssueGetMilestonesListResponse, IssueGetMilestonesListError, ForgejoOpContext>;
+export type IssueGetRepoCommentsError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** List all comments in a repository */
+export declare const issueGetRepoComments: API.OperationMethod<IssueGetRepoCommentsRequest, IssueGetRepoCommentsResponse, IssueGetRepoCommentsError, ForgejoOpContext>;
+export type IssueListBlocksError = NotFound | ForgejoOpError;
+/** List issues that are blocked by this issue */
+export declare const issueListBlocks: API.OperationMethod<IssueListBlocksRequest, IssueListBlocksResponse, IssueListBlocksError, ForgejoOpContext>;
+export type IssueListLabelsError = Forbidden | NotFound | ForgejoOpError;
+/** Get all of a repository's labels */
+export declare const issueListLabels: API.OperationMethod<IssueListLabelsRequest, IssueListLabelsResponse, IssueListLabelsError, ForgejoOpContext>;
+export type IssuePostCommentReactionError = Forbidden | NotFound | ForgejoOpError;
+/** Add a reaction to a comment of an issue */
+export declare const issuePostCommentReaction: API.OperationMethod<IssuePostCommentReactionRequest, Reaction, IssuePostCommentReactionError, ForgejoOpContext>;
+export type IssueRemoveLabelError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Remove a label from an issue */
+export declare const issueRemoveLabel: API.OperationMethod<IssueRemoveLabelRequest, IssueRemoveLabelResponse, IssueRemoveLabelError, ForgejoOpContext>;
+export type IssueReplaceLabelsError = Forbidden | NotFound | ForgejoOpError;
+/** Replace an issue's labels */
+export declare const issueReplaceLabels: API.OperationMethod<IssueReplaceLabelsRequest, IssueReplaceLabelsResponse, IssueReplaceLabelsError, ForgejoOpContext>;
+export type IssueResetTimeError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Reset a tracked time of an issue */
+export declare const issueResetTime: API.OperationMethod<IssueResetTimeRequest, IssueResetTimeResponse, IssueResetTimeError, ForgejoOpContext>;
+export type IssueStartStopWatchError = Forbidden | NotFound | Conflict | ForgejoOpError;
+/** Start stopwatch on an issue. */
+export declare const issueStartStopWatch: API.OperationMethod<IssueStartStopWatchRequest, IssueStartStopWatchResponse, IssueStartStopWatchError, ForgejoOpContext>;
+export type IssueStopStopWatchError = Forbidden | NotFound | Conflict | ForgejoOpError;
+/** Stop an issue's existing stopwatch. */
+export declare const issueStopStopWatch: API.OperationMethod<IssueStopStopWatchRequest, IssueStopStopWatchResponse, IssueStopStopWatchError, ForgejoOpContext>;
+export type IssueSubscriptionsError = NotFound | ForgejoOpError;
+/** Get users who subscribed on an issue. */
+export declare const issueSubscriptions: API.OperationMethod<IssueSubscriptionsRequest, IssueSubscriptionsResponse, IssueSubscriptionsError, ForgejoOpContext>;
+export type IssueTrackedTimesError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** List an issue's tracked times */
+export declare const issueTrackedTimes: API.OperationMethod<IssueTrackedTimesRequest, IssueTrackedTimesResponse, IssueTrackedTimesError, ForgejoOpContext>;
+export type ListIssueAttachmentsError = NotFound | ForgejoOpError;
+/** List issue's attachments */
+export declare const listIssueAttachments: API.OperationMethod<ListIssueAttachmentsRequest, ListIssueAttachmentsResponse, ListIssueAttachmentsError, ForgejoOpContext>;
+export type ListIssueCommentAttachmentsError = NotFound | ForgejoOpError;
+/** List comment's attachments */
+export declare const listIssueCommentAttachments: API.OperationMethod<ListIssueCommentAttachmentsRequest, ListIssueCommentAttachmentsResponse, ListIssueCommentAttachmentsError, ForgejoOpContext>;
+export type ListIssueDependenciesError = NotFound | ForgejoOpError;
+/** List an issue's dependencies, i.e all issues that block this issue. */
+export declare const listIssueDependencies: API.OperationMethod<ListIssueDependenciesRequest, ListIssueDependenciesResponse, ListIssueDependenciesError, ForgejoOpContext>;
+export type ListIssuesError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** List a repository's issues */
+export declare const listIssues: API.OperationMethod<ListIssuesRequest, ListIssuesResponse, ListIssuesError, ForgejoOpContext>;
+export type MoveIssuePinError = Forbidden | NotFound | ForgejoOpError;
+/** Moves the Pin to the given Position */
+export declare const moveIssuePin: API.OperationMethod<MoveIssuePinRequest, MoveIssuePinResponse, MoveIssuePinError, ForgejoOpContext>;
+export type PinIssueError = Forbidden | NotFound | ForgejoOpError;
+/** Pin an Issue */
+export declare const pinIssue: API.OperationMethod<PinIssueRequest, PinIssueResponse, PinIssueError, ForgejoOpContext>;
+export type PostIssueReactionError = Forbidden | NotFound | ForgejoOpError;
+/** Add a reaction to an issue */
+export declare const postIssueReaction: API.OperationMethod<PostIssueReactionRequest, Reaction, PostIssueReactionError, ForgejoOpContext>;
+export type RemoveIssueBlockingError = NotFound | ForgejoOpError;
+/** Unblock the issue given in the body by the issue in path */
+export declare const removeIssueBlocking: API.OperationMethod<RemoveIssueBlockingRequest, Issue, RemoveIssueBlockingError, ForgejoOpContext>;
+export type RemoveIssueDependenciesError = NotFound | Locked | ForgejoOpError;
+/** Remove an issue dependency */
+export declare const removeIssueDependencies: API.OperationMethod<RemoveIssueDependenciesRequest, Issue, RemoveIssueDependenciesError, ForgejoOpContext>;
+export type SearchIssuesError = BadRequest | UnprocessableEntity | ForgejoOpError;
+/** Search for issues across the repositories that the user has access to */
+export declare const searchIssues: API.OperationMethod<SearchIssuesRequest, SearchIssuesResponse, SearchIssuesError, ForgejoOpContext>;
+export type UnpinIssueError = Forbidden | NotFound | ForgejoOpError;
+/** Unpin an Issue */
+export declare const unpinIssue: API.OperationMethod<UnpinIssueRequest, UnpinIssueResponse, UnpinIssueError, ForgejoOpContext>;
+//# sourceMappingURL=issue.d.ts.map