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

package/src/services/miscellaneous.ts

@@ -0,0 +1,1118 @@
+// 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 NotFound
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<NotFound>()("NotFound", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 404 }],
+  ) {}
+
+export class UnprocessableEntity
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<UnprocessableEntity>()("UnprocessableEntity", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 422 }],
+  ) {}
+
+export interface GetActionsRunRequest {}
+export const GetActionsRunRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/actions/run", code: 200 })),
+).annotate({
+  identifier: "GetActionsRunRequest",
+}) as any as S.Schema<GetActionsRunRequest>;
+
+/** ExternalTracker represents settings for external tracker */
+export interface ExternalTracker {
+  /** External Issue Tracker URL Format. Use the placeholders {user}, {repo} and {index} for the username, repository name and issue index. */
+  external_tracker_format?: string;
+  /** External Issue Tracker issue regular expression */
+  external_tracker_regexp_pattern?: string;
+  /** External Issue Tracker Number Format, either `numeric`, `alphanumeric`, or `regexp` */
+  external_tracker_style?: string;
+  /** URL of external issue tracker. */
+  external_tracker_url?: string;
+}
+export const ExternalTracker = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    external_tracker_format: S.optional(S.String),
+    external_tracker_regexp_pattern: S.optional(S.String),
+    external_tracker_style: S.optional(S.String),
+    external_tracker_url: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ExternalTracker",
+}) as any as S.Schema<ExternalTracker>;
+
+/** ExternalWiki represents setting for external wiki */
+export interface ExternalWiki {
+  /** URL of external wiki. */
+  external_wiki_url?: string;
+}
+export const ExternalWiki = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    external_wiki_url: S.optional(S.String),
+  }),
+).annotate({ identifier: "ExternalWiki" }) as any as S.Schema<ExternalWiki>;
+
+/** InternalTracker represents settings for internal tracker */
+export interface InternalTracker {
+  /** Let only contributors track time (Built-in issue tracker) */
+  allow_only_contributors_to_track_time?: boolean;
+  /** Enable dependencies for issues and pull requests (Built-in issue tracker) */
+  enable_issue_dependencies?: boolean;
+  /** Enable time tracking (Built-in issue tracker) */
+  enable_time_tracker?: boolean;
+}
+export const InternalTracker = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allow_only_contributors_to_track_time: S.optional(S.Boolean),
+    enable_issue_dependencies: S.optional(S.Boolean),
+    enable_time_tracker: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "InternalTracker",
+}) as any as S.Schema<InternalTracker>;
+
+/** ObjectFormatName of the underlying git repository */
+export type RepositoryObjectFormatName = "sha1" | "sha256";
+export const RepositoryObjectFormatName = /*@__PURE__*/ S.String;
+
+/** 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>;
+
+/** Permission represents a set of permissions */
+export interface Permission {
+  admin?: boolean;
+  pull?: boolean;
+  push?: boolean;
+}
+export const Permission = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    admin: S.optional(S.Boolean),
+    pull: S.optional(S.Boolean),
+    push: S.optional(S.Boolean),
+  }),
+).annotate({ identifier: "Permission" }) as any as S.Schema<Permission>;
+
+/** Organization represents an organization */
+export interface Organization {
+  avatar_url?: string;
+  created?: string;
+  description?: string;
+  email?: string;
+  full_name?: string;
+  id: number;
+  location?: string;
+  name?: string;
+  repo_admin_change_team_access?: boolean;
+  /** deprecated */
+  username: string;
+  visibility?: string;
+  website?: string;
+}
+export const Organization = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    avatar_url: S.optional(S.String),
+    created: S.optional(S.String),
+    description: S.optional(S.String),
+    email: S.optional(S.String),
+    full_name: S.optional(S.String),
+    id: S.Number,
+    location: S.optional(S.String),
+    name: S.optional(S.String),
+    repo_admin_change_team_access: S.optional(S.Boolean),
+    username: S.String,
+    visibility: S.optional(S.String),
+    website: S.optional(S.String),
+  }),
+).annotate({ identifier: "Organization" }) as any as S.Schema<Organization>;
+
+export type TeamPermission = "none" | "read" | "write" | "admin" | "owner";
+export const TeamPermission = /*@__PURE__*/ S.String;
+
+export type TeamUnitsList = Array<string>;
+export const TeamUnitsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<TeamUnitsList>;
+
+export type TeamUnitsMapMap = { [key: string]: string | undefined };
+export const TeamUnitsMapMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<TeamUnitsMapMap>;
+
+/** Team represents a team in an organization */
+export interface Team {
+  can_create_org_repo?: boolean;
+  description?: string;
+  id: number;
+  includes_all_repositories?: boolean;
+  name: string;
+  organization?: Organization;
+  permission?: TeamPermission;
+  units?: TeamUnitsList;
+  units_map?: TeamUnitsMapMap;
+}
+export const Team = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    can_create_org_repo: S.optional(S.Boolean),
+    description: S.optional(S.String),
+    id: S.Number,
+    includes_all_repositories: S.optional(S.Boolean),
+    name: S.String,
+    organization: S.optional(Organization),
+    permission: S.optional(TeamPermission),
+    units: S.optional(TeamUnitsList),
+    units_map: S.optional(TeamUnitsMapMap),
+  }),
+).annotate({ identifier: "Team" }) as any as S.Schema<Team>;
+
+export type RepoTransferTeamsList = Array<Team>;
+export const RepoTransferTeamsList = /*@__PURE__*/ S.Array(
+  Team,
+) as any as S.Schema<RepoTransferTeamsList>;
+
+/** RepoTransfer represents a pending repo transfer */
+export interface RepoTransfer {
+  doer?: User;
+  recipient?: User;
+  teams?: RepoTransferTeamsList;
+}
+export const RepoTransfer = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    doer: S.optional(User),
+    recipient: S.optional(User),
+    teams: S.optional(RepoTransferTeamsList),
+  }),
+).annotate({ identifier: "RepoTransfer" }) as any as S.Schema<RepoTransfer>;
+
+export type RepositoryTopicsList = Array<string>;
+export const RepositoryTopicsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RepositoryTopicsList>;
+
+/** Repository represents a repository */
+export interface Repository {
+  allow_fast_forward_only_merge?: boolean;
+  allow_merge_commits?: boolean;
+  allow_rebase?: boolean;
+  allow_rebase_explicit?: boolean;
+  allow_rebase_update?: boolean;
+  allow_squash_merge?: boolean;
+  archived?: boolean;
+  archived_at?: string;
+  avatar_url?: string;
+  clone_url: string;
+  created_at: string;
+  default_allow_maintainer_edit?: boolean;
+  default_branch: string;
+  default_delete_branch_after_merge?: boolean;
+  default_merge_style?: string;
+  default_update_style?: string;
+  description?: string;
+  empty?: boolean;
+  external_tracker?: ExternalTracker;
+  external_wiki?: ExternalWiki;
+  fork?: boolean;
+  forks_count?: number;
+  full_name: string;
+  globally_editable_wiki?: boolean;
+  has_actions?: boolean;
+  has_issues?: boolean;
+  has_packages?: boolean;
+  has_projects?: boolean;
+  has_pull_requests?: boolean;
+  has_releases?: boolean;
+  /** is the wiki enabled */
+  has_wiki?: boolean;
+  /** have wiki pages ever been created */
+  has_wiki_contents?: boolean;
+  html_url: string;
+  id: number;
+  ignore_whitespace_conflicts?: boolean;
+  internal?: boolean;
+  internal_tracker?: InternalTracker;
+  language?: string;
+  languages_url?: string;
+  link?: string;
+  mirror?: boolean;
+  mirror_interval?: string;
+  mirror_updated?: string;
+  name: string;
+  /** ObjectFormatName of the underlying git repository */
+  object_format_name?: RepositoryObjectFormatName;
+  open_issues_count?: number;
+  open_pr_counter?: number;
+  original_url?: string;
+  owner: User;
+  parent?: Repository;
+  permissions?: Permission;
+  private?: boolean;
+  release_counter?: number;
+  repo_transfer?: RepoTransfer;
+  size?: number;
+  ssh_url: string;
+  stars_count?: number;
+  template?: boolean;
+  topics?: RepositoryTopicsList;
+  updated_at: string;
+  url?: string;
+  watchers_count?: number;
+  website?: string;
+  wiki_branch?: string;
+  wiki_clone_url?: string;
+  wiki_ssh_url?: string;
+}
+export const Repository = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allow_fast_forward_only_merge: S.optional(S.Boolean),
+    allow_merge_commits: S.optional(S.Boolean),
+    allow_rebase: S.optional(S.Boolean),
+    allow_rebase_explicit: S.optional(S.Boolean),
+    allow_rebase_update: S.optional(S.Boolean),
+    allow_squash_merge: S.optional(S.Boolean),
+    archived: S.optional(S.Boolean),
+    archived_at: S.optional(S.String),
+    avatar_url: S.optional(S.String),
+    clone_url: S.String,
+    created_at: S.String,
+    default_allow_maintainer_edit: S.optional(S.Boolean),
+    default_branch: S.String,
+    default_delete_branch_after_merge: S.optional(S.Boolean),
+    default_merge_style: S.optional(S.String),
+    default_update_style: S.optional(S.String),
+    description: S.optional(S.String),
+    empty: S.optional(S.Boolean),
+    external_tracker: S.optional(ExternalTracker),
+    external_wiki: S.optional(ExternalWiki),
+    fork: S.optional(S.Boolean),
+    forks_count: S.optional(S.Number),
+    full_name: S.String,
+    globally_editable_wiki: S.optional(S.Boolean),
+    has_actions: S.optional(S.Boolean),
+    has_issues: S.optional(S.Boolean),
+    has_packages: S.optional(S.Boolean),
+    has_projects: S.optional(S.Boolean),
+    has_pull_requests: S.optional(S.Boolean),
+    has_releases: S.optional(S.Boolean),
+    has_wiki: S.optional(S.Boolean),
+    has_wiki_contents: S.optional(S.Boolean),
+    html_url: S.String,
+    id: S.Number,
+    ignore_whitespace_conflicts: S.optional(S.Boolean),
+    internal: S.optional(S.Boolean),
+    internal_tracker: S.optional(InternalTracker),
+    language: S.optional(S.String),
+    languages_url: S.optional(S.String),
+    link: S.optional(S.String),
+    mirror: S.optional(S.Boolean),
+    mirror_interval: S.optional(S.String),
+    mirror_updated: S.optional(S.String),
+    name: S.String,
+    object_format_name: S.optional(RepositoryObjectFormatName),
+    open_issues_count: S.optional(S.Number),
+    open_pr_counter: S.optional(S.Number),
+    original_url: S.optional(S.String),
+    owner: User,
+    parent: S.optional(Repository),
+    permissions: S.optional(Permission),
+    private: S.optional(S.Boolean),
+    release_counter: S.optional(S.Number),
+    repo_transfer: S.optional(RepoTransfer),
+    size: S.optional(S.Number),
+    ssh_url: S.String,
+    stars_count: S.optional(S.Number),
+    template: S.optional(S.Boolean),
+    topics: S.optional(RepositoryTopicsList),
+    updated_at: S.String,
+    url: S.optional(S.String),
+    watchers_count: S.optional(S.Number),
+    website: S.optional(S.String),
+    wiki_branch: S.optional(S.String),
+    wiki_clone_url: S.optional(S.String),
+    wiki_ssh_url: S.optional(S.String),
+  }),
+).annotate({ identifier: "Repository" }) as any as S.Schema<Repository>;
+
+/** ActionRun represents an action run */
+export interface ActionRun {
+  /** the cron id for the schedule trigger */
+  ScheduleID?: number;
+  /** who approved this action run */
+  approved_by?: number;
+  /** the commit sha the action run ran on */
+  commit_sha?: string;
+  /** when the action run was created */
+  created?: string;
+  duration?: number;
+  /** the webhook event that causes the workflow to run */
+  event?: string;
+  /** the payload of the webhook event that causes the workflow to run */
+  event_payload?: string;
+  /** the url of this action run */
+  html_url?: string;
+  /** the action run id */
+  id?: number;
+  /** a unique number for each run of a repository */
+  index_in_repo?: number;
+  /** If this is triggered by a PR from a forked repository or an untrusted user, we need to check if it is approved and limit permissions when running the workflow. */
+  is_fork_pull_request?: boolean;
+  /** has the commit/tag/… the action run ran on been deleted */
+  is_ref_deleted?: boolean;
+  /** may need approval if it's a fork pull request */
+  need_approval?: boolean;
+  /** the commit/tag/… the action run ran on */
+  prettyref?: string;
+  repository?: Repository;
+  /** when the action run was started */
+  started?: string;
+  /** the current status of this run */
+  status?: string;
+  /** when the action run was stopped */
+  stopped?: string;
+  /** the action run's title */
+  title?: string;
+  /** the trigger event defined in the `on` configuration of the triggered workflow */
+  trigger_event?: string;
+  trigger_user?: User;
+  /** when the action run was last updated */
+  updated?: string;
+  /** the name of workflow file */
+  workflow_id?: string;
+}
+export const ActionRun = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ScheduleID: S.optional(S.Number),
+    approved_by: S.optional(S.Number),
+    commit_sha: S.optional(S.String),
+    created: S.optional(S.String),
+    duration: S.optional(S.Number),
+    event: S.optional(S.String),
+    event_payload: S.optional(S.String),
+    html_url: S.optional(S.String),
+    id: S.optional(S.Number),
+    index_in_repo: S.optional(S.Number),
+    is_fork_pull_request: S.optional(S.Boolean),
+    is_ref_deleted: S.optional(S.Boolean),
+    need_approval: S.optional(S.Boolean),
+    prettyref: S.optional(S.String),
+    repository: S.optional(Repository),
+    started: S.optional(S.String),
+    status: S.optional(S.String),
+    stopped: S.optional(S.String),
+    title: S.optional(S.String),
+    trigger_event: S.optional(S.String),
+    trigger_user: S.optional(User),
+    updated: S.optional(S.String),
+    workflow_id: S.optional(S.String),
+  }),
+).annotate({ identifier: "ActionRun" }) as any as S.Schema<ActionRun>;
+
+export interface GetGitignoreTemplateInfoRequest {
+  /** name of the template */
+  name: string;
+}
+export const GetGitignoreTemplateInfoRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/gitignore/templates/{name}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetGitignoreTemplateInfoRequest",
+}) as any as S.Schema<GetGitignoreTemplateInfoRequest>;
+
+/** GitignoreTemplateInfo name and text of a gitignore template */
+export interface GitignoreTemplateInfo {
+  name?: string;
+  source?: string;
+}
+export const GitignoreTemplateInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    source: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "GitignoreTemplateInfo",
+}) as any as S.Schema<GitignoreTemplateInfo>;
+
+export interface GetLabelTemplateInfoRequest {
+  /** name of the template */
+  name: string;
+}
+export const GetLabelTemplateInfoRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/label/templates/{name}", code: 200 })),
+).annotate({
+  identifier: "GetLabelTemplateInfoRequest",
+}) as any as S.Schema<GetLabelTemplateInfoRequest>;
+
+/** LabelTemplate info of a Label template */
+export interface LabelTemplate {
+  color?: string;
+  description?: string;
+  exclusive?: boolean;
+  name?: string;
+}
+export const LabelTemplate = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    color: S.optional(S.String),
+    description: S.optional(S.String),
+    exclusive: S.optional(S.Boolean),
+    name: S.optional(S.String),
+  }),
+).annotate({ identifier: "LabelTemplate" }) as any as S.Schema<LabelTemplate>;
+
+export type GetLabelTemplateInfoResponseBodyList = Array<LabelTemplate>;
+export const GetLabelTemplateInfoResponseBodyList = /*@__PURE__*/ S.Array(
+  LabelTemplate,
+) as any as S.Schema<GetLabelTemplateInfoResponseBodyList>;
+
+export type GetLabelTemplateInfoResponse = GetLabelTemplateInfoResponseBodyList;
+export const GetLabelTemplateInfoResponse = /*@__PURE__*/ S.suspend(() =>
+  GetLabelTemplateInfoResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetLabelTemplateInfoResponse",
+}) as any as S.Schema<GetLabelTemplateInfoResponse>;
+
+export interface GetLicenseTemplateInfoRequest {
+  /** name of the license */
+  name: string;
+}
+export const GetLicenseTemplateInfoRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/licenses/{name}", code: 200 })),
+).annotate({
+  identifier: "GetLicenseTemplateInfoRequest",
+}) as any as S.Schema<GetLicenseTemplateInfoRequest>;
+
+/** LicensesInfo contains information about a License */
+export interface LicenseTemplateInfo {
+  body?: string;
+  implementation?: string;
+  key?: string;
+  name?: string;
+  url?: string;
+}
+export const LicenseTemplateInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    body: S.optional(S.String),
+    implementation: S.optional(S.String),
+    key: S.optional(S.String),
+    name: S.optional(S.String),
+    url: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "LicenseTemplateInfo",
+}) as any as S.Schema<LicenseTemplateInfo>;
+
+export interface GetNodeInfoRequest {}
+export const GetNodeInfoRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/nodeinfo", code: 200 })),
+).annotate({
+  identifier: "GetNodeInfoRequest",
+}) as any as S.Schema<GetNodeInfoRequest>;
+
+export type NodeInfoProtocolsList = Array<string>;
+export const NodeInfoProtocolsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<NodeInfoProtocolsList>;
+
+export type NodeInfoServicesInboundList = Array<string>;
+export const NodeInfoServicesInboundList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<NodeInfoServicesInboundList>;
+
+export type NodeInfoServicesOutboundList = Array<string>;
+export const NodeInfoServicesOutboundList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<NodeInfoServicesOutboundList>;
+
+/** NodeInfoServices contains the third party sites this server can connect to via their application API */
+export interface NodeInfoServices {
+  inbound?: NodeInfoServicesInboundList;
+  outbound?: NodeInfoServicesOutboundList;
+}
+export const NodeInfoServices = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    inbound: S.optional(NodeInfoServicesInboundList),
+    outbound: S.optional(NodeInfoServicesOutboundList),
+  }),
+).annotate({
+  identifier: "NodeInfoServices",
+}) as any as S.Schema<NodeInfoServices>;
+
+/** NodeInfoSoftware contains Metadata about server software in use */
+export interface NodeInfoSoftware {
+  homepage?: string;
+  name?: string;
+  repository?: string;
+  version?: string;
+}
+export const NodeInfoSoftware = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    homepage: S.optional(S.String),
+    name: S.optional(S.String),
+    repository: S.optional(S.String),
+    version: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "NodeInfoSoftware",
+}) as any as S.Schema<NodeInfoSoftware>;
+
+/** NodeInfoUsageUsers contains statistics about the users of this server */
+export interface NodeInfoUsageUsers {
+  activeHalfyear?: number;
+  activeMonth?: number;
+  total?: number;
+}
+export const NodeInfoUsageUsers = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    activeHalfyear: S.optional(S.Number),
+    activeMonth: S.optional(S.Number),
+    total: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "NodeInfoUsageUsers",
+}) as any as S.Schema<NodeInfoUsageUsers>;
+
+/** NodeInfoUsage contains usage statistics for this server */
+export interface NodeInfoUsage {
+  localComments?: number;
+  localPosts?: number;
+  users?: NodeInfoUsageUsers;
+}
+export const NodeInfoUsage = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    localComments: S.optional(S.Number),
+    localPosts: S.optional(S.Number),
+    users: S.optional(NodeInfoUsageUsers),
+  }),
+).annotate({ identifier: "NodeInfoUsage" }) as any as S.Schema<NodeInfoUsage>;
+
+/** NodeInfo contains standardized way of exposing metadata about a server running one of the distributed social networks */
+export interface NodeInfo {
+  metadata?: unknown;
+  openRegistrations?: boolean;
+  protocols?: NodeInfoProtocolsList;
+  services?: NodeInfoServices;
+  software?: NodeInfoSoftware;
+  usage?: NodeInfoUsage;
+  version?: string;
+}
+export const NodeInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    metadata: S.optional(S.Unknown),
+    openRegistrations: S.optional(S.Boolean),
+    protocols: S.optional(NodeInfoProtocolsList),
+    services: S.optional(NodeInfoServices),
+    software: S.optional(NodeInfoSoftware),
+    usage: S.optional(NodeInfoUsage),
+    version: S.optional(S.String),
+  }),
+).annotate({ identifier: "NodeInfo" }) as any as S.Schema<NodeInfo>;
+
+export interface GetSigningKeyRequest {}
+export const GetSigningKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/signing-key.gpg", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetSigningKeyRequest",
+}) as any as S.Schema<GetSigningKeyRequest>;
+
+export type GetSigningKeyResponse = string;
+export const GetSigningKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetSigningKeyResponse",
+}) as any as S.Schema<GetSigningKeyResponse>;
+
+export interface GetSSHSigningKeyRequest {}
+export const GetSSHSigningKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/signing-key.ssh", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetSSHSigningKeyRequest",
+}) as any as S.Schema<GetSSHSigningKeyRequest>;
+
+export type GetSSHSigningKeyResponse = string;
+export const GetSSHSigningKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetSSHSigningKeyResponse",
+}) as any as S.Schema<GetSSHSigningKeyResponse>;
+
+export interface GetVersionRequest {}
+export const GetVersionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/version", code: 200 })),
+).annotate({
+  identifier: "GetVersionRequest",
+}) as any as S.Schema<GetVersionRequest>;
+
+/** ServerVersion wraps the version of the server */
+export interface ServerVersion {
+  version?: string;
+}
+export const ServerVersion = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    version: S.optional(S.String),
+  }),
+).annotate({ identifier: "ServerVersion" }) as any as S.Schema<ServerVersion>;
+
+export interface ListGitignoresTemplatesRequest {}
+export const ListGitignoresTemplatesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/gitignore/templates", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListGitignoresTemplatesRequest",
+}) as any as S.Schema<ListGitignoresTemplatesRequest>;
+
+export type ListGitignoresTemplatesResponseBodyList = Array<string>;
+export const ListGitignoresTemplatesResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListGitignoresTemplatesResponseBodyList>;
+
+export type ListGitignoresTemplatesResponse =
+  ListGitignoresTemplatesResponseBodyList;
+export const ListGitignoresTemplatesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListGitignoresTemplatesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListGitignoresTemplatesResponse",
+}) as any as S.Schema<ListGitignoresTemplatesResponse>;
+
+export interface ListLabelTemplatesRequest {}
+export const ListLabelTemplatesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/label/templates", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListLabelTemplatesRequest",
+}) as any as S.Schema<ListLabelTemplatesRequest>;
+
+export type ListLabelTemplatesResponseBodyList = Array<string>;
+export const ListLabelTemplatesResponseBodyList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListLabelTemplatesResponseBodyList>;
+
+export type ListLabelTemplatesResponse = ListLabelTemplatesResponseBodyList;
+export const ListLabelTemplatesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListLabelTemplatesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListLabelTemplatesResponse",
+}) as any as S.Schema<ListLabelTemplatesResponse>;
+
+export interface ListLicenseTemplatesRequest {}
+export const ListLicenseTemplatesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/licenses", code: 200 })),
+).annotate({
+  identifier: "ListLicenseTemplatesRequest",
+}) as any as S.Schema<ListLicenseTemplatesRequest>;
+
+/** LicensesListEntry is used for the API */
+export interface LicensesTemplateListEntry {
+  key?: string;
+  name?: string;
+  url?: string;
+}
+export const LicensesTemplateListEntry = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    key: S.optional(S.String),
+    name: S.optional(S.String),
+    url: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "LicensesTemplateListEntry",
+}) as any as S.Schema<LicensesTemplateListEntry>;
+
+export type ListLicenseTemplatesResponseBodyList =
+  Array<LicensesTemplateListEntry>;
+export const ListLicenseTemplatesResponseBodyList = /*@__PURE__*/ S.Array(
+  LicensesTemplateListEntry,
+) as any as S.Schema<ListLicenseTemplatesResponseBodyList>;
+
+export type ListLicenseTemplatesResponse = ListLicenseTemplatesResponseBodyList;
+export const ListLicenseTemplatesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListLicenseTemplatesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListLicenseTemplatesResponse",
+}) as any as S.Schema<ListLicenseTemplatesResponse>;
+
+export interface RenderMarkdownRequest {
+  /** Context to render */
+  Context?: string;
+  /** Mode to render (comment, gfm, markdown) */
+  Mode?: string;
+  /** Text markdown to render */
+  Text?: string;
+  /** Is it a wiki page ? */
+  Wiki?: boolean;
+}
+export const RenderMarkdownRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    Context: S.optional(S.String),
+    Mode: S.optional(S.String),
+    Text: S.optional(S.String),
+    Wiki: S.optional(S.Boolean),
+  }).pipe(T.Http({ method: "POST", uri: "/markdown", code: 200 })),
+).annotate({
+  identifier: "RenderMarkdownRequest",
+}) as any as S.Schema<RenderMarkdownRequest>;
+
+export type RenderMarkdownResponse = string;
+export const RenderMarkdownResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "RenderMarkdownResponse",
+}) as any as S.Schema<RenderMarkdownResponse>;
+
+export interface RenderMarkdownRawRequest {
+  body: string;
+}
+export const RenderMarkdownRawRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    body: S.String.pipe(T.HttpBody()),
+  }).pipe(T.Http({ method: "POST", uri: "/markdown/raw", code: 200 })),
+).annotate({
+  identifier: "RenderMarkdownRawRequest",
+}) as any as S.Schema<RenderMarkdownRawRequest>;
+
+export type RenderMarkdownRawResponse = string;
+export const RenderMarkdownRawResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "RenderMarkdownRawResponse",
+}) as any as S.Schema<RenderMarkdownRawResponse>;
+
+export interface RenderMarkupRequest {
+  /** The current branch path where the form gets posted */
+  BranchPath?: string;
+  /** Context to render */
+  Context?: string;
+  /** File path for detecting extension in file mode */
+  FilePath?: string;
+  /** Mode to render (comment, gfm, markdown, file) */
+  Mode?: string;
+  /** Text markup to render */
+  Text?: string;
+  /** Is it a wiki page ? */
+  Wiki?: boolean;
+}
+export const RenderMarkupRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    BranchPath: S.optional(S.String),
+    Context: S.optional(S.String),
+    FilePath: S.optional(S.String),
+    Mode: S.optional(S.String),
+    Text: S.optional(S.String),
+    Wiki: S.optional(S.Boolean),
+  }).pipe(T.Http({ method: "POST", uri: "/markup", code: 200 })),
+).annotate({
+  identifier: "RenderMarkupRequest",
+}) as any as S.Schema<RenderMarkupRequest>;
+
+export type RenderMarkupResponse = string;
+export const RenderMarkupResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "RenderMarkupResponse",
+}) as any as S.Schema<RenderMarkupResponse>;
+
+export type GetActionsRunError = ForgejoOpError;
+/** Get a workflow run associated with a token The automatic actions token must be used as the authentication mechanism (<code>Authorization: Bearer $&#x7b;&#x7b; forgejo.token &#x7d;&#x7d;</code>); other types of tokens cannot be used. The token is associated with the job, which must be still running for the request to this endpoint to succeed. */
+export const getActionsRun: API.OperationMethod<
+  GetActionsRunRequest,
+  ActionRun,
+  GetActionsRunError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetActionsRunRequest,
+  output: ActionRun,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetGitignoreTemplateInfoError = NotFound | ForgejoOpError;
+/** Returns information about a gitignore template */
+export const getGitignoreTemplateInfo: API.OperationMethod<
+  GetGitignoreTemplateInfoRequest,
+  GitignoreTemplateInfo,
+  GetGitignoreTemplateInfoError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetGitignoreTemplateInfoRequest,
+  output: GitignoreTemplateInfo,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetLabelTemplateInfoError = NotFound | ForgejoOpError;
+/** Returns all labels in a template */
+export const getLabelTemplateInfo: API.OperationMethod<
+  GetLabelTemplateInfoRequest,
+  GetLabelTemplateInfoResponse,
+  GetLabelTemplateInfoError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetLabelTemplateInfoRequest,
+  output: GetLabelTemplateInfoResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetLicenseTemplateInfoError = NotFound | ForgejoOpError;
+/** Returns information about a license template */
+export const getLicenseTemplateInfo: API.OperationMethod<
+  GetLicenseTemplateInfoRequest,
+  LicenseTemplateInfo,
+  GetLicenseTemplateInfoError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetLicenseTemplateInfoRequest,
+  output: LicenseTemplateInfo,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetNodeInfoError = ForgejoOpError;
+/** Returns the nodeinfo of the Forgejo application */
+export const getNodeInfo: API.OperationMethod<
+  GetNodeInfoRequest,
+  NodeInfo,
+  GetNodeInfoError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetNodeInfoRequest,
+  output: NodeInfo,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSigningKeyError = ForgejoOpError;
+/** Get default signing-key.gpg */
+export const getSigningKey: API.OperationMethod<
+  GetSigningKeyRequest,
+  GetSigningKeyResponse,
+  GetSigningKeyError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSigningKeyRequest,
+  output: GetSigningKeyResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSSHSigningKeyError = NotFound | ForgejoOpError;
+/** Get default signing-key.ssh */
+export const getSSHSigningKey: API.OperationMethod<
+  GetSSHSigningKeyRequest,
+  GetSSHSigningKeyResponse,
+  GetSSHSigningKeyError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSSHSigningKeyRequest,
+  output: GetSSHSigningKeyResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVersionError = ForgejoOpError;
+/** Returns the version of the running application */
+export const getVersion: API.OperationMethod<
+  GetVersionRequest,
+  ServerVersion,
+  GetVersionError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVersionRequest,
+  output: ServerVersion,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListGitignoresTemplatesError = ForgejoOpError;
+/** Returns a list of all gitignore templates */
+export const listGitignoresTemplates: API.OperationMethod<
+  ListGitignoresTemplatesRequest,
+  ListGitignoresTemplatesResponse,
+  ListGitignoresTemplatesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListGitignoresTemplatesRequest,
+  output: ListGitignoresTemplatesResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListLabelTemplatesError = ForgejoOpError;
+/** Returns a list of all label templates */
+export const listLabelTemplates: API.OperationMethod<
+  ListLabelTemplatesRequest,
+  ListLabelTemplatesResponse,
+  ListLabelTemplatesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListLabelTemplatesRequest,
+  output: ListLabelTemplatesResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListLicenseTemplatesError = ForgejoOpError;
+/** Returns a list of all license templates */
+export const listLicenseTemplates: API.OperationMethod<
+  ListLicenseTemplatesRequest,
+  ListLicenseTemplatesResponse,
+  ListLicenseTemplatesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListLicenseTemplatesRequest,
+  output: ListLicenseTemplatesResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RenderMarkdownError = UnprocessableEntity | ForgejoOpError;
+/** Render a markdown document as HTML */
+export const renderMarkdown: API.OperationMethod<
+  RenderMarkdownRequest,
+  RenderMarkdownResponse,
+  RenderMarkdownError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RenderMarkdownRequest,
+  output: RenderMarkdownResponse,
+  errors: [UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RenderMarkdownRawError = UnprocessableEntity | ForgejoOpError;
+/** Render raw markdown as HTML */
+export const renderMarkdownRaw: API.OperationMethod<
+  RenderMarkdownRawRequest,
+  RenderMarkdownRawResponse,
+  RenderMarkdownRawError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RenderMarkdownRawRequest,
+  output: RenderMarkdownRawResponse,
+  errors: [UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RenderMarkupError = UnprocessableEntity | ForgejoOpError;
+/** Render a markup document as HTML */
+export const renderMarkup: API.OperationMethod<
+  RenderMarkupRequest,
+  RenderMarkupResponse,
+  RenderMarkupError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RenderMarkupRequest,
+  output: RenderMarkupResponse,
+  errors: [UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));