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

package/src/services/organization.ts

@@ -0,0 +1,4008 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-forgejo). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as C from "@distilled.cloud/core/category";
+import * as T from "../traits.ts";
+import {
+  ForgejoProtocol,
+  type ForgejoOpError,
+  type ForgejoOpContext,
+} from "../protocol.ts";
+import * as Retry from "../retry.ts";
+
+export type { ForgejoOpError, ForgejoOpContext };
+
+export class BadRequest
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<BadRequest>()("BadRequest", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 400 }],
+  ) {}
+
+export class Conflict
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<Conflict>()("Conflict", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withConflictError),
+    [{ status: 409 }],
+  ) {}
+
+export class Forbidden
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<Forbidden>()("Forbidden", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withAuthError),
+    [{ status: 403 }],
+  ) {}
+
+export class NotFound
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<NotFound>()("NotFound", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 404 }],
+  ) {}
+
+/** The organization still owns repositories and cannot be deleted until they are gone (Forgejo answers HTTP 500 with `user still has ownership of repositories`). Retry once the repositories are deleted. */
+export class OrganizationOwnsRepositories
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<OrganizationOwnsRepositories>()(
+      "OrganizationOwnsRepositories",
+      {
+        code: S.Number,
+        message: S.String,
+      },
+    ).pipe(C.withConflictError),
+    [
+      {
+        status: 500,
+        message: { includes: "still has ownership of repositories" },
+      },
+    ],
+  ) {}
+
+export class UnprocessableEntity
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<UnprocessableEntity>()("UnprocessableEntity", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 422 }],
+  ) {}
+
+/** possible values are `public` (default), `limited` or `private` */
+export type CreateOrgRequestVisibility = "public" | "limited" | "private";
+export const CreateOrgRequestVisibility = /*@__PURE__*/ S.String;
+
+export interface CreateOrgRequest {
+  description?: string;
+  email?: string;
+  full_name?: string;
+  location?: string;
+  repo_admin_change_team_access?: boolean;
+  username: string;
+  /** possible values are `public` (default), `limited` or `private` */
+  visibility?: CreateOrgRequestVisibility | (string & {});
+  website?: string;
+}
+export const CreateOrgRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    email: S.optional(S.String),
+    full_name: S.optional(S.String),
+    location: S.optional(S.String),
+    repo_admin_change_team_access: S.optional(S.Boolean),
+    username: S.String,
+    visibility: S.optional(CreateOrgRequestVisibility),
+    website: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/orgs", code: 200 })),
+).annotate({
+  identifier: "CreateOrgRequest",
+}) as any as S.Schema<CreateOrgRequest>;
+
+/** 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>;
+
+/** ObjectFormatName of the underlying git repository */
+export type CreateOrgRepoRequestObjectFormatName = "sha1" | "sha256";
+export const CreateOrgRepoRequestObjectFormatName = /*@__PURE__*/ S.String;
+
+/** TrustModel of the repository */
+export type CreateOrgRepoRequestTrustModel =
+  | "default"
+  | "collaborator"
+  | "committer"
+  | "collaboratorcommitter";
+export const CreateOrgRepoRequestTrustModel = /*@__PURE__*/ S.String;
+
+export interface CreateOrgRepoRequest {
+  /** name of organization */
+  org: string;
+  /** Whether the repository should be auto-initialized? */
+  auto_init?: boolean;
+  /** DefaultBranch of the repository (used when initializes and in template) */
+  default_branch?: string;
+  /** Description of the repository to create */
+  description?: string;
+  /** Gitignores to use, separated by commas */
+  gitignores?: string;
+  /** Label-Set to use */
+  issue_labels?: string;
+  /** License to use */
+  license?: string;
+  /** Name of the repository to create */
+  name: string;
+  /** ObjectFormatName of the underlying git repository */
+  object_format_name?: CreateOrgRepoRequestObjectFormatName | (string & {});
+  /** Whether the repository is private */
+  private?: boolean;
+  /** Readme of the repository to create */
+  readme?: string;
+  /** Whether the repository is template */
+  template?: boolean;
+  /** TrustModel of the repository */
+  trust_model?: CreateOrgRepoRequestTrustModel | (string & {});
+}
+export const CreateOrgRepoRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    auto_init: S.optional(S.Boolean),
+    default_branch: S.optional(S.String),
+    description: S.optional(S.String),
+    gitignores: S.optional(S.String),
+    issue_labels: S.optional(S.String),
+    license: S.optional(S.String),
+    name: S.String,
+    object_format_name: S.optional(CreateOrgRepoRequestObjectFormatName),
+    private: S.optional(S.Boolean),
+    readme: S.optional(S.String),
+    template: S.optional(S.Boolean),
+    trust_model: S.optional(CreateOrgRepoRequestTrustModel),
+  }).pipe(T.Http({ method: "POST", uri: "/orgs/{org}/repos", code: 200 })),
+).annotate({
+  identifier: "CreateOrgRepoRequest",
+}) as any as S.Schema<CreateOrgRepoRequest>;
+
+/** 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>;
+
+export type TeamPermission = "none" | "read" | "write" | "admin" | "owner";
+export const TeamPermission = /*@__PURE__*/ S.String;
+
+export type TeamUnitsList = Array<string>;
+export const TeamUnitsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<TeamUnitsList>;
+
+export type TeamUnitsMapMap = { [key: string]: string | undefined };
+export const TeamUnitsMapMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<TeamUnitsMapMap>;
+
+/** Team represents a team in an organization */
+export interface Team {
+  can_create_org_repo?: boolean;
+  description?: string;
+  id: number;
+  includes_all_repositories?: boolean;
+  name: string;
+  organization?: Organization;
+  permission?: TeamPermission;
+  units?: TeamUnitsList;
+  units_map?: TeamUnitsMapMap;
+}
+export const Team = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    can_create_org_repo: S.optional(S.Boolean),
+    description: S.optional(S.String),
+    id: S.Number,
+    includes_all_repositories: S.optional(S.Boolean),
+    name: S.String,
+    organization: S.optional(Organization),
+    permission: S.optional(TeamPermission),
+    units: S.optional(TeamUnitsList),
+    units_map: S.optional(TeamUnitsMapMap),
+  }),
+).annotate({ identifier: "Team" }) as any as S.Schema<Team>;
+
+export type RepoTransferTeamsList = Array<Team>;
+export const RepoTransferTeamsList = /*@__PURE__*/ S.Array(
+  Team,
+) as any as S.Schema<RepoTransferTeamsList>;
+
+/** RepoTransfer represents a pending repo transfer */
+export interface RepoTransfer {
+  doer?: User;
+  recipient?: User;
+  teams?: RepoTransferTeamsList;
+}
+export const RepoTransfer = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    doer: S.optional(User),
+    recipient: S.optional(User),
+    teams: S.optional(RepoTransferTeamsList),
+  }),
+).annotate({ identifier: "RepoTransfer" }) as any as S.Schema<RepoTransfer>;
+
+export type RepositoryTopicsList = Array<string>;
+export const RepositoryTopicsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RepositoryTopicsList>;
+
+/** Repository represents a repository */
+export interface Repository {
+  allow_fast_forward_only_merge?: boolean;
+  allow_merge_commits?: boolean;
+  allow_rebase?: boolean;
+  allow_rebase_explicit?: boolean;
+  allow_rebase_update?: boolean;
+  allow_squash_merge?: boolean;
+  archived?: boolean;
+  archived_at?: string;
+  avatar_url?: string;
+  clone_url: string;
+  created_at: string;
+  default_allow_maintainer_edit?: boolean;
+  default_branch: string;
+  default_delete_branch_after_merge?: boolean;
+  default_merge_style?: string;
+  default_update_style?: string;
+  description?: string;
+  empty?: boolean;
+  external_tracker?: ExternalTracker;
+  external_wiki?: ExternalWiki;
+  fork?: boolean;
+  forks_count?: number;
+  full_name: string;
+  globally_editable_wiki?: boolean;
+  has_actions?: boolean;
+  has_issues?: boolean;
+  has_packages?: boolean;
+  has_projects?: boolean;
+  has_pull_requests?: boolean;
+  has_releases?: boolean;
+  /** is the wiki enabled */
+  has_wiki?: boolean;
+  /** have wiki pages ever been created */
+  has_wiki_contents?: boolean;
+  html_url: string;
+  id: number;
+  ignore_whitespace_conflicts?: boolean;
+  internal?: boolean;
+  internal_tracker?: InternalTracker;
+  language?: string;
+  languages_url?: string;
+  link?: string;
+  mirror?: boolean;
+  mirror_interval?: string;
+  mirror_updated?: string;
+  name: string;
+  /** ObjectFormatName of the underlying git repository */
+  object_format_name?: RepositoryObjectFormatName;
+  open_issues_count?: number;
+  open_pr_counter?: number;
+  original_url?: string;
+  owner: User;
+  parent?: Repository;
+  permissions?: Permission;
+  private?: boolean;
+  release_counter?: number;
+  repo_transfer?: RepoTransfer;
+  size?: number;
+  ssh_url: string;
+  stars_count?: number;
+  template?: boolean;
+  topics?: RepositoryTopicsList;
+  updated_at: string;
+  url?: string;
+  watchers_count?: number;
+  website?: string;
+  wiki_branch?: string;
+  wiki_clone_url?: string;
+  wiki_ssh_url?: string;
+}
+export const Repository = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allow_fast_forward_only_merge: S.optional(S.Boolean),
+    allow_merge_commits: S.optional(S.Boolean),
+    allow_rebase: S.optional(S.Boolean),
+    allow_rebase_explicit: S.optional(S.Boolean),
+    allow_rebase_update: S.optional(S.Boolean),
+    allow_squash_merge: S.optional(S.Boolean),
+    archived: S.optional(S.Boolean),
+    archived_at: S.optional(S.String),
+    avatar_url: S.optional(S.String),
+    clone_url: S.String,
+    created_at: S.String,
+    default_allow_maintainer_edit: S.optional(S.Boolean),
+    default_branch: S.String,
+    default_delete_branch_after_merge: S.optional(S.Boolean),
+    default_merge_style: S.optional(S.String),
+    default_update_style: S.optional(S.String),
+    description: S.optional(S.String),
+    empty: S.optional(S.Boolean),
+    external_tracker: S.optional(ExternalTracker),
+    external_wiki: S.optional(ExternalWiki),
+    fork: S.optional(S.Boolean),
+    forks_count: S.optional(S.Number),
+    full_name: S.String,
+    globally_editable_wiki: S.optional(S.Boolean),
+    has_actions: S.optional(S.Boolean),
+    has_issues: S.optional(S.Boolean),
+    has_packages: S.optional(S.Boolean),
+    has_projects: S.optional(S.Boolean),
+    has_pull_requests: S.optional(S.Boolean),
+    has_releases: S.optional(S.Boolean),
+    has_wiki: S.optional(S.Boolean),
+    has_wiki_contents: S.optional(S.Boolean),
+    html_url: S.String,
+    id: S.Number,
+    ignore_whitespace_conflicts: S.optional(S.Boolean),
+    internal: S.optional(S.Boolean),
+    internal_tracker: S.optional(InternalTracker),
+    language: S.optional(S.String),
+    languages_url: S.optional(S.String),
+    link: S.optional(S.String),
+    mirror: S.optional(S.Boolean),
+    mirror_interval: S.optional(S.String),
+    mirror_updated: S.optional(S.String),
+    name: S.String,
+    object_format_name: S.optional(RepositoryObjectFormatName),
+    open_issues_count: S.optional(S.Number),
+    open_pr_counter: S.optional(S.Number),
+    original_url: S.optional(S.String),
+    owner: User,
+    parent: S.optional(Repository),
+    permissions: S.optional(Permission),
+    private: S.optional(S.Boolean),
+    release_counter: S.optional(S.Number),
+    repo_transfer: S.optional(RepoTransfer),
+    size: S.optional(S.Number),
+    ssh_url: S.String,
+    stars_count: S.optional(S.Number),
+    template: S.optional(S.Boolean),
+    topics: S.optional(RepositoryTopicsList),
+    updated_at: S.String,
+    url: S.optional(S.String),
+    watchers_count: S.optional(S.Number),
+    website: S.optional(S.String),
+    wiki_branch: S.optional(S.String),
+    wiki_clone_url: S.optional(S.String),
+    wiki_ssh_url: S.optional(S.String),
+  }),
+).annotate({ identifier: "Repository" }) as any as S.Schema<Repository>;
+
+export interface CreateOrgVariableRequest {
+  /** name of the organization */
+  org: string;
+  /** name of the variable */
+  variablename: string;
+  /** Value of the variable to create. Special characters will be retained. Line endings will be normalized to LF to match the behaviour of browsers. Encode the data with Base64 if line endings should be retained. */
+  value: string;
+}
+export const CreateOrgVariableRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    variablename: S.String.pipe(T.Label()),
+    value: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/orgs/{org}/actions/variables/{variablename}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateOrgVariableRequest",
+}) as any as S.Schema<CreateOrgVariableRequest>;
+
+export interface CreateOrgVariableResponse {}
+export const CreateOrgVariableResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateOrgVariableResponse",
+}) as any as S.Schema<CreateOrgVariableResponse>;
+
+export interface DeleteOrgRequest {
+  /** organization that is to be deleted */
+  org: string;
+}
+export const DeleteOrgRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "DELETE", uri: "/orgs/{org}", code: 200 })),
+).annotate({
+  identifier: "DeleteOrgRequest",
+}) as any as S.Schema<DeleteOrgRequest>;
+
+export interface DeleteOrgResponse {}
+export const DeleteOrgResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteOrgResponse",
+}) as any as S.Schema<DeleteOrgResponse>;
+
+export interface DeleteOrgRunnerRequest {
+  /** name of the organization */
+  org: string;
+  /** ID of the runner */
+  runner_id: string;
+}
+export const DeleteOrgRunnerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    runner_id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/orgs/{org}/actions/runners/{runner_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteOrgRunnerRequest",
+}) as any as S.Schema<DeleteOrgRunnerRequest>;
+
+export interface DeleteOrgRunnerResponse {}
+export const DeleteOrgRunnerResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteOrgRunnerResponse",
+}) as any as S.Schema<DeleteOrgRunnerResponse>;
+
+export interface DeleteOrgSecretRequest {
+  /** name of organization */
+  org: string;
+  /** name of the secret */
+  secretname: string;
+}
+export const DeleteOrgSecretRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    secretname: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/orgs/{org}/actions/secrets/{secretname}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteOrgSecretRequest",
+}) as any as S.Schema<DeleteOrgSecretRequest>;
+
+export interface DeleteOrgSecretResponse {}
+export const DeleteOrgSecretResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteOrgSecretResponse",
+}) as any as S.Schema<DeleteOrgSecretResponse>;
+
+export interface DeleteOrgVariableRequest {
+  /** name of the organization */
+  org: string;
+  /** name of the variable */
+  variablename: string;
+}
+export const DeleteOrgVariableRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    variablename: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/orgs/{org}/actions/variables/{variablename}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteOrgVariableRequest",
+}) as any as S.Schema<DeleteOrgVariableRequest>;
+
+export interface DeleteOrgVariableResponse {}
+export const DeleteOrgVariableResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteOrgVariableResponse",
+}) as any as S.Schema<DeleteOrgVariableResponse>;
+
+/** possible values are `public`, `limited` or `private` */
+export type EditOrgRequestVisibility = "public" | "limited" | "private";
+export const EditOrgRequestVisibility = /*@__PURE__*/ S.String;
+
+export interface EditOrgRequest {
+  /** name of the organization to edit */
+  org: string;
+  description?: string;
+  email?: string;
+  full_name?: string;
+  location?: string;
+  repo_admin_change_team_access?: boolean;
+  /** possible values are `public`, `limited` or `private` */
+  visibility?: EditOrgRequestVisibility | (string & {});
+  website?: string;
+}
+export const EditOrgRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    description: S.optional(S.String),
+    email: S.optional(S.String),
+    full_name: S.optional(S.String),
+    location: S.optional(S.String),
+    repo_admin_change_team_access: S.optional(S.Boolean),
+    visibility: S.optional(EditOrgRequestVisibility),
+    website: S.optional(S.String),
+  }).pipe(T.Http({ method: "PATCH", uri: "/orgs/{org}", code: 200 })),
+).annotate({ identifier: "EditOrgRequest" }) as any as S.Schema<EditOrgRequest>;
+
+export interface GetOrgRequest {
+  /** name of the organization to get */
+  org: string;
+}
+export const GetOrgRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/orgs/{org}", code: 200 })),
+).annotate({ identifier: "GetOrgRequest" }) as any as S.Schema<GetOrgRequest>;
+
+export interface GetOrgRunnerRequest {
+  /** name of the organization */
+  org: string;
+  /** ID of the runner */
+  runner_id: string;
+}
+export const GetOrgRunnerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    runner_id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/orgs/{org}/actions/runners/{runner_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOrgRunnerRequest",
+}) as any as S.Schema<GetOrgRunnerRequest>;
+
+/** Labels is a list of labels attached to this runner. */
+export type ActionRunnerLabelsList = Array<string>;
+export const ActionRunnerLabelsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ActionRunnerLabelsList>;
+
+/** Status indicates whether this runner is offline, or active, for example. */
+export type ActionRunnerStatus = "offline" | "idle" | "active";
+export const ActionRunnerStatus = /*@__PURE__*/ S.String;
+
+/** ActionRunner represents a runner */
+export interface ActionRunner {
+  /** Description provides optional details about this runner. */
+  description?: string;
+  /** Indicates if runner is ephemeral runner */
+  ephemeral?: boolean;
+  /** ID uniquely identifies this runner. */
+  id?: number;
+  /** Labels is a list of labels attached to this runner. */
+  labels?: ActionRunnerLabelsList;
+  /** Name of the runner; not unique. */
+  name?: string;
+  /** OwnerID is the identifier of the user or organization this runner belongs to. O if the runner is owned by a repository. */
+  owner_id?: number;
+  /** RepoID is the identifier of the repository this runner belongs to. 0 if the runner belongs to a user or organization. */
+  repo_id?: number;
+  /** Status indicates whether this runner is offline, or active, for example. */
+  status?: ActionRunnerStatus;
+  /** UUID uniquely identifies this runner. */
+  uuid?: string;
+  /** Version is the self-reported version string of Forgejo Runner. */
+  version?: string;
+}
+export const ActionRunner = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    ephemeral: S.optional(S.Boolean),
+    id: S.optional(S.Number),
+    labels: S.optional(ActionRunnerLabelsList),
+    name: S.optional(S.String),
+    owner_id: S.optional(S.Number),
+    repo_id: S.optional(S.Number),
+    status: S.optional(ActionRunnerStatus),
+    uuid: S.optional(S.String),
+    version: S.optional(S.String),
+  }),
+).annotate({ identifier: "ActionRunner" }) as any as S.Schema<ActionRunner>;
+
+export interface GetOrgRunnersRequest {
+  /** name of the organization */
+  org: string;
+  /** whether to include all visible runners (true) or only those that are directly owned by the organization (false) */
+  visible?: boolean;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const GetOrgRunnersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    visible: S.optional(S.Boolean.pipe(T.Query())),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/orgs/{org}/actions/runners", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetOrgRunnersRequest",
+}) as any as S.Schema<GetOrgRunnersRequest>;
+
+export type GetOrgRunnersResponseBodyList = Array<ActionRunner>;
+export const GetOrgRunnersResponseBodyList = /*@__PURE__*/ S.Array(
+  ActionRunner,
+) as any as S.Schema<GetOrgRunnersResponseBodyList>;
+
+export type GetOrgRunnersResponse = GetOrgRunnersResponseBodyList;
+export const GetOrgRunnersResponse = /*@__PURE__*/ S.suspend(() =>
+  GetOrgRunnersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetOrgRunnersResponse",
+}) as any as S.Schema<GetOrgRunnersResponse>;
+
+export interface GetOrgVariableRequest {
+  /** name of the organization */
+  org: string;
+  /** name of the variable */
+  variablename: string;
+}
+export const GetOrgVariableRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    variablename: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/orgs/{org}/actions/variables/{variablename}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOrgVariableRequest",
+}) as any as S.Schema<GetOrgVariableRequest>;
+
+/** ActionVariable return value of the query API */
+export interface ActionVariable {
+  /** the value of the variable */
+  data: string;
+  /** the name of the variable */
+  name: string;
+  /** the owner to which the variable belongs */
+  owner_id?: number;
+  /** the repository to which the variable belongs */
+  repo_id?: number;
+}
+export const ActionVariable = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.String,
+    name: S.String,
+    owner_id: S.optional(S.Number),
+    repo_id: S.optional(S.Number),
+  }),
+).annotate({ identifier: "ActionVariable" }) as any as S.Schema<ActionVariable>;
+
+export interface GetOrgVariablesListRequest {
+  /** name of the organization */
+  org: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const GetOrgVariablesListRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/orgs/{org}/actions/variables", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetOrgVariablesListRequest",
+}) as any as S.Schema<GetOrgVariablesListRequest>;
+
+export type GetOrgVariablesListResponseBodyList = Array<ActionVariable>;
+export const GetOrgVariablesListResponseBodyList = /*@__PURE__*/ S.Array(
+  ActionVariable,
+) as any as S.Schema<GetOrgVariablesListResponseBodyList>;
+
+export type GetOrgVariablesListResponse = GetOrgVariablesListResponseBodyList;
+export const GetOrgVariablesListResponse = /*@__PURE__*/ S.suspend(() =>
+  GetOrgVariablesListResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetOrgVariablesListResponse",
+}) as any as S.Schema<GetOrgVariablesListResponse>;
+
+export interface OrgAddTeamMemberRequest {
+  /** id of the team */
+  id: number;
+  /** username of the user to add */
+  username: string;
+}
+export const OrgAddTeamMemberRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/teams/{id}/members/{username}", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgAddTeamMemberRequest",
+}) as any as S.Schema<OrgAddTeamMemberRequest>;
+
+export interface OrgAddTeamMemberResponse {}
+export const OrgAddTeamMemberResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgAddTeamMemberResponse",
+}) as any as S.Schema<OrgAddTeamMemberResponse>;
+
+export interface OrgAddTeamRepositoryRequest {
+  /** id of the team */
+  id: number;
+  /** organization that owns the repo to add */
+  org: string;
+  /** name of the repo to add */
+  repo: string;
+}
+export const OrgAddTeamRepositoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+    org: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/teams/{id}/repos/{org}/{repo}", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgAddTeamRepositoryRequest",
+}) as any as S.Schema<OrgAddTeamRepositoryRequest>;
+
+export interface OrgAddTeamRepositoryResponse {}
+export const OrgAddTeamRepositoryResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgAddTeamRepositoryResponse",
+}) as any as S.Schema<OrgAddTeamRepositoryResponse>;
+
+export interface OrgBlockUserRequest {
+  /** name of the org */
+  org: string;
+  /** username of the user */
+  username: string;
+}
+export const OrgBlockUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/orgs/{org}/block/{username}", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgBlockUserRequest",
+}) as any as S.Schema<OrgBlockUserRequest>;
+
+export interface OrgBlockUserResponse {}
+export const OrgBlockUserResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgBlockUserResponse",
+}) as any as S.Schema<OrgBlockUserResponse>;
+
+export interface OrgCheckQuotaRequest {
+  /** name of the organization */
+  org: string;
+  /** subject of the quota */
+  subject: string;
+}
+export const OrgCheckQuotaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    subject: S.String.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/orgs/{org}/quota/check", code: 200 })),
+).annotate({
+  identifier: "OrgCheckQuotaRequest",
+}) as any as S.Schema<OrgCheckQuotaRequest>;
+
+export type OrgCheckQuotaResponse = boolean;
+export const OrgCheckQuotaResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Boolean.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgCheckQuotaResponse",
+}) as any as S.Schema<OrgCheckQuotaResponse>;
+
+export interface OrgConcealMemberRequest {
+  /** name of the organization */
+  org: string;
+  /** username of the user */
+  username: string;
+}
+export const OrgConcealMemberRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/orgs/{org}/public_members/{username}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "OrgConcealMemberRequest",
+}) as any as S.Schema<OrgConcealMemberRequest>;
+
+export interface OrgConcealMemberResponse {}
+export const OrgConcealMemberResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgConcealMemberResponse",
+}) as any as S.Schema<OrgConcealMemberResponse>;
+
+/** CreateHookOptionConfig has all config options in it required are "content_type" and "url" Required */
+export type CreateHookOptionConfig = { [key: string]: string | undefined };
+export const CreateHookOptionConfig = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<CreateHookOptionConfig>;
+
+export type OrgCreateHookRequestEventsList = Array<string>;
+export const OrgCreateHookRequestEventsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<OrgCreateHookRequestEventsList>;
+
+export type OrgCreateHookRequestType =
+  | "forgejo"
+  | "dingtalk"
+  | "discord"
+  | "gitea"
+  | "gogs"
+  | "msteams"
+  | "slack"
+  | "telegram"
+  | "feishu"
+  | "wechatwork"
+  | "packagist";
+export const OrgCreateHookRequestType = /*@__PURE__*/ S.String;
+
+export interface OrgCreateHookRequest {
+  /** name of the organization */
+  org: string;
+  active?: boolean;
+  authorization_header?: string;
+  branch_filter?: string;
+  config: CreateHookOptionConfig;
+  events?: OrgCreateHookRequestEventsList;
+  type: OrgCreateHookRequestType | (string & {});
+}
+export const OrgCreateHookRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    active: S.optional(S.Boolean),
+    authorization_header: S.optional(S.String),
+    branch_filter: S.optional(S.String),
+    config: CreateHookOptionConfig,
+    events: S.optional(OrgCreateHookRequestEventsList),
+    type: OrgCreateHookRequestType,
+  }).pipe(T.Http({ method: "POST", uri: "/orgs/{org}/hooks", code: 200 })),
+).annotate({
+  identifier: "OrgCreateHookRequest",
+}) as any as S.Schema<OrgCreateHookRequest>;
+
+/** Deprecated: use Metadata instead */
+export type HookConfigMap = { [key: string]: string | undefined };
+export const HookConfigMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<HookConfigMap>;
+
+export type HookEventsList = Array<string>;
+export const HookEventsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<HookEventsList>;
+
+/** Hook a hook is a web hook when one repository changed */
+export interface Hook {
+  active: boolean;
+  authorization_header?: string;
+  branch_filter?: string;
+  /** Deprecated: use Metadata instead */
+  config?: HookConfigMap;
+  content_type?: string;
+  created_at: string;
+  events?: HookEventsList;
+  id: number;
+  metadata?: unknown;
+  type: string;
+  updated_at: string;
+  url: string;
+}
+export const Hook = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    active: S.Boolean,
+    authorization_header: S.optional(S.String),
+    branch_filter: S.optional(S.String),
+    config: S.optional(HookConfigMap),
+    content_type: S.optional(S.String),
+    created_at: S.String,
+    events: S.optional(HookEventsList),
+    id: S.Number,
+    metadata: S.optional(S.Unknown),
+    type: S.String,
+    updated_at: S.String,
+    url: S.String,
+  }),
+).annotate({ identifier: "Hook" }) as any as S.Schema<Hook>;
+
+export interface OrgCreateLabelRequest {
+  /** name of the organization */
+  org: string;
+  color: string;
+  description?: string;
+  exclusive?: boolean;
+  is_archived?: boolean;
+  name: string;
+}
+export const OrgCreateLabelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    color: S.String,
+    description: S.optional(S.String),
+    exclusive: S.optional(S.Boolean),
+    is_archived: S.optional(S.Boolean),
+    name: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/orgs/{org}/labels", code: 200 })),
+).annotate({
+  identifier: "OrgCreateLabelRequest",
+}) as any as S.Schema<OrgCreateLabelRequest>;
+
+/** Label a label to an issue or a pr */
+export interface Label {
+  color: string;
+  description?: string;
+  exclusive?: boolean;
+  id: number;
+  is_archived?: boolean;
+  name: string;
+  url?: string;
+}
+export const Label = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    color: S.String,
+    description: S.optional(S.String),
+    exclusive: S.optional(S.Boolean),
+    id: S.Number,
+    is_archived: S.optional(S.Boolean),
+    name: S.String,
+    url: S.optional(S.String),
+  }),
+).annotate({ identifier: "Label" }) as any as S.Schema<Label>;
+
+export type OrgCreateTeamRequestPermission = "read" | "write" | "admin";
+export const OrgCreateTeamRequestPermission = /*@__PURE__*/ S.String;
+
+export type OrgCreateTeamRequestUnitsList = Array<string>;
+export const OrgCreateTeamRequestUnitsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<OrgCreateTeamRequestUnitsList>;
+
+export type OrgCreateTeamRequestUnitsMapMap = {
+  [key: string]: string | undefined;
+};
+export const OrgCreateTeamRequestUnitsMapMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<OrgCreateTeamRequestUnitsMapMap>;
+
+export interface OrgCreateTeamRequest {
+  /** name of the organization */
+  org: string;
+  can_create_org_repo?: boolean;
+  description?: string;
+  includes_all_repositories?: boolean;
+  name: string;
+  permission?: OrgCreateTeamRequestPermission | (string & {});
+  units?: OrgCreateTeamRequestUnitsList;
+  units_map?: OrgCreateTeamRequestUnitsMapMap;
+}
+export const OrgCreateTeamRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    can_create_org_repo: S.optional(S.Boolean),
+    description: S.optional(S.String),
+    includes_all_repositories: S.optional(S.Boolean),
+    name: S.String,
+    permission: S.optional(OrgCreateTeamRequestPermission),
+    units: S.optional(OrgCreateTeamRequestUnitsList),
+    units_map: S.optional(OrgCreateTeamRequestUnitsMapMap),
+  }).pipe(T.Http({ method: "POST", uri: "/orgs/{org}/teams", code: 200 })),
+).annotate({
+  identifier: "OrgCreateTeamRequest",
+}) as any as S.Schema<OrgCreateTeamRequest>;
+
+export interface OrgDeleteAvatarRequest {
+  /** name of the organization */
+  org: string;
+}
+export const OrgDeleteAvatarRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "DELETE", uri: "/orgs/{org}/avatar", code: 200 })),
+).annotate({
+  identifier: "OrgDeleteAvatarRequest",
+}) as any as S.Schema<OrgDeleteAvatarRequest>;
+
+export interface OrgDeleteAvatarResponse {}
+export const OrgDeleteAvatarResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgDeleteAvatarResponse",
+}) as any as S.Schema<OrgDeleteAvatarResponse>;
+
+export interface OrgDeleteHookRequest {
+  /** name of the organization */
+  org: string;
+  /** id of the hook to delete */
+  id: number;
+}
+export const OrgDeleteHookRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "DELETE", uri: "/orgs/{org}/hooks/{id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgDeleteHookRequest",
+}) as any as S.Schema<OrgDeleteHookRequest>;
+
+export interface OrgDeleteHookResponse {}
+export const OrgDeleteHookResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgDeleteHookResponse",
+}) as any as S.Schema<OrgDeleteHookResponse>;
+
+export interface OrgDeleteLabelRequest {
+  /** name of the organization */
+  org: string;
+  /** id of the label to delete */
+  id: number;
+}
+export const OrgDeleteLabelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "DELETE", uri: "/orgs/{org}/labels/{id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgDeleteLabelRequest",
+}) as any as S.Schema<OrgDeleteLabelRequest>;
+
+export interface OrgDeleteLabelResponse {}
+export const OrgDeleteLabelResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgDeleteLabelResponse",
+}) as any as S.Schema<OrgDeleteLabelResponse>;
+
+export interface OrgDeleteMemberRequest {
+  /** name of the organization */
+  org: string;
+  /** username of the user */
+  username: string;
+}
+export const OrgDeleteMemberRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/orgs/{org}/members/{username}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "OrgDeleteMemberRequest",
+}) as any as S.Schema<OrgDeleteMemberRequest>;
+
+export interface OrgDeleteMemberResponse {}
+export const OrgDeleteMemberResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgDeleteMemberResponse",
+}) as any as S.Schema<OrgDeleteMemberResponse>;
+
+export interface OrgDeleteTeamRequest {
+  /** id of the team to delete */
+  id: number;
+}
+export const OrgDeleteTeamRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "DELETE", uri: "/teams/{id}", code: 200 })),
+).annotate({
+  identifier: "OrgDeleteTeamRequest",
+}) as any as S.Schema<OrgDeleteTeamRequest>;
+
+export interface OrgDeleteTeamResponse {}
+export const OrgDeleteTeamResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgDeleteTeamResponse",
+}) as any as S.Schema<OrgDeleteTeamResponse>;
+
+export type OrgEditHookRequestConfigMap = { [key: string]: string | undefined };
+export const OrgEditHookRequestConfigMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<OrgEditHookRequestConfigMap>;
+
+export type OrgEditHookRequestEventsList = Array<string>;
+export const OrgEditHookRequestEventsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<OrgEditHookRequestEventsList>;
+
+export interface OrgEditHookRequest {
+  /** name of the organization */
+  org: string;
+  /** id of the hook to update */
+  id: number;
+  active?: boolean;
+  authorization_header?: string;
+  branch_filter?: string;
+  config?: OrgEditHookRequestConfigMap;
+  events?: OrgEditHookRequestEventsList;
+}
+export const OrgEditHookRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+    active: S.optional(S.Boolean),
+    authorization_header: S.optional(S.String),
+    branch_filter: S.optional(S.String),
+    config: S.optional(OrgEditHookRequestConfigMap),
+    events: S.optional(OrgEditHookRequestEventsList),
+  }).pipe(
+    T.Http({ method: "PATCH", uri: "/orgs/{org}/hooks/{id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgEditHookRequest",
+}) as any as S.Schema<OrgEditHookRequest>;
+
+export interface OrgEditLabelRequest {
+  /** name of the organization */
+  org: string;
+  /** id of the label to edit */
+  id: number;
+  color?: string;
+  description?: string;
+  exclusive?: boolean;
+  is_archived?: boolean;
+  name?: string;
+}
+export const OrgEditLabelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+    color: S.optional(S.String),
+    description: S.optional(S.String),
+    exclusive: S.optional(S.Boolean),
+    is_archived: S.optional(S.Boolean),
+    name: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "PATCH", uri: "/orgs/{org}/labels/{id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgEditLabelRequest",
+}) as any as S.Schema<OrgEditLabelRequest>;
+
+export type OrgEditTeamRequestPermission = "read" | "write" | "admin";
+export const OrgEditTeamRequestPermission = /*@__PURE__*/ S.String;
+
+export type OrgEditTeamRequestUnitsList = Array<string>;
+export const OrgEditTeamRequestUnitsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<OrgEditTeamRequestUnitsList>;
+
+export type OrgEditTeamRequestUnitsMapMap = {
+  [key: string]: string | undefined;
+};
+export const OrgEditTeamRequestUnitsMapMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<OrgEditTeamRequestUnitsMapMap>;
+
+export interface OrgEditTeamRequest {
+  /** id of the team to edit */
+  id: number;
+  can_create_org_repo?: boolean;
+  description?: string;
+  includes_all_repositories?: boolean;
+  name: string;
+  permission?: OrgEditTeamRequestPermission | (string & {});
+  units?: OrgEditTeamRequestUnitsList;
+  units_map?: OrgEditTeamRequestUnitsMapMap;
+}
+export const OrgEditTeamRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+    can_create_org_repo: S.optional(S.Boolean),
+    description: S.optional(S.String),
+    includes_all_repositories: S.optional(S.Boolean),
+    name: S.String,
+    permission: S.optional(OrgEditTeamRequestPermission),
+    units: S.optional(OrgEditTeamRequestUnitsList),
+    units_map: S.optional(OrgEditTeamRequestUnitsMapMap),
+  }).pipe(T.Http({ method: "PATCH", uri: "/teams/{id}", code: 200 })),
+).annotate({
+  identifier: "OrgEditTeamRequest",
+}) as any as S.Schema<OrgEditTeamRequest>;
+
+export interface OrgGetAllRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgGetAllRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/orgs", code: 200 })),
+).annotate({
+  identifier: "OrgGetAllRequest",
+}) as any as S.Schema<OrgGetAllRequest>;
+
+export type OrgGetAllResponseBodyList = Array<Organization>;
+export const OrgGetAllResponseBodyList = /*@__PURE__*/ S.Array(
+  Organization,
+) as any as S.Schema<OrgGetAllResponseBodyList>;
+
+export type OrgGetAllResponse = OrgGetAllResponseBodyList;
+export const OrgGetAllResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgGetAllResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgGetAllResponse",
+}) as any as S.Schema<OrgGetAllResponse>;
+
+export interface OrgGetHookRequest {
+  /** name of the organization */
+  org: string;
+  /** id of the hook to get */
+  id: number;
+}
+export const OrgGetHookRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/orgs/{org}/hooks/{id}", code: 200 })),
+).annotate({
+  identifier: "OrgGetHookRequest",
+}) as any as S.Schema<OrgGetHookRequest>;
+
+export interface OrgGetLabelRequest {
+  /** name of the organization */
+  org: string;
+  /** id of the label to get */
+  id: number;
+}
+export const OrgGetLabelRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    id: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/orgs/{org}/labels/{id}", code: 200 })),
+).annotate({
+  identifier: "OrgGetLabelRequest",
+}) as any as S.Schema<OrgGetLabelRequest>;
+
+export interface OrgGetQuotaRequest {
+  /** name of the organization */
+  org: string;
+}
+export const OrgGetQuotaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/orgs/{org}/quota", code: 200 })),
+).annotate({
+  identifier: "OrgGetQuotaRequest",
+}) as any as S.Schema<OrgGetQuotaRequest>;
+
+/** Subjects the rule affects */
+export type QuotaRuleInfoSubjectsList = Array<string>;
+export const QuotaRuleInfoSubjectsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<QuotaRuleInfoSubjectsList>;
+
+/** QuotaRuleInfo contains information about a quota rule */
+export interface QuotaRuleInfo {
+  /** The limit set by the rule */
+  limit?: number;
+  /** Name of the rule (only shown to admins) */
+  name?: string;
+  /** Subjects the rule affects */
+  subjects?: QuotaRuleInfoSubjectsList;
+}
+export const QuotaRuleInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    limit: S.optional(S.Number),
+    name: S.optional(S.String),
+    subjects: S.optional(QuotaRuleInfoSubjectsList),
+  }),
+).annotate({ identifier: "QuotaRuleInfo" }) as any as S.Schema<QuotaRuleInfo>;
+
+/** Rules associated with the group */
+export type QuotaGroupRulesList = Array<QuotaRuleInfo>;
+export const QuotaGroupRulesList = /*@__PURE__*/ S.Array(
+  QuotaRuleInfo,
+) as any as S.Schema<QuotaGroupRulesList>;
+
+/** QuotaGroup represents a quota group */
+export interface QuotaGroup {
+  /** Name of the group */
+  name?: string;
+  /** Rules associated with the group */
+  rules?: QuotaGroupRulesList;
+}
+export const QuotaGroup = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    rules: S.optional(QuotaGroupRulesList),
+  }),
+).annotate({ identifier: "QuotaGroup" }) as any as S.Schema<QuotaGroup>;
+
+/** QuotaGroupList represents a list of quota groups */
+export type QuotaGroupList = Array<QuotaGroup>;
+export const QuotaGroupList = /*@__PURE__*/ S.Array(
+  QuotaGroup,
+) as any as S.Schema<QuotaGroupList>;
+
+/** QuotaUsedSizeAssetsAttachments represents the size-based attachment quota usage of a user */
+export interface QuotaUsedSizeAssetsAttachments {
+  /** Storage size used for the user's issue & comment attachments */
+  issues?: number;
+  /** Storage size used for the user's release attachments */
+  releases?: number;
+}
+export const QuotaUsedSizeAssetsAttachments = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    issues: S.optional(S.Number),
+    releases: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "QuotaUsedSizeAssetsAttachments",
+}) as any as S.Schema<QuotaUsedSizeAssetsAttachments>;
+
+/** QuotaUsedSizeAssetsPackages represents the size-based package quota usage of a user */
+export interface QuotaUsedSizeAssetsPackages {
+  /** Storage suze used for the user's packages */
+  all?: number;
+}
+export const QuotaUsedSizeAssetsPackages = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    all: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "QuotaUsedSizeAssetsPackages",
+}) as any as S.Schema<QuotaUsedSizeAssetsPackages>;
+
+/** QuotaUsedSizeAssets represents the size-based asset usage of a user */
+export interface QuotaUsedSizeAssets {
+  /** Storage size used for the user's artifacts */
+  artifacts?: number;
+  attachments?: QuotaUsedSizeAssetsAttachments;
+  packages?: QuotaUsedSizeAssetsPackages;
+}
+export const QuotaUsedSizeAssets = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    artifacts: S.optional(S.Number),
+    attachments: S.optional(QuotaUsedSizeAssetsAttachments),
+    packages: S.optional(QuotaUsedSizeAssetsPackages),
+  }),
+).annotate({
+  identifier: "QuotaUsedSizeAssets",
+}) as any as S.Schema<QuotaUsedSizeAssets>;
+
+/** QuotaUsedSizeGit represents the size-based git (lfs) quota usage of a user */
+export interface QuotaUsedSizeGit {
+  /** Storage size of the user's Git LFS objects */
+  LFS?: number;
+}
+export const QuotaUsedSizeGit = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    LFS: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "QuotaUsedSizeGit",
+}) as any as S.Schema<QuotaUsedSizeGit>;
+
+/** QuotaUsedSizeRepos represents the size-based repository quota usage of a user */
+export interface QuotaUsedSizeRepos {
+  /** Storage size of the user's private repositories */
+  private?: number;
+  /** Storage size of the user's public repositories */
+  public?: number;
+}
+export const QuotaUsedSizeRepos = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    private: S.optional(S.Number),
+    public: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "QuotaUsedSizeRepos",
+}) as any as S.Schema<QuotaUsedSizeRepos>;
+
+/** QuotaUsedSize represents the size-based quota usage of a user */
+export interface QuotaUsedSize {
+  assets?: QuotaUsedSizeAssets;
+  git?: QuotaUsedSizeGit;
+  repos?: QuotaUsedSizeRepos;
+}
+export const QuotaUsedSize = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    assets: S.optional(QuotaUsedSizeAssets),
+    git: S.optional(QuotaUsedSizeGit),
+    repos: S.optional(QuotaUsedSizeRepos),
+  }),
+).annotate({ identifier: "QuotaUsedSize" }) as any as S.Schema<QuotaUsedSize>;
+
+/** QuotaUsed represents the quota usage of a user */
+export interface QuotaUsed {
+  size?: QuotaUsedSize;
+}
+export const QuotaUsed = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    size: S.optional(QuotaUsedSize),
+  }),
+).annotate({ identifier: "QuotaUsed" }) as any as S.Schema<QuotaUsed>;
+
+/** QuotaInfo represents information about a user's quota */
+export interface QuotaInfo {
+  groups?: QuotaGroupList;
+  used?: QuotaUsed;
+}
+export const QuotaInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    groups: S.optional(QuotaGroupList),
+    used: S.optional(QuotaUsed),
+  }),
+).annotate({ identifier: "QuotaInfo" }) as any as S.Schema<QuotaInfo>;
+
+export interface OrgGetTeamRequest {
+  /** id of the team to get */
+  id: number;
+}
+export const OrgGetTeamRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/teams/{id}", code: 200 })),
+).annotate({
+  identifier: "OrgGetTeamRequest",
+}) as any as S.Schema<OrgGetTeamRequest>;
+
+export interface OrgGetUserPermissionsRequest {
+  /** username of user */
+  username: string;
+  /** name of the organization */
+  org: string;
+}
+export const OrgGetUserPermissionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    org: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/users/{username}/orgs/{org}/permissions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "OrgGetUserPermissionsRequest",
+}) as any as S.Schema<OrgGetUserPermissionsRequest>;
+
+/** OrganizationPermissions list different users permissions on an organization */
+export interface OrganizationPermissions {
+  can_create_repository?: boolean;
+  can_read?: boolean;
+  can_write?: boolean;
+  is_admin?: boolean;
+  is_owner?: boolean;
+}
+export const OrganizationPermissions = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    can_create_repository: S.optional(S.Boolean),
+    can_read: S.optional(S.Boolean),
+    can_write: S.optional(S.Boolean),
+    is_admin: S.optional(S.Boolean),
+    is_owner: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "OrganizationPermissions",
+}) as any as S.Schema<OrganizationPermissions>;
+
+export interface OrgIsMemberRequest {
+  /** name of the organization */
+  org: string;
+  /** username of the user */
+  username: string;
+}
+export const OrgIsMemberRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/orgs/{org}/members/{username}", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgIsMemberRequest",
+}) as any as S.Schema<OrgIsMemberRequest>;
+
+export interface OrgIsMemberResponse {}
+export const OrgIsMemberResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgIsMemberResponse",
+}) as any as S.Schema<OrgIsMemberResponse>;
+
+export interface OrgIsPublicMemberRequest {
+  /** name of the organization */
+  org: string;
+  /** username of the user */
+  username: string;
+}
+export const OrgIsPublicMemberRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/orgs/{org}/public_members/{username}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "OrgIsPublicMemberRequest",
+}) as any as S.Schema<OrgIsPublicMemberRequest>;
+
+export interface OrgIsPublicMemberResponse {}
+export const OrgIsPublicMemberResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgIsPublicMemberResponse",
+}) as any as S.Schema<OrgIsPublicMemberResponse>;
+
+export interface OrgListActionsSecretsRequest {
+  /** name of the organization */
+  org: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListActionsSecretsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/orgs/{org}/actions/secrets", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgListActionsSecretsRequest",
+}) as any as S.Schema<OrgListActionsSecretsRequest>;
+
+/** Secret represents a secret */
+export interface Secret {
+  created_at: string;
+  /** the secret's name */
+  name: string;
+}
+export const Secret = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    created_at: S.String,
+    name: S.String,
+  }),
+).annotate({ identifier: "Secret" }) as any as S.Schema<Secret>;
+
+export type OrgListActionsSecretsResponseBodyList = Array<Secret>;
+export const OrgListActionsSecretsResponseBodyList = /*@__PURE__*/ S.Array(
+  Secret,
+) as any as S.Schema<OrgListActionsSecretsResponseBodyList>;
+
+export type OrgListActionsSecretsResponse =
+  OrgListActionsSecretsResponseBodyList;
+export const OrgListActionsSecretsResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListActionsSecretsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListActionsSecretsResponse",
+}) as any as S.Schema<OrgListActionsSecretsResponse>;
+
+export interface OrgListActivityFeedsRequest {
+  /** name of the org */
+  org: string;
+  /** the date of the activities to be found */
+  date?: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListActivityFeedsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    date: S.optional(S.String.pipe(T.Query())),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/orgs/{org}/activities/feeds", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgListActivityFeedsRequest",
+}) as any as S.Schema<OrgListActivityFeedsRequest>;
+
+export type AttachmentType = "attachment" | "external";
+export const AttachmentType = /*@__PURE__*/ S.String;
+
+/** Attachment a generic attachment */
+export interface Attachment {
+  browser_download_url?: string;
+  created_at?: string;
+  download_count?: number;
+  id?: number;
+  name?: string;
+  size?: number;
+  type?: AttachmentType;
+  uuid?: string;
+}
+export const Attachment = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    browser_download_url: S.optional(S.String),
+    created_at: S.optional(S.String),
+    download_count: S.optional(S.Number),
+    id: S.optional(S.Number),
+    name: S.optional(S.String),
+    size: S.optional(S.Number),
+    type: S.optional(AttachmentType),
+    uuid: S.optional(S.String),
+  }),
+).annotate({ identifier: "Attachment" }) as any as S.Schema<Attachment>;
+
+/** The attachments to the comment */
+export type CommentAssetsList = Array<Attachment>;
+export const CommentAssetsList = /*@__PURE__*/ S.Array(
+  Attachment,
+) as any as S.Schema<CommentAssetsList>;
+
+/** Comment represents a comment on a commit or issue */
+export interface Comment {
+  /** The attachments to the comment */
+  assets?: CommentAssetsList;
+  /** The body of the comment */
+  body?: string;
+  /** The time of the comment's creation */
+  created_at?: string;
+  /** The HTML URL of the comment */
+  html_url?: string;
+  /** The identifier of the comment */
+  id?: number;
+  /** The HTML URL of the issue if the comment is posted on an issue, else empty string */
+  issue_url?: string;
+  /** The original author that posted the comment if it was not posted locally, else empty string */
+  original_author?: string;
+  /** The ID of the original author that posted the comment if it was not posted locally, else 0 */
+  original_author_id?: number;
+  /** The HTML URL of the pull request if the comment is posted on a pull request, else empty string */
+  pull_request_url?: string;
+  /** The time of the comment's update */
+  updated_at?: string;
+  user?: User;
+}
+export const Comment = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    assets: S.optional(CommentAssetsList),
+    body: S.optional(S.String),
+    created_at: S.optional(S.String),
+    html_url: S.optional(S.String),
+    id: S.optional(S.Number),
+    issue_url: S.optional(S.String),
+    original_author: S.optional(S.String),
+    original_author_id: S.optional(S.Number),
+    pull_request_url: S.optional(S.String),
+    updated_at: S.optional(S.String),
+    user: S.optional(User),
+  }),
+).annotate({ identifier: "Comment" }) as any as S.Schema<Comment>;
+
+/** the type of action */
+export type ActivityOpType =
+  | "create_repo"
+  | "rename_repo"
+  | "star_repo"
+  | "watch_repo"
+  | "commit_repo"
+  | "create_issue"
+  | "create_pull_request"
+  | "transfer_repo"
+  | "push_tag"
+  | "comment_issue"
+  | "merge_pull_request"
+  | "close_issue"
+  | "reopen_issue"
+  | "close_pull_request"
+  | "reopen_pull_request"
+  | "delete_tag"
+  | "delete_branch"
+  | "mirror_sync_push"
+  | "mirror_sync_create"
+  | "mirror_sync_delete"
+  | "approve_pull_request"
+  | "reject_pull_request"
+  | "comment_pull"
+  | "publish_release"
+  | "pull_review_dismissed"
+  | "pull_request_ready_for_review"
+  | "auto_merge_pull_request";
+export const ActivityOpType = /*@__PURE__*/ S.String;
+
+export interface Activity {
+  act_user?: User;
+  act_user_id?: number;
+  comment?: Comment;
+  comment_id?: number;
+  content?: string;
+  created?: string;
+  id?: number;
+  is_private?: boolean;
+  /** the type of action */
+  op_type?: ActivityOpType;
+  ref_name?: string;
+  repo?: Repository;
+  repo_id?: number;
+  user_id?: number;
+}
+export const Activity = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    act_user: S.optional(User),
+    act_user_id: S.optional(S.Number),
+    comment: S.optional(Comment),
+    comment_id: S.optional(S.Number),
+    content: S.optional(S.String),
+    created: S.optional(S.String),
+    id: S.optional(S.Number),
+    is_private: S.optional(S.Boolean),
+    op_type: S.optional(ActivityOpType),
+    ref_name: S.optional(S.String),
+    repo: S.optional(Repository),
+    repo_id: S.optional(S.Number),
+    user_id: S.optional(S.Number),
+  }),
+).annotate({ identifier: "Activity" }) as any as S.Schema<Activity>;
+
+export type OrgListActivityFeedsResponseBodyList = Array<Activity>;
+export const OrgListActivityFeedsResponseBodyList = /*@__PURE__*/ S.Array(
+  Activity,
+) as any as S.Schema<OrgListActivityFeedsResponseBodyList>;
+
+export type OrgListActivityFeedsResponse = OrgListActivityFeedsResponseBodyList;
+export const OrgListActivityFeedsResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListActivityFeedsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListActivityFeedsResponse",
+}) as any as S.Schema<OrgListActivityFeedsResponse>;
+
+export interface OrgListBlockedUsersRequest {
+  /** name of the org */
+  org: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListBlockedUsersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/orgs/{org}/list_blocked", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgListBlockedUsersRequest",
+}) as any as S.Schema<OrgListBlockedUsersRequest>;
+
+export interface BlockedUser {
+  block_id?: number;
+  created_at?: string;
+}
+export const BlockedUser = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    block_id: S.optional(S.Number),
+    created_at: S.optional(S.String),
+  }),
+).annotate({ identifier: "BlockedUser" }) as any as S.Schema<BlockedUser>;
+
+export type OrgListBlockedUsersResponseBodyList = Array<BlockedUser>;
+export const OrgListBlockedUsersResponseBodyList = /*@__PURE__*/ S.Array(
+  BlockedUser,
+) as any as S.Schema<OrgListBlockedUsersResponseBodyList>;
+
+export type OrgListBlockedUsersResponse = OrgListBlockedUsersResponseBodyList;
+export const OrgListBlockedUsersResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListBlockedUsersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListBlockedUsersResponse",
+}) as any as S.Schema<OrgListBlockedUsersResponse>;
+
+export interface OrgListCurrentUserOrgsRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListCurrentUserOrgsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/orgs", code: 200 })),
+).annotate({
+  identifier: "OrgListCurrentUserOrgsRequest",
+}) as any as S.Schema<OrgListCurrentUserOrgsRequest>;
+
+export type OrgListCurrentUserOrgsResponseBodyList = Array<Organization>;
+export const OrgListCurrentUserOrgsResponseBodyList = /*@__PURE__*/ S.Array(
+  Organization,
+) as any as S.Schema<OrgListCurrentUserOrgsResponseBodyList>;
+
+export type OrgListCurrentUserOrgsResponse =
+  OrgListCurrentUserOrgsResponseBodyList;
+export const OrgListCurrentUserOrgsResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListCurrentUserOrgsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListCurrentUserOrgsResponse",
+}) as any as S.Schema<OrgListCurrentUserOrgsResponse>;
+
+export interface OrgListHooksRequest {
+  /** name of the organization */
+  org: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListHooksRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/orgs/{org}/hooks", code: 200 })),
+).annotate({
+  identifier: "OrgListHooksRequest",
+}) as any as S.Schema<OrgListHooksRequest>;
+
+export type OrgListHooksResponseBodyList = Array<Hook>;
+export const OrgListHooksResponseBodyList = /*@__PURE__*/ S.Array(
+  Hook,
+) as any as S.Schema<OrgListHooksResponseBodyList>;
+
+export type OrgListHooksResponse = OrgListHooksResponseBodyList;
+export const OrgListHooksResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListHooksResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListHooksResponse",
+}) as any as S.Schema<OrgListHooksResponse>;
+
+export type OrgListLabelsRequestSort =
+  | "mostissues"
+  | "leastissues"
+  | "reversealphabetically";
+export const OrgListLabelsRequestSort = /*@__PURE__*/ S.String;
+
+export interface OrgListLabelsRequest {
+  /** name of the organization */
+  org: string;
+  /** Specifies the sorting method: mostissues, leastissues, or reversealphabetically. */
+  sort?: OrgListLabelsRequestSort | (string & {});
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListLabelsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    sort: S.optional(OrgListLabelsRequestSort.pipe(T.Query())),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/orgs/{org}/labels", code: 200 })),
+).annotate({
+  identifier: "OrgListLabelsRequest",
+}) as any as S.Schema<OrgListLabelsRequest>;
+
+export type OrgListLabelsResponseBodyList = Array<Label>;
+export const OrgListLabelsResponseBodyList = /*@__PURE__*/ S.Array(
+  Label,
+) as any as S.Schema<OrgListLabelsResponseBodyList>;
+
+export type OrgListLabelsResponse = OrgListLabelsResponseBodyList;
+export const OrgListLabelsResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListLabelsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListLabelsResponse",
+}) as any as S.Schema<OrgListLabelsResponse>;
+
+export interface OrgListMembersRequest {
+  /** name of the organization */
+  org: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListMembersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/orgs/{org}/members", code: 200 })),
+).annotate({
+  identifier: "OrgListMembersRequest",
+}) as any as S.Schema<OrgListMembersRequest>;
+
+export type OrgListMembersResponseBodyList = Array<User>;
+export const OrgListMembersResponseBodyList = /*@__PURE__*/ S.Array(
+  User,
+) as any as S.Schema<OrgListMembersResponseBodyList>;
+
+export type OrgListMembersResponse = OrgListMembersResponseBodyList;
+export const OrgListMembersResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListMembersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListMembersResponse",
+}) as any as S.Schema<OrgListMembersResponse>;
+
+export interface OrgListPublicMembersRequest {
+  /** name of the organization */
+  org: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListPublicMembersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/orgs/{org}/public_members", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgListPublicMembersRequest",
+}) as any as S.Schema<OrgListPublicMembersRequest>;
+
+export type OrgListPublicMembersResponseBodyList = Array<User>;
+export const OrgListPublicMembersResponseBodyList = /*@__PURE__*/ S.Array(
+  User,
+) as any as S.Schema<OrgListPublicMembersResponseBodyList>;
+
+export type OrgListPublicMembersResponse = OrgListPublicMembersResponseBodyList;
+export const OrgListPublicMembersResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListPublicMembersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListPublicMembersResponse",
+}) as any as S.Schema<OrgListPublicMembersResponse>;
+
+export interface OrgListQuotaArtifactsRequest {
+  /** name of the organization */
+  org: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListQuotaArtifactsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/orgs/{org}/quota/artifacts", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgListQuotaArtifactsRequest",
+}) as any as S.Schema<OrgListQuotaArtifactsRequest>;
+
+/** QuotaUsedArtifact represents an artifact counting towards a user's quota */
+export interface QuotaUsedArtifact {
+  /** HTML URL to the action run containing the artifact */
+  html_url?: string;
+  /** Name of the artifact */
+  name?: string;
+  /** Size of the artifact (compressed) */
+  size?: number;
+}
+export const QuotaUsedArtifact = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    html_url: S.optional(S.String),
+    name: S.optional(S.String),
+    size: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "QuotaUsedArtifact",
+}) as any as S.Schema<QuotaUsedArtifact>;
+
+/** QuotaUsedArtifactList represents a list of artifacts counting towards a user's quota */
+export type QuotaUsedArtifactList = Array<QuotaUsedArtifact>;
+export const QuotaUsedArtifactList = /*@__PURE__*/ S.Array(
+  QuotaUsedArtifact,
+) as any as S.Schema<QuotaUsedArtifactList>;
+
+export type OrgListQuotaArtifactsResponse = QuotaUsedArtifactList;
+export const OrgListQuotaArtifactsResponse = /*@__PURE__*/ S.suspend(() =>
+  QuotaUsedArtifactList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListQuotaArtifactsResponse",
+}) as any as S.Schema<OrgListQuotaArtifactsResponse>;
+
+export interface OrgListQuotaAttachmentsRequest {
+  /** name of the organization */
+  org: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListQuotaAttachmentsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/orgs/{org}/quota/attachments", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgListQuotaAttachmentsRequest",
+}) as any as S.Schema<OrgListQuotaAttachmentsRequest>;
+
+/** Context for the attachment: URLs to the containing object */
+export interface QuotaUsedAttachmentContainedIn {
+  /** API URL for the object that contains this attachment */
+  api_url?: string;
+  /** HTML URL for the object that contains this attachment */
+  html_url?: string;
+}
+export const QuotaUsedAttachmentContainedIn = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    api_url: S.optional(S.String),
+    html_url: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "QuotaUsedAttachmentContainedIn",
+}) as any as S.Schema<QuotaUsedAttachmentContainedIn>;
+
+/** QuotaUsedAttachment represents an attachment counting towards a user's quota */
+export interface QuotaUsedAttachment {
+  /** API URL for the attachment */
+  api_url?: string;
+  /** Context for the attachment: URLs to the containing object */
+  contained_in?: QuotaUsedAttachmentContainedIn;
+  /** Filename of the attachment */
+  name?: string;
+  /** Size of the attachment (in bytes) */
+  size?: number;
+}
+export const QuotaUsedAttachment = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    api_url: S.optional(S.String),
+    contained_in: S.optional(QuotaUsedAttachmentContainedIn),
+    name: S.optional(S.String),
+    size: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "QuotaUsedAttachment",
+}) as any as S.Schema<QuotaUsedAttachment>;
+
+/** QuotaUsedAttachmentList represents a list of attachment counting towards a user's quota */
+export type QuotaUsedAttachmentList = Array<QuotaUsedAttachment>;
+export const QuotaUsedAttachmentList = /*@__PURE__*/ S.Array(
+  QuotaUsedAttachment,
+) as any as S.Schema<QuotaUsedAttachmentList>;
+
+export type OrgListQuotaAttachmentsResponse = QuotaUsedAttachmentList;
+export const OrgListQuotaAttachmentsResponse = /*@__PURE__*/ S.suspend(() =>
+  QuotaUsedAttachmentList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListQuotaAttachmentsResponse",
+}) as any as S.Schema<OrgListQuotaAttachmentsResponse>;
+
+export interface OrgListQuotaPackagesRequest {
+  /** name of the organization */
+  org: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListQuotaPackagesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/orgs/{org}/quota/packages", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgListQuotaPackagesRequest",
+}) as any as S.Schema<OrgListQuotaPackagesRequest>;
+
+/** QuotaUsedPackage represents a package counting towards a user's quota */
+export interface QuotaUsedPackage {
+  /** HTML URL to the package version */
+  html_url?: string;
+  /** Name of the package */
+  name?: string;
+  /** Size of the package version */
+  size?: number;
+  /** Type of the package */
+  type?: string;
+  /** Version of the package */
+  version?: string;
+}
+export const QuotaUsedPackage = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    html_url: S.optional(S.String),
+    name: S.optional(S.String),
+    size: S.optional(S.Number),
+    type: S.optional(S.String),
+    version: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "QuotaUsedPackage",
+}) as any as S.Schema<QuotaUsedPackage>;
+
+/** QuotaUsedPackageList represents a list of packages counting towards a user's quota */
+export type QuotaUsedPackageList = Array<QuotaUsedPackage>;
+export const QuotaUsedPackageList = /*@__PURE__*/ S.Array(
+  QuotaUsedPackage,
+) as any as S.Schema<QuotaUsedPackageList>;
+
+export type OrgListQuotaPackagesResponse = QuotaUsedPackageList;
+export const OrgListQuotaPackagesResponse = /*@__PURE__*/ S.suspend(() =>
+  QuotaUsedPackageList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListQuotaPackagesResponse",
+}) as any as S.Schema<OrgListQuotaPackagesResponse>;
+
+export interface OrgListReposRequest {
+  /** name of the organization */
+  org: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListReposRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/orgs/{org}/repos", code: 200 })),
+).annotate({
+  identifier: "OrgListReposRequest",
+}) as any as S.Schema<OrgListReposRequest>;
+
+export type OrgListReposResponseBodyList = Array<Repository>;
+export const OrgListReposResponseBodyList = /*@__PURE__*/ S.Array(
+  Repository,
+) as any as S.Schema<OrgListReposResponseBodyList>;
+
+export type OrgListReposResponse = OrgListReposResponseBodyList;
+export const OrgListReposResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListReposResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListReposResponse",
+}) as any as S.Schema<OrgListReposResponse>;
+
+export interface OrgListTeamActivityFeedsRequest {
+  /** id of the team */
+  id: number;
+  /** the date of the activities to be found */
+  date?: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListTeamActivityFeedsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+    date: S.optional(S.String.pipe(T.Query())),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/teams/{id}/activities/feeds", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgListTeamActivityFeedsRequest",
+}) as any as S.Schema<OrgListTeamActivityFeedsRequest>;
+
+export type OrgListTeamActivityFeedsResponseBodyList = Array<Activity>;
+export const OrgListTeamActivityFeedsResponseBodyList = /*@__PURE__*/ S.Array(
+  Activity,
+) as any as S.Schema<OrgListTeamActivityFeedsResponseBodyList>;
+
+export type OrgListTeamActivityFeedsResponse =
+  OrgListTeamActivityFeedsResponseBodyList;
+export const OrgListTeamActivityFeedsResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListTeamActivityFeedsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListTeamActivityFeedsResponse",
+}) as any as S.Schema<OrgListTeamActivityFeedsResponse>;
+
+export interface OrgListTeamMemberRequest {
+  /** id of the team */
+  id: number;
+  /** username of the member to list */
+  username: string;
+}
+export const OrgListTeamMemberRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/teams/{id}/members/{username}", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgListTeamMemberRequest",
+}) as any as S.Schema<OrgListTeamMemberRequest>;
+
+export interface OrgListTeamMembersRequest {
+  /** id of the team */
+  id: number;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListTeamMembersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/teams/{id}/members", code: 200 })),
+).annotate({
+  identifier: "OrgListTeamMembersRequest",
+}) as any as S.Schema<OrgListTeamMembersRequest>;
+
+export type OrgListTeamMembersResponseBodyList = Array<User>;
+export const OrgListTeamMembersResponseBodyList = /*@__PURE__*/ S.Array(
+  User,
+) as any as S.Schema<OrgListTeamMembersResponseBodyList>;
+
+export type OrgListTeamMembersResponse = OrgListTeamMembersResponseBodyList;
+export const OrgListTeamMembersResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListTeamMembersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListTeamMembersResponse",
+}) as any as S.Schema<OrgListTeamMembersResponse>;
+
+export interface OrgListTeamRepoRequest {
+  /** id of the team */
+  id: number;
+  /** organization that owns the repo to list */
+  org: string;
+  /** name of the repo to list */
+  repo: string;
+}
+export const OrgListTeamRepoRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+    org: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/teams/{id}/repos/{org}/{repo}", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgListTeamRepoRequest",
+}) as any as S.Schema<OrgListTeamRepoRequest>;
+
+export interface OrgListTeamReposRequest {
+  /** id of the team */
+  id: number;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListTeamReposRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/teams/{id}/repos", code: 200 })),
+).annotate({
+  identifier: "OrgListTeamReposRequest",
+}) as any as S.Schema<OrgListTeamReposRequest>;
+
+export type OrgListTeamReposResponseBodyList = Array<Repository>;
+export const OrgListTeamReposResponseBodyList = /*@__PURE__*/ S.Array(
+  Repository,
+) as any as S.Schema<OrgListTeamReposResponseBodyList>;
+
+export type OrgListTeamReposResponse = OrgListTeamReposResponseBodyList;
+export const OrgListTeamReposResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListTeamReposResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListTeamReposResponse",
+}) as any as S.Schema<OrgListTeamReposResponse>;
+
+export interface OrgListTeamsRequest {
+  /** name of the organization */
+  org: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListTeamsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/orgs/{org}/teams", code: 200 })),
+).annotate({
+  identifier: "OrgListTeamsRequest",
+}) as any as S.Schema<OrgListTeamsRequest>;
+
+export type OrgListTeamsResponseBodyList = Array<Team>;
+export const OrgListTeamsResponseBodyList = /*@__PURE__*/ S.Array(
+  Team,
+) as any as S.Schema<OrgListTeamsResponseBodyList>;
+
+export type OrgListTeamsResponse = OrgListTeamsResponseBodyList;
+export const OrgListTeamsResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListTeamsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListTeamsResponse",
+}) as any as S.Schema<OrgListTeamsResponse>;
+
+export interface OrgListUserOrgsRequest {
+  /** username of user */
+  username: string;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const OrgListUserOrgsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/users/{username}/orgs", code: 200 })),
+).annotate({
+  identifier: "OrgListUserOrgsRequest",
+}) as any as S.Schema<OrgListUserOrgsRequest>;
+
+export type OrgListUserOrgsResponseBodyList = Array<Organization>;
+export const OrgListUserOrgsResponseBodyList = /*@__PURE__*/ S.Array(
+  Organization,
+) as any as S.Schema<OrgListUserOrgsResponseBodyList>;
+
+export type OrgListUserOrgsResponse = OrgListUserOrgsResponseBodyList;
+export const OrgListUserOrgsResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgListUserOrgsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgListUserOrgsResponse",
+}) as any as S.Schema<OrgListUserOrgsResponse>;
+
+export interface OrgPublicizeMemberRequest {
+  /** name of the organization */
+  org: string;
+  /** username of the user */
+  username: string;
+}
+export const OrgPublicizeMemberRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/orgs/{org}/public_members/{username}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "OrgPublicizeMemberRequest",
+}) as any as S.Schema<OrgPublicizeMemberRequest>;
+
+export interface OrgPublicizeMemberResponse {}
+export const OrgPublicizeMemberResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgPublicizeMemberResponse",
+}) as any as S.Schema<OrgPublicizeMemberResponse>;
+
+export interface OrgRemoveTeamMemberRequest {
+  /** id of the team */
+  id: number;
+  /** username of the user to remove */
+  username: string;
+}
+export const OrgRemoveTeamMemberRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/teams/{id}/members/{username}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "OrgRemoveTeamMemberRequest",
+}) as any as S.Schema<OrgRemoveTeamMemberRequest>;
+
+export interface OrgRemoveTeamMemberResponse {}
+export const OrgRemoveTeamMemberResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgRemoveTeamMemberResponse",
+}) as any as S.Schema<OrgRemoveTeamMemberResponse>;
+
+export interface OrgRemoveTeamRepositoryRequest {
+  /** id of the team */
+  id: number;
+  /** organization that owns the repo to remove */
+  org: string;
+  /** name of the repo to remove */
+  repo: string;
+}
+export const OrgRemoveTeamRepositoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+    org: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/teams/{id}/repos/{org}/{repo}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "OrgRemoveTeamRepositoryRequest",
+}) as any as S.Schema<OrgRemoveTeamRepositoryRequest>;
+
+export interface OrgRemoveTeamRepositoryResponse {}
+export const OrgRemoveTeamRepositoryResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgRemoveTeamRepositoryResponse",
+}) as any as S.Schema<OrgRemoveTeamRepositoryResponse>;
+
+export interface OrgSearchRunJobsRequest {
+  /** name of the organization */
+  org: string;
+  /** a comma separated list of run job labels to search for */
+  labels?: string;
+}
+export const OrgSearchRunJobsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    labels: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/orgs/{org}/actions/runners/jobs",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "OrgSearchRunJobsRequest",
+}) as any as S.Schema<OrgSearchRunJobsRequest>;
+
+/** the action run job needed ids */
+export type ActionRunJobNeedsList = Array<string>;
+export const ActionRunJobNeedsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ActionRunJobNeedsList>;
+
+/** the action run job labels to run on */
+export type ActionRunJobRunsOnList = Array<string>;
+export const ActionRunJobRunsOnList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ActionRunJobRunsOnList>;
+
+/** ActionRunJob represents a job of a run */
+export interface ActionRunJob {
+  /** How many times the job has been attempted including the current attempt. */
+  attempt?: number;
+  /** Opaque identifier that uniquely identifies a single attempt of a job. */
+  handle?: string;
+  /** Identifier of this job. */
+  id?: number;
+  /** the action run job name */
+  name?: string;
+  /** the action run job needed ids */
+  needs?: ActionRunJobNeedsList;
+  /** the owner id */
+  owner_id?: number;
+  /** the repository id */
+  repo_id?: number;
+  /** Identifier of the workflow run this job belongs to. */
+  run_id?: number;
+  /** the action run job labels to run on */
+  runs_on?: ActionRunJobRunsOnList;
+  /** the action run job status */
+  status?: string;
+  /** the action run job latest task id */
+  task_id?: number;
+}
+export const ActionRunJob = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    attempt: S.optional(S.Number),
+    handle: S.optional(S.String),
+    id: S.optional(S.Number),
+    name: S.optional(S.String),
+    needs: S.optional(ActionRunJobNeedsList),
+    owner_id: S.optional(S.Number),
+    repo_id: S.optional(S.Number),
+    run_id: S.optional(S.Number),
+    runs_on: S.optional(ActionRunJobRunsOnList),
+    status: S.optional(S.String),
+    task_id: S.optional(S.Number),
+  }),
+).annotate({ identifier: "ActionRunJob" }) as any as S.Schema<ActionRunJob>;
+
+export type OrgSearchRunJobsResponseBodyList = Array<ActionRunJob>;
+export const OrgSearchRunJobsResponseBodyList = /*@__PURE__*/ S.Array(
+  ActionRunJob,
+) as any as S.Schema<OrgSearchRunJobsResponseBodyList>;
+
+export type OrgSearchRunJobsResponse = OrgSearchRunJobsResponseBodyList;
+export const OrgSearchRunJobsResponse = /*@__PURE__*/ S.suspend(() =>
+  OrgSearchRunJobsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "OrgSearchRunJobsResponse",
+}) as any as S.Schema<OrgSearchRunJobsResponse>;
+
+export interface OrgUnblockUserRequest {
+  /** name of the org */
+  org: string;
+  /** username of the user */
+  username: string;
+}
+export const OrgUnblockUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/orgs/{org}/unblock/{username}", code: 200 }),
+  ),
+).annotate({
+  identifier: "OrgUnblockUserRequest",
+}) as any as S.Schema<OrgUnblockUserRequest>;
+
+export interface OrgUnblockUserResponse {}
+export const OrgUnblockUserResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgUnblockUserResponse",
+}) as any as S.Schema<OrgUnblockUserResponse>;
+
+export interface OrgUpdateAvatarRequest {
+  /** name of the organization */
+  org: string;
+  /** image must be base64 encoded */
+  image?: string;
+}
+export const OrgUpdateAvatarRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    image: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/orgs/{org}/avatar", code: 200 })),
+).annotate({
+  identifier: "OrgUpdateAvatarRequest",
+}) as any as S.Schema<OrgUpdateAvatarRequest>;
+
+export interface OrgUpdateAvatarResponse {}
+export const OrgUpdateAvatarResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "OrgUpdateAvatarResponse",
+}) as any as S.Schema<OrgUpdateAvatarResponse>;
+
+export interface RegisterOrgRunnerRequest {
+  /** name of the organization */
+  org: string;
+  /** Description of the runner to register. */
+  description?: string;
+  /** Register as ephemeral runner https://forgejo.org/docs/latest/admin/actions/security/#ephemeral-runner */
+  ephemeral?: boolean;
+  /** Name of the runner to register. The name of the runner does not have to be unique. */
+  name: string;
+}
+export const RegisterOrgRunnerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    description: S.optional(S.String),
+    ephemeral: S.optional(S.Boolean),
+    name: S.String,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/orgs/{org}/actions/runners", code: 200 }),
+  ),
+).annotate({
+  identifier: "RegisterOrgRunnerRequest",
+}) as any as S.Schema<RegisterOrgRunnerRequest>;
+
+export interface RegisterRunnerResponse {
+  id?: number;
+  token?: string;
+  uuid?: string;
+}
+export const RegisterRunnerResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.Number),
+    token: S.optional(S.String),
+    uuid: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "RegisterRunnerResponse",
+}) as any as S.Schema<RegisterRunnerResponse>;
+
+export interface RenameOrgRequest {
+  /** existing org name */
+  org: string;
+  /** New username for this org. This name cannot be in use yet by any other user. */
+  new_name: string;
+}
+export const RenameOrgRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    new_name: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/orgs/{org}/rename", code: 200 })),
+).annotate({
+  identifier: "RenameOrgRequest",
+}) as any as S.Schema<RenameOrgRequest>;
+
+export interface RenameOrgResponse {}
+export const RenameOrgResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "RenameOrgResponse",
+}) as any as S.Schema<RenameOrgResponse>;
+
+export interface SearchTeamRequest {
+  /** name of the organization */
+  org: string;
+  /** keywords to search */
+  q?: string;
+  /** include search within team description (defaults to true) */
+  include_desc?: boolean;
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const SearchTeamRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    q: S.optional(S.String.pipe(T.Query())),
+    include_desc: S.optional(S.Boolean.pipe(T.Query())),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/orgs/{org}/teams/search", code: 200 }),
+  ),
+).annotate({
+  identifier: "SearchTeamRequest",
+}) as any as S.Schema<SearchTeamRequest>;
+
+export type SearchTeamResponseDataList = Array<Team>;
+export const SearchTeamResponseDataList = /*@__PURE__*/ S.Array(
+  Team,
+) as any as S.Schema<SearchTeamResponseDataList>;
+
+export interface SearchTeamResponse {
+  data?: SearchTeamResponseDataList;
+  ok?: boolean;
+}
+export const SearchTeamResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(SearchTeamResponseDataList),
+    ok: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "SearchTeamResponse",
+}) as any as S.Schema<SearchTeamResponse>;
+
+export interface UpdateOrgSecretRequest {
+  /** name of organization */
+  org: string;
+  /** name of the secret */
+  secretname: string;
+  /** Data of the secret. Special characters will be retained. Line endings will be normalized to LF to match the behaviour of browsers. Encode the data with Base64 if line endings should be retained. */
+  data: string;
+}
+export const UpdateOrgSecretRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    secretname: S.String.pipe(T.Label()),
+    data: S.String,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/orgs/{org}/actions/secrets/{secretname}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UpdateOrgSecretRequest",
+}) as any as S.Schema<UpdateOrgSecretRequest>;
+
+export interface UpdateOrgSecretResponse {}
+export const UpdateOrgSecretResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UpdateOrgSecretResponse",
+}) as any as S.Schema<UpdateOrgSecretResponse>;
+
+export interface UpdateOrgVariableRequest {
+  /** name of the organization */
+  org: string;
+  /** name of the variable */
+  variablename: string;
+  /** New name for the variable. If the field is empty, the variable name won't be updated. Forgejo will convert it to uppercase. */
+  name?: string;
+  /** Value of the variable to update. Special characters will be retained. Line endings will be normalized to LF to match the behaviour of browsers. Encode the data with Base64 if line endings should be retained. */
+  value: string;
+}
+export const UpdateOrgVariableRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    variablename: S.String.pipe(T.Label()),
+    name: S.optional(S.String),
+    value: S.String,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/orgs/{org}/actions/variables/{variablename}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UpdateOrgVariableRequest",
+}) as any as S.Schema<UpdateOrgVariableRequest>;
+
+export interface UpdateOrgVariableResponse {}
+export const UpdateOrgVariableResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UpdateOrgVariableResponse",
+}) as any as S.Schema<UpdateOrgVariableResponse>;
+
+export type CreateOrgError = Forbidden | UnprocessableEntity | ForgejoOpError;
+/** Create an organization */
+export const createOrg: API.OperationMethod<
+  CreateOrgRequest,
+  Organization,
+  CreateOrgError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOrgRequest,
+  output: Organization,
+  errors: [Forbidden, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOrgRepoError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | Conflict
+  | ForgejoOpError;
+/** Create a repository in an organization */
+export const createOrgRepo: API.OperationMethod<
+  CreateOrgRepoRequest,
+  Repository,
+  CreateOrgRepoError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOrgRepoRequest,
+  output: Repository,
+  errors: [BadRequest, Forbidden, NotFound, Conflict],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOrgVariableError = BadRequest | NotFound | ForgejoOpError;
+/** Create a new variable in organization */
+export const createOrgVariable: API.OperationMethod<
+  CreateOrgVariableRequest,
+  CreateOrgVariableResponse,
+  CreateOrgVariableError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOrgVariableRequest,
+  output: CreateOrgVariableResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOrgError =
+  | NotFound
+  | OrganizationOwnsRepositories
+  | ForgejoOpError;
+/** Delete an organization */
+export const deleteOrg: API.OperationMethod<
+  DeleteOrgRequest,
+  DeleteOrgResponse,
+  DeleteOrgError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOrgRequest,
+  output: DeleteOrgResponse,
+  errors: [NotFound, OrganizationOwnsRepositories],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOrgRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Delete a particular runner that belongs to the organization */
+export const deleteOrgRunner: API.OperationMethod<
+  DeleteOrgRunnerRequest,
+  DeleteOrgRunnerResponse,
+  DeleteOrgRunnerError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOrgRunnerRequest,
+  output: DeleteOrgRunnerResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOrgSecretError = BadRequest | NotFound | ForgejoOpError;
+/** Delete a secret in an organization */
+export const deleteOrgSecret: API.OperationMethod<
+  DeleteOrgSecretRequest,
+  DeleteOrgSecretResponse,
+  DeleteOrgSecretError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOrgSecretRequest,
+  output: DeleteOrgSecretResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOrgVariableError = BadRequest | NotFound | ForgejoOpError;
+/** Delete organization's variable by name */
+export const deleteOrgVariable: API.OperationMethod<
+  DeleteOrgVariableRequest,
+  DeleteOrgVariableResponse,
+  DeleteOrgVariableError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOrgVariableRequest,
+  output: DeleteOrgVariableResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EditOrgError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Edit an organization */
+export const editOrg: API.OperationMethod<
+  EditOrgRequest,
+  Organization,
+  EditOrgError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EditOrgRequest,
+  output: Organization,
+  errors: [NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOrgError = NotFound | ForgejoOpError;
+/** Get an organization */
+export const getOrg: API.OperationMethod<
+  GetOrgRequest,
+  Organization,
+  GetOrgError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrgRequest,
+  output: Organization,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOrgRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Get a particular runner that belongs to the organization */
+export const getOrgRunner: API.OperationMethod<
+  GetOrgRunnerRequest,
+  ActionRunner,
+  GetOrgRunnerError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrgRunnerRequest,
+  output: ActionRunner,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOrgRunnersError = BadRequest | NotFound | ForgejoOpError;
+/** Get the organization's runners */
+export const getOrgRunners: API.OperationMethod<
+  GetOrgRunnersRequest,
+  GetOrgRunnersResponse,
+  GetOrgRunnersError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrgRunnersRequest,
+  output: GetOrgRunnersResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOrgVariableError = BadRequest | NotFound | ForgejoOpError;
+/** Get organization's variable by name */
+export const getOrgVariable: API.OperationMethod<
+  GetOrgVariableRequest,
+  ActionVariable,
+  GetOrgVariableError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrgVariableRequest,
+  output: ActionVariable,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOrgVariablesListError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** List variables of an organization */
+export const getOrgVariablesList: API.OperationMethod<
+  GetOrgVariablesListRequest,
+  GetOrgVariablesListResponse,
+  GetOrgVariablesListError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrgVariablesListRequest,
+  output: GetOrgVariablesListResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgAddTeamMemberError = NotFound | ForgejoOpError;
+/** Add a team member */
+export const orgAddTeamMember: API.OperationMethod<
+  OrgAddTeamMemberRequest,
+  OrgAddTeamMemberResponse,
+  OrgAddTeamMemberError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgAddTeamMemberRequest,
+  output: OrgAddTeamMemberResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgAddTeamRepositoryError = Forbidden | NotFound | ForgejoOpError;
+/** Add a repository to a team */
+export const orgAddTeamRepository: API.OperationMethod<
+  OrgAddTeamRepositoryRequest,
+  OrgAddTeamRepositoryResponse,
+  OrgAddTeamRepositoryError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgAddTeamRepositoryRequest,
+  output: OrgAddTeamRepositoryResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgBlockUserError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Blocks a user from the organization */
+export const orgBlockUser: API.OperationMethod<
+  OrgBlockUserRequest,
+  OrgBlockUserResponse,
+  OrgBlockUserError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgBlockUserRequest,
+  output: OrgBlockUserResponse,
+  errors: [NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgCheckQuotaError =
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Check if the organization is over quota for a given subject */
+export const orgCheckQuota: API.OperationMethod<
+  OrgCheckQuotaRequest,
+  OrgCheckQuotaResponse,
+  OrgCheckQuotaError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgCheckQuotaRequest,
+  output: OrgCheckQuotaResponse,
+  errors: [Forbidden, NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgConcealMemberError = Forbidden | NotFound | ForgejoOpError;
+/** Conceal a user's membership */
+export const orgConcealMember: API.OperationMethod<
+  OrgConcealMemberRequest,
+  OrgConcealMemberResponse,
+  OrgConcealMemberError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgConcealMemberRequest,
+  output: OrgConcealMemberResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgCreateHookError = NotFound | ForgejoOpError;
+/** Create a hook */
+export const orgCreateHook: API.OperationMethod<
+  OrgCreateHookRequest,
+  Hook,
+  OrgCreateHookError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgCreateHookRequest,
+  output: Hook,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgCreateLabelError =
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Create a label for an organization */
+export const orgCreateLabel: API.OperationMethod<
+  OrgCreateLabelRequest,
+  Label,
+  OrgCreateLabelError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgCreateLabelRequest,
+  output: Label,
+  errors: [NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgCreateTeamError =
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Create a team */
+export const orgCreateTeam: API.OperationMethod<
+  OrgCreateTeamRequest,
+  Team,
+  OrgCreateTeamError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgCreateTeamRequest,
+  output: Team,
+  errors: [NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgDeleteAvatarError = NotFound | ForgejoOpError;
+/** Delete an organization's avatar. It will be replaced by a default one */
+export const orgDeleteAvatar: API.OperationMethod<
+  OrgDeleteAvatarRequest,
+  OrgDeleteAvatarResponse,
+  OrgDeleteAvatarError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgDeleteAvatarRequest,
+  output: OrgDeleteAvatarResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgDeleteHookError = NotFound | ForgejoOpError;
+/** Delete a hook */
+export const orgDeleteHook: API.OperationMethod<
+  OrgDeleteHookRequest,
+  OrgDeleteHookResponse,
+  OrgDeleteHookError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgDeleteHookRequest,
+  output: OrgDeleteHookResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgDeleteLabelError = NotFound | ForgejoOpError;
+/** Delete a label */
+export const orgDeleteLabel: API.OperationMethod<
+  OrgDeleteLabelRequest,
+  OrgDeleteLabelResponse,
+  OrgDeleteLabelError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgDeleteLabelRequest,
+  output: OrgDeleteLabelResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgDeleteMemberError = NotFound | ForgejoOpError;
+/** Remove a member from an organization */
+export const orgDeleteMember: API.OperationMethod<
+  OrgDeleteMemberRequest,
+  OrgDeleteMemberResponse,
+  OrgDeleteMemberError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgDeleteMemberRequest,
+  output: OrgDeleteMemberResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgDeleteTeamError = NotFound | ForgejoOpError;
+/** Delete a team */
+export const orgDeleteTeam: API.OperationMethod<
+  OrgDeleteTeamRequest,
+  OrgDeleteTeamResponse,
+  OrgDeleteTeamError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgDeleteTeamRequest,
+  output: OrgDeleteTeamResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgEditHookError = NotFound | ForgejoOpError;
+/** Update a hook */
+export const orgEditHook: API.OperationMethod<
+  OrgEditHookRequest,
+  Hook,
+  OrgEditHookError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgEditHookRequest,
+  output: Hook,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgEditLabelError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Update a label */
+export const orgEditLabel: API.OperationMethod<
+  OrgEditLabelRequest,
+  Label,
+  OrgEditLabelError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgEditLabelRequest,
+  output: Label,
+  errors: [NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgEditTeamError = NotFound | ForgejoOpError;
+/** Edit a team */
+export const orgEditTeam: API.OperationMethod<
+  OrgEditTeamRequest,
+  Team,
+  OrgEditTeamError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgEditTeamRequest,
+  output: Team,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgGetAllError = ForgejoOpError;
+/** List all organizations */
+export const orgGetAll: API.OperationMethod<
+  OrgGetAllRequest,
+  OrgGetAllResponse,
+  OrgGetAllError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgGetAllRequest,
+  output: OrgGetAllResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgGetHookError = NotFound | ForgejoOpError;
+/** Get a hook */
+export const orgGetHook: API.OperationMethod<
+  OrgGetHookRequest,
+  Hook,
+  OrgGetHookError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgGetHookRequest,
+  output: Hook,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgGetLabelError = NotFound | ForgejoOpError;
+/** Get a single label */
+export const orgGetLabel: API.OperationMethod<
+  OrgGetLabelRequest,
+  Label,
+  OrgGetLabelError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgGetLabelRequest,
+  output: Label,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgGetQuotaError = Forbidden | NotFound | ForgejoOpError;
+/** Get quota information for an organization */
+export const orgGetQuota: API.OperationMethod<
+  OrgGetQuotaRequest,
+  QuotaInfo,
+  OrgGetQuotaError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgGetQuotaRequest,
+  output: QuotaInfo,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgGetTeamError = NotFound | ForgejoOpError;
+/** Get a team */
+export const orgGetTeam: API.OperationMethod<
+  OrgGetTeamRequest,
+  Team,
+  OrgGetTeamError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgGetTeamRequest,
+  output: Team,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgGetUserPermissionsError = Forbidden | NotFound | ForgejoOpError;
+/** Get user permissions in organization */
+export const orgGetUserPermissions: API.OperationMethod<
+  OrgGetUserPermissionsRequest,
+  OrganizationPermissions,
+  OrgGetUserPermissionsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgGetUserPermissionsRequest,
+  output: OrganizationPermissions,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgIsMemberError = NotFound | ForgejoOpError;
+/** Check if a user is a member of an organization */
+export const orgIsMember: API.OperationMethod<
+  OrgIsMemberRequest,
+  OrgIsMemberResponse,
+  OrgIsMemberError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgIsMemberRequest,
+  output: OrgIsMemberResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgIsPublicMemberError = NotFound | ForgejoOpError;
+/** Check if a user is a public member of an organization */
+export const orgIsPublicMember: API.OperationMethod<
+  OrgIsPublicMemberRequest,
+  OrgIsPublicMemberResponse,
+  OrgIsPublicMemberError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgIsPublicMemberRequest,
+  output: OrgIsPublicMemberResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListActionsSecretsError = Forbidden | NotFound | ForgejoOpError;
+/** List actions secrets of an organization */
+export const orgListActionsSecrets: API.OperationMethod<
+  OrgListActionsSecretsRequest,
+  OrgListActionsSecretsResponse,
+  OrgListActionsSecretsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListActionsSecretsRequest,
+  output: OrgListActionsSecretsResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListActivityFeedsError = NotFound | ForgejoOpError;
+/** List an organization's activity feeds */
+export const orgListActivityFeeds: API.OperationMethod<
+  OrgListActivityFeedsRequest,
+  OrgListActivityFeedsResponse,
+  OrgListActivityFeedsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListActivityFeedsRequest,
+  output: OrgListActivityFeedsResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListBlockedUsersError = ForgejoOpError;
+/** List the organization's blocked users */
+export const orgListBlockedUsers: API.OperationMethod<
+  OrgListBlockedUsersRequest,
+  OrgListBlockedUsersResponse,
+  OrgListBlockedUsersError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListBlockedUsersRequest,
+  output: OrgListBlockedUsersResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListCurrentUserOrgsError = Forbidden | NotFound | ForgejoOpError;
+/** List the current user's organizations */
+export const orgListCurrentUserOrgs: API.OperationMethod<
+  OrgListCurrentUserOrgsRequest,
+  OrgListCurrentUserOrgsResponse,
+  OrgListCurrentUserOrgsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListCurrentUserOrgsRequest,
+  output: OrgListCurrentUserOrgsResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListHooksError = NotFound | ForgejoOpError;
+/** List an organization's webhooks */
+export const orgListHooks: API.OperationMethod<
+  OrgListHooksRequest,
+  OrgListHooksResponse,
+  OrgListHooksError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListHooksRequest,
+  output: OrgListHooksResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListLabelsError = NotFound | ForgejoOpError;
+/** List an organization's labels */
+export const orgListLabels: API.OperationMethod<
+  OrgListLabelsRequest,
+  OrgListLabelsResponse,
+  OrgListLabelsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListLabelsRequest,
+  output: OrgListLabelsResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListMembersError = NotFound | ForgejoOpError;
+/** List an organization's members */
+export const orgListMembers: API.OperationMethod<
+  OrgListMembersRequest,
+  OrgListMembersResponse,
+  OrgListMembersError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListMembersRequest,
+  output: OrgListMembersResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListPublicMembersError = NotFound | ForgejoOpError;
+/** List an organization's public members */
+export const orgListPublicMembers: API.OperationMethod<
+  OrgListPublicMembersRequest,
+  OrgListPublicMembersResponse,
+  OrgListPublicMembersError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListPublicMembersRequest,
+  output: OrgListPublicMembersResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListQuotaArtifactsError = Forbidden | NotFound | ForgejoOpError;
+/** List the artifacts affecting the organization's quota */
+export const orgListQuotaArtifacts: API.OperationMethod<
+  OrgListQuotaArtifactsRequest,
+  OrgListQuotaArtifactsResponse,
+  OrgListQuotaArtifactsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListQuotaArtifactsRequest,
+  output: OrgListQuotaArtifactsResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListQuotaAttachmentsError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** List the attachments affecting the organization's quota */
+export const orgListQuotaAttachments: API.OperationMethod<
+  OrgListQuotaAttachmentsRequest,
+  OrgListQuotaAttachmentsResponse,
+  OrgListQuotaAttachmentsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListQuotaAttachmentsRequest,
+  output: OrgListQuotaAttachmentsResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListQuotaPackagesError = Forbidden | NotFound | ForgejoOpError;
+/** List the packages affecting the organization's quota */
+export const orgListQuotaPackages: API.OperationMethod<
+  OrgListQuotaPackagesRequest,
+  OrgListQuotaPackagesResponse,
+  OrgListQuotaPackagesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListQuotaPackagesRequest,
+  output: OrgListQuotaPackagesResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListReposError = NotFound | ForgejoOpError;
+/** List an organization's repos */
+export const orgListRepos: API.OperationMethod<
+  OrgListReposRequest,
+  OrgListReposResponse,
+  OrgListReposError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListReposRequest,
+  output: OrgListReposResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListTeamActivityFeedsError = NotFound | ForgejoOpError;
+/** List a team's activity feeds */
+export const orgListTeamActivityFeeds: API.OperationMethod<
+  OrgListTeamActivityFeedsRequest,
+  OrgListTeamActivityFeedsResponse,
+  OrgListTeamActivityFeedsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListTeamActivityFeedsRequest,
+  output: OrgListTeamActivityFeedsResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListTeamMemberError = NotFound | ForgejoOpError;
+/** List a particular member of team */
+export const orgListTeamMember: API.OperationMethod<
+  OrgListTeamMemberRequest,
+  User,
+  OrgListTeamMemberError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListTeamMemberRequest,
+  output: User,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListTeamMembersError = Forbidden | NotFound | ForgejoOpError;
+/** List a team's members */
+export const orgListTeamMembers: API.OperationMethod<
+  OrgListTeamMembersRequest,
+  OrgListTeamMembersResponse,
+  OrgListTeamMembersError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListTeamMembersRequest,
+  output: OrgListTeamMembersResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListTeamRepoError = NotFound | ForgejoOpError;
+/** List a particular repo of team */
+export const orgListTeamRepo: API.OperationMethod<
+  OrgListTeamRepoRequest,
+  Repository,
+  OrgListTeamRepoError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListTeamRepoRequest,
+  output: Repository,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListTeamReposError = NotFound | ForgejoOpError;
+/** List a team's repos */
+export const orgListTeamRepos: API.OperationMethod<
+  OrgListTeamReposRequest,
+  OrgListTeamReposResponse,
+  OrgListTeamReposError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListTeamReposRequest,
+  output: OrgListTeamReposResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListTeamsError = Forbidden | NotFound | ForgejoOpError;
+/** List an organization's teams */
+export const orgListTeams: API.OperationMethod<
+  OrgListTeamsRequest,
+  OrgListTeamsResponse,
+  OrgListTeamsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListTeamsRequest,
+  output: OrgListTeamsResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgListUserOrgsError = NotFound | ForgejoOpError;
+/** List a user's organizations */
+export const orgListUserOrgs: API.OperationMethod<
+  OrgListUserOrgsRequest,
+  OrgListUserOrgsResponse,
+  OrgListUserOrgsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgListUserOrgsRequest,
+  output: OrgListUserOrgsResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgPublicizeMemberError = Forbidden | NotFound | ForgejoOpError;
+/** Publicize a user's membership */
+export const orgPublicizeMember: API.OperationMethod<
+  OrgPublicizeMemberRequest,
+  OrgPublicizeMemberResponse,
+  OrgPublicizeMemberError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgPublicizeMemberRequest,
+  output: OrgPublicizeMemberResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgRemoveTeamMemberError = NotFound | ForgejoOpError;
+/** Remove a team member */
+export const orgRemoveTeamMember: API.OperationMethod<
+  OrgRemoveTeamMemberRequest,
+  OrgRemoveTeamMemberResponse,
+  OrgRemoveTeamMemberError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgRemoveTeamMemberRequest,
+  output: OrgRemoveTeamMemberResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgRemoveTeamRepositoryError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Remove a repository from a team This does not delete the repository, it only removes the repository from the team. */
+export const orgRemoveTeamRepository: API.OperationMethod<
+  OrgRemoveTeamRepositoryRequest,
+  OrgRemoveTeamRepositoryResponse,
+  OrgRemoveTeamRepositoryError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgRemoveTeamRepositoryRequest,
+  output: OrgRemoveTeamRepositoryResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgSearchRunJobsError = Forbidden | ForgejoOpError;
+/** Search for organization's action jobs according filter conditions */
+export const orgSearchRunJobs: API.OperationMethod<
+  OrgSearchRunJobsRequest,
+  OrgSearchRunJobsResponse,
+  OrgSearchRunJobsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgSearchRunJobsRequest,
+  output: OrgSearchRunJobsResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgUnblockUserError =
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Unblock a user from the organization */
+export const orgUnblockUser: API.OperationMethod<
+  OrgUnblockUserRequest,
+  OrgUnblockUserResponse,
+  OrgUnblockUserError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgUnblockUserRequest,
+  output: OrgUnblockUserResponse,
+  errors: [NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type OrgUpdateAvatarError = NotFound | ForgejoOpError;
+/** Update an organization's avatar */
+export const orgUpdateAvatar: API.OperationMethod<
+  OrgUpdateAvatarRequest,
+  OrgUpdateAvatarResponse,
+  OrgUpdateAvatarError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: OrgUpdateAvatarRequest,
+  output: OrgUpdateAvatarResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RegisterOrgRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Register a new organization-level runner */
+export const registerOrgRunner: API.OperationMethod<
+  RegisterOrgRunnerRequest,
+  RegisterRunnerResponse,
+  RegisterOrgRunnerError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RegisterOrgRunnerRequest,
+  output: RegisterRunnerResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RenameOrgError = Forbidden | UnprocessableEntity | ForgejoOpError;
+/** Rename an organization */
+export const renameOrg: API.OperationMethod<
+  RenameOrgRequest,
+  RenameOrgResponse,
+  RenameOrgError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RenameOrgRequest,
+  output: RenameOrgResponse,
+  errors: [Forbidden, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SearchTeamError = NotFound | ForgejoOpError;
+/** Search for teams within an organization */
+export const searchTeam: API.OperationMethod<
+  SearchTeamRequest,
+  SearchTeamResponse,
+  SearchTeamError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SearchTeamRequest,
+  output: SearchTeamResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateOrgSecretError = BadRequest | NotFound | ForgejoOpError;
+/** Create or Update a secret value in an organization */
+export const updateOrgSecret: API.OperationMethod<
+  UpdateOrgSecretRequest,
+  UpdateOrgSecretResponse,
+  UpdateOrgSecretError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateOrgSecretRequest,
+  output: UpdateOrgSecretResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateOrgVariableError = BadRequest | NotFound | ForgejoOpError;
+/** Update variable in organization */
+export const updateOrgVariable: API.OperationMethod<
+  UpdateOrgVariableRequest,
+  UpdateOrgVariableResponse,
+  UpdateOrgVariableError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateOrgVariableRequest,
+  output: UpdateOrgVariableResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));