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

package/lib/services/organization.d.ts

@@ -0,0 +1,1593 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import { type ForgejoOpError, type ForgejoOpContext } from "../protocol.ts";
+export type { ForgejoOpError, ForgejoOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const Conflict_base: S.Class<Conflict, S.TaggedStruct<"Conflict", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+export declare class Conflict extends /*@__PURE__*/ Conflict_base {
+}
+declare const Forbidden_base: S.Class<Forbidden, S.TaggedStruct<"Forbidden", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        AuthError: true;
+    };
+});
+export declare class Forbidden extends /*@__PURE__*/ Forbidden_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+declare const OrganizationOwnsRepositories_base: S.Class<OrganizationOwnsRepositories, S.TaggedStruct<"OrganizationOwnsRepositories", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+/** 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 declare class OrganizationOwnsRepositories extends /*@__PURE__*/ OrganizationOwnsRepositories_base {
+}
+declare const UnprocessableEntity_base: S.Class<UnprocessableEntity, S.TaggedStruct<"UnprocessableEntity", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class UnprocessableEntity extends /*@__PURE__*/ UnprocessableEntity_base {
+}
+/** possible values are `public` (default), `limited` or `private` */
+export type CreateOrgRequestVisibility = "public" | "limited" | "private";
+export declare const CreateOrgRequestVisibility: any;
+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 declare const CreateOrgRequest: 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 declare const Organization: S.Schema<Organization>;
+/** ObjectFormatName of the underlying git repository */
+export type CreateOrgRepoRequestObjectFormatName = "sha1" | "sha256";
+export declare const CreateOrgRepoRequestObjectFormatName: any;
+/** TrustModel of the repository */
+export type CreateOrgRepoRequestTrustModel = "default" | "collaborator" | "committer" | "collaboratorcommitter";
+export declare const CreateOrgRepoRequestTrustModel: any;
+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 declare const CreateOrgRepoRequest: 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 declare const ExternalTracker: S.Schema<ExternalTracker>;
+/** ExternalWiki represents setting for external wiki */
+export interface ExternalWiki {
+    /** URL of external wiki. */
+    external_wiki_url?: string;
+}
+export declare const ExternalWiki: 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 declare const InternalTracker: S.Schema<InternalTracker>;
+/** ObjectFormatName of the underlying git repository */
+export type RepositoryObjectFormatName = "sha1" | "sha256";
+export declare const RepositoryObjectFormatName: any;
+/** User represents a user */
+export interface User {
+    /** Is user active */
+    active?: boolean;
+    /** URL to the user's avatar */
+    avatar_url?: string;
+    created?: string;
+    /** the user's description */
+    description?: string;
+    email?: string;
+    /** user counts */
+    followers_count?: number;
+    following_count?: number;
+    /** the user's full name */
+    full_name?: string;
+    /** URL to the user's profile page */
+    html_url?: string;
+    /** the user's id */
+    id: number;
+    /** Is the user an administrator */
+    is_admin?: boolean;
+    /** User locale */
+    language?: string;
+    last_login?: string;
+    /** the user's location */
+    location?: string;
+    /** the user's username */
+    login: string;
+    /** the user's authentication sign-in name. */
+    login_name?: string;
+    /** Is user login prohibited */
+    prohibit_login?: boolean;
+    /** the user's pronouns */
+    pronouns?: string;
+    /** Is user restricted */
+    restricted?: boolean;
+    /** The ID of the user's Authentication Source */
+    source_id?: number;
+    starred_repos_count?: number;
+    /** User visibility level option: public, limited, private */
+    visibility?: string;
+    /** the user's website */
+    website?: string;
+}
+export declare const User: S.Schema<User>;
+/** Permission represents a set of permissions */
+export interface Permission {
+    admin?: boolean;
+    pull?: boolean;
+    push?: boolean;
+}
+export declare const Permission: S.Schema<Permission>;
+export type TeamPermission = "none" | "read" | "write" | "admin" | "owner";
+export declare const TeamPermission: any;
+export type TeamUnitsList = Array<string>;
+export declare const TeamUnitsList: S.Schema<TeamUnitsList>;
+export type TeamUnitsMapMap = {
+    [key: string]: string | undefined;
+};
+export declare const TeamUnitsMapMap: S.Schema<TeamUnitsMapMap>;
+/** Team represents a team in an organization */
+export interface Team {
+    can_create_org_repo?: boolean;
+    description?: string;
+    id: number;
+    includes_all_repositories?: boolean;
+    name: string;
+    organization?: Organization;
+    permission?: TeamPermission;
+    units?: TeamUnitsList;
+    units_map?: TeamUnitsMapMap;
+}
+export declare const Team: S.Schema<Team>;
+export type RepoTransferTeamsList = Array<Team>;
+export declare const RepoTransferTeamsList: S.Schema<RepoTransferTeamsList>;
+/** RepoTransfer represents a pending repo transfer */
+export interface RepoTransfer {
+    doer?: User;
+    recipient?: User;
+    teams?: RepoTransferTeamsList;
+}
+export declare const RepoTransfer: S.Schema<RepoTransfer>;
+export type RepositoryTopicsList = Array<string>;
+export declare const RepositoryTopicsList: 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 declare const Repository: 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 declare const CreateOrgVariableRequest: S.Schema<CreateOrgVariableRequest>;
+export interface CreateOrgVariableResponse {
+}
+export declare const CreateOrgVariableResponse: S.Schema<CreateOrgVariableResponse>;
+export interface DeleteOrgRequest {
+    /** organization that is to be deleted */
+    org: string;
+}
+export declare const DeleteOrgRequest: S.Schema<DeleteOrgRequest>;
+export interface DeleteOrgResponse {
+}
+export declare const DeleteOrgResponse: S.Schema<DeleteOrgResponse>;
+export interface DeleteOrgRunnerRequest {
+    /** name of the organization */
+    org: string;
+    /** ID of the runner */
+    runner_id: string;
+}
+export declare const DeleteOrgRunnerRequest: S.Schema<DeleteOrgRunnerRequest>;
+export interface DeleteOrgRunnerResponse {
+}
+export declare const DeleteOrgRunnerResponse: S.Schema<DeleteOrgRunnerResponse>;
+export interface DeleteOrgSecretRequest {
+    /** name of organization */
+    org: string;
+    /** name of the secret */
+    secretname: string;
+}
+export declare const DeleteOrgSecretRequest: S.Schema<DeleteOrgSecretRequest>;
+export interface DeleteOrgSecretResponse {
+}
+export declare const DeleteOrgSecretResponse: S.Schema<DeleteOrgSecretResponse>;
+export interface DeleteOrgVariableRequest {
+    /** name of the organization */
+    org: string;
+    /** name of the variable */
+    variablename: string;
+}
+export declare const DeleteOrgVariableRequest: S.Schema<DeleteOrgVariableRequest>;
+export interface DeleteOrgVariableResponse {
+}
+export declare const DeleteOrgVariableResponse: S.Schema<DeleteOrgVariableResponse>;
+/** possible values are `public`, `limited` or `private` */
+export type EditOrgRequestVisibility = "public" | "limited" | "private";
+export declare const EditOrgRequestVisibility: any;
+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 declare const EditOrgRequest: S.Schema<EditOrgRequest>;
+export interface GetOrgRequest {
+    /** name of the organization to get */
+    org: string;
+}
+export declare const GetOrgRequest: S.Schema<GetOrgRequest>;
+export interface GetOrgRunnerRequest {
+    /** name of the organization */
+    org: string;
+    /** ID of the runner */
+    runner_id: string;
+}
+export declare const GetOrgRunnerRequest: S.Schema<GetOrgRunnerRequest>;
+/** Labels is a list of labels attached to this runner. */
+export type ActionRunnerLabelsList = Array<string>;
+export declare const ActionRunnerLabelsList: S.Schema<ActionRunnerLabelsList>;
+/** Status indicates whether this runner is offline, or active, for example. */
+export type ActionRunnerStatus = "offline" | "idle" | "active";
+export declare const ActionRunnerStatus: any;
+/** 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 declare const ActionRunner: 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 declare const GetOrgRunnersRequest: S.Schema<GetOrgRunnersRequest>;
+export type GetOrgRunnersResponseBodyList = Array<ActionRunner>;
+export declare const GetOrgRunnersResponseBodyList: S.Schema<GetOrgRunnersResponseBodyList>;
+export type GetOrgRunnersResponse = GetOrgRunnersResponseBodyList;
+export declare const GetOrgRunnersResponse: S.Schema<GetOrgRunnersResponse>;
+export interface GetOrgVariableRequest {
+    /** name of the organization */
+    org: string;
+    /** name of the variable */
+    variablename: string;
+}
+export declare const GetOrgVariableRequest: 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 declare const ActionVariable: 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 declare const GetOrgVariablesListRequest: S.Schema<GetOrgVariablesListRequest>;
+export type GetOrgVariablesListResponseBodyList = Array<ActionVariable>;
+export declare const GetOrgVariablesListResponseBodyList: S.Schema<GetOrgVariablesListResponseBodyList>;
+export type GetOrgVariablesListResponse = GetOrgVariablesListResponseBodyList;
+export declare const GetOrgVariablesListResponse: S.Schema<GetOrgVariablesListResponse>;
+export interface OrgAddTeamMemberRequest {
+    /** id of the team */
+    id: number;
+    /** username of the user to add */
+    username: string;
+}
+export declare const OrgAddTeamMemberRequest: S.Schema<OrgAddTeamMemberRequest>;
+export interface OrgAddTeamMemberResponse {
+}
+export declare const OrgAddTeamMemberResponse: 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 declare const OrgAddTeamRepositoryRequest: S.Schema<OrgAddTeamRepositoryRequest>;
+export interface OrgAddTeamRepositoryResponse {
+}
+export declare const OrgAddTeamRepositoryResponse: S.Schema<OrgAddTeamRepositoryResponse>;
+export interface OrgBlockUserRequest {
+    /** name of the org */
+    org: string;
+    /** username of the user */
+    username: string;
+}
+export declare const OrgBlockUserRequest: S.Schema<OrgBlockUserRequest>;
+export interface OrgBlockUserResponse {
+}
+export declare const OrgBlockUserResponse: S.Schema<OrgBlockUserResponse>;
+export interface OrgCheckQuotaRequest {
+    /** name of the organization */
+    org: string;
+    /** subject of the quota */
+    subject: string;
+}
+export declare const OrgCheckQuotaRequest: S.Schema<OrgCheckQuotaRequest>;
+export type OrgCheckQuotaResponse = boolean;
+export declare const OrgCheckQuotaResponse: S.Schema<OrgCheckQuotaResponse>;
+export interface OrgConcealMemberRequest {
+    /** name of the organization */
+    org: string;
+    /** username of the user */
+    username: string;
+}
+export declare const OrgConcealMemberRequest: S.Schema<OrgConcealMemberRequest>;
+export interface OrgConcealMemberResponse {
+}
+export declare const OrgConcealMemberResponse: 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 declare const CreateHookOptionConfig: S.Schema<CreateHookOptionConfig>;
+export type OrgCreateHookRequestEventsList = Array<string>;
+export declare const OrgCreateHookRequestEventsList: S.Schema<OrgCreateHookRequestEventsList>;
+export type OrgCreateHookRequestType = "forgejo" | "dingtalk" | "discord" | "gitea" | "gogs" | "msteams" | "slack" | "telegram" | "feishu" | "wechatwork" | "packagist";
+export declare const OrgCreateHookRequestType: any;
+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 declare const OrgCreateHookRequest: S.Schema<OrgCreateHookRequest>;
+/** Deprecated: use Metadata instead */
+export type HookConfigMap = {
+    [key: string]: string | undefined;
+};
+export declare const HookConfigMap: S.Schema<HookConfigMap>;
+export type HookEventsList = Array<string>;
+export declare const HookEventsList: 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 declare const Hook: S.Schema<Hook>;
+export interface OrgCreateLabelRequest {
+    /** name of the organization */
+    org: string;
+    color: string;
+    description?: string;
+    exclusive?: boolean;
+    is_archived?: boolean;
+    name: string;
+}
+export declare const OrgCreateLabelRequest: 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 declare const Label: S.Schema<Label>;
+export type OrgCreateTeamRequestPermission = "read" | "write" | "admin";
+export declare const OrgCreateTeamRequestPermission: any;
+export type OrgCreateTeamRequestUnitsList = Array<string>;
+export declare const OrgCreateTeamRequestUnitsList: S.Schema<OrgCreateTeamRequestUnitsList>;
+export type OrgCreateTeamRequestUnitsMapMap = {
+    [key: string]: string | undefined;
+};
+export declare const OrgCreateTeamRequestUnitsMapMap: 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 declare const OrgCreateTeamRequest: S.Schema<OrgCreateTeamRequest>;
+export interface OrgDeleteAvatarRequest {
+    /** name of the organization */
+    org: string;
+}
+export declare const OrgDeleteAvatarRequest: S.Schema<OrgDeleteAvatarRequest>;
+export interface OrgDeleteAvatarResponse {
+}
+export declare const OrgDeleteAvatarResponse: S.Schema<OrgDeleteAvatarResponse>;
+export interface OrgDeleteHookRequest {
+    /** name of the organization */
+    org: string;
+    /** id of the hook to delete */
+    id: number;
+}
+export declare const OrgDeleteHookRequest: S.Schema<OrgDeleteHookRequest>;
+export interface OrgDeleteHookResponse {
+}
+export declare const OrgDeleteHookResponse: S.Schema<OrgDeleteHookResponse>;
+export interface OrgDeleteLabelRequest {
+    /** name of the organization */
+    org: string;
+    /** id of the label to delete */
+    id: number;
+}
+export declare const OrgDeleteLabelRequest: S.Schema<OrgDeleteLabelRequest>;
+export interface OrgDeleteLabelResponse {
+}
+export declare const OrgDeleteLabelResponse: S.Schema<OrgDeleteLabelResponse>;
+export interface OrgDeleteMemberRequest {
+    /** name of the organization */
+    org: string;
+    /** username of the user */
+    username: string;
+}
+export declare const OrgDeleteMemberRequest: S.Schema<OrgDeleteMemberRequest>;
+export interface OrgDeleteMemberResponse {
+}
+export declare const OrgDeleteMemberResponse: S.Schema<OrgDeleteMemberResponse>;
+export interface OrgDeleteTeamRequest {
+    /** id of the team to delete */
+    id: number;
+}
+export declare const OrgDeleteTeamRequest: S.Schema<OrgDeleteTeamRequest>;
+export interface OrgDeleteTeamResponse {
+}
+export declare const OrgDeleteTeamResponse: S.Schema<OrgDeleteTeamResponse>;
+export type OrgEditHookRequestConfigMap = {
+    [key: string]: string | undefined;
+};
+export declare const OrgEditHookRequestConfigMap: S.Schema<OrgEditHookRequestConfigMap>;
+export type OrgEditHookRequestEventsList = Array<string>;
+export declare const OrgEditHookRequestEventsList: 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 declare const OrgEditHookRequest: 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 declare const OrgEditLabelRequest: S.Schema<OrgEditLabelRequest>;
+export type OrgEditTeamRequestPermission = "read" | "write" | "admin";
+export declare const OrgEditTeamRequestPermission: any;
+export type OrgEditTeamRequestUnitsList = Array<string>;
+export declare const OrgEditTeamRequestUnitsList: S.Schema<OrgEditTeamRequestUnitsList>;
+export type OrgEditTeamRequestUnitsMapMap = {
+    [key: string]: string | undefined;
+};
+export declare const OrgEditTeamRequestUnitsMapMap: 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 declare const OrgEditTeamRequest: S.Schema<OrgEditTeamRequest>;
+export interface OrgGetAllRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const OrgGetAllRequest: S.Schema<OrgGetAllRequest>;
+export type OrgGetAllResponseBodyList = Array<Organization>;
+export declare const OrgGetAllResponseBodyList: S.Schema<OrgGetAllResponseBodyList>;
+export type OrgGetAllResponse = OrgGetAllResponseBodyList;
+export declare const OrgGetAllResponse: S.Schema<OrgGetAllResponse>;
+export interface OrgGetHookRequest {
+    /** name of the organization */
+    org: string;
+    /** id of the hook to get */
+    id: number;
+}
+export declare const OrgGetHookRequest: S.Schema<OrgGetHookRequest>;
+export interface OrgGetLabelRequest {
+    /** name of the organization */
+    org: string;
+    /** id of the label to get */
+    id: number;
+}
+export declare const OrgGetLabelRequest: S.Schema<OrgGetLabelRequest>;
+export interface OrgGetQuotaRequest {
+    /** name of the organization */
+    org: string;
+}
+export declare const OrgGetQuotaRequest: S.Schema<OrgGetQuotaRequest>;
+/** Subjects the rule affects */
+export type QuotaRuleInfoSubjectsList = Array<string>;
+export declare const QuotaRuleInfoSubjectsList: 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 declare const QuotaRuleInfo: S.Schema<QuotaRuleInfo>;
+/** Rules associated with the group */
+export type QuotaGroupRulesList = Array<QuotaRuleInfo>;
+export declare const QuotaGroupRulesList: 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 declare const QuotaGroup: S.Schema<QuotaGroup>;
+/** QuotaGroupList represents a list of quota groups */
+export type QuotaGroupList = Array<QuotaGroup>;
+export declare const QuotaGroupList: 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 declare const QuotaUsedSizeAssetsAttachments: 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 declare const QuotaUsedSizeAssetsPackages: 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 declare const QuotaUsedSizeAssets: 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 declare const QuotaUsedSizeGit: 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 declare const QuotaUsedSizeRepos: S.Schema<QuotaUsedSizeRepos>;
+/** QuotaUsedSize represents the size-based quota usage of a user */
+export interface QuotaUsedSize {
+    assets?: QuotaUsedSizeAssets;
+    git?: QuotaUsedSizeGit;
+    repos?: QuotaUsedSizeRepos;
+}
+export declare const QuotaUsedSize: S.Schema<QuotaUsedSize>;
+/** QuotaUsed represents the quota usage of a user */
+export interface QuotaUsed {
+    size?: QuotaUsedSize;
+}
+export declare const QuotaUsed: S.Schema<QuotaUsed>;
+/** QuotaInfo represents information about a user's quota */
+export interface QuotaInfo {
+    groups?: QuotaGroupList;
+    used?: QuotaUsed;
+}
+export declare const QuotaInfo: S.Schema<QuotaInfo>;
+export interface OrgGetTeamRequest {
+    /** id of the team to get */
+    id: number;
+}
+export declare const OrgGetTeamRequest: S.Schema<OrgGetTeamRequest>;
+export interface OrgGetUserPermissionsRequest {
+    /** username of user */
+    username: string;
+    /** name of the organization */
+    org: string;
+}
+export declare const OrgGetUserPermissionsRequest: 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 declare const OrganizationPermissions: S.Schema<OrganizationPermissions>;
+export interface OrgIsMemberRequest {
+    /** name of the organization */
+    org: string;
+    /** username of the user */
+    username: string;
+}
+export declare const OrgIsMemberRequest: S.Schema<OrgIsMemberRequest>;
+export interface OrgIsMemberResponse {
+}
+export declare const OrgIsMemberResponse: S.Schema<OrgIsMemberResponse>;
+export interface OrgIsPublicMemberRequest {
+    /** name of the organization */
+    org: string;
+    /** username of the user */
+    username: string;
+}
+export declare const OrgIsPublicMemberRequest: S.Schema<OrgIsPublicMemberRequest>;
+export interface OrgIsPublicMemberResponse {
+}
+export declare const OrgIsPublicMemberResponse: 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 declare const OrgListActionsSecretsRequest: S.Schema<OrgListActionsSecretsRequest>;
+/** Secret represents a secret */
+export interface Secret {
+    created_at: string;
+    /** the secret's name */
+    name: string;
+}
+export declare const Secret: S.Schema<Secret>;
+export type OrgListActionsSecretsResponseBodyList = Array<Secret>;
+export declare const OrgListActionsSecretsResponseBodyList: S.Schema<OrgListActionsSecretsResponseBodyList>;
+export type OrgListActionsSecretsResponse = OrgListActionsSecretsResponseBodyList;
+export declare const OrgListActionsSecretsResponse: 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 declare const OrgListActivityFeedsRequest: S.Schema<OrgListActivityFeedsRequest>;
+export type AttachmentType = "attachment" | "external";
+export declare const AttachmentType: any;
+/** Attachment a generic attachment */
+export interface Attachment {
+    browser_download_url?: string;
+    created_at?: string;
+    download_count?: number;
+    id?: number;
+    name?: string;
+    size?: number;
+    type?: AttachmentType;
+    uuid?: string;
+}
+export declare const Attachment: S.Schema<Attachment>;
+/** The attachments to the comment */
+export type CommentAssetsList = Array<Attachment>;
+export declare const CommentAssetsList: S.Schema<CommentAssetsList>;
+/** Comment represents a comment on a commit or issue */
+export interface Comment {
+    /** The attachments to the comment */
+    assets?: CommentAssetsList;
+    /** The body of the comment */
+    body?: string;
+    /** The time of the comment's creation */
+    created_at?: string;
+    /** The HTML URL of the comment */
+    html_url?: string;
+    /** The identifier of the comment */
+    id?: number;
+    /** The HTML URL of the issue if the comment is posted on an issue, else empty string */
+    issue_url?: string;
+    /** The original author that posted the comment if it was not posted locally, else empty string */
+    original_author?: string;
+    /** The ID of the original author that posted the comment if it was not posted locally, else 0 */
+    original_author_id?: number;
+    /** The HTML URL of the pull request if the comment is posted on a pull request, else empty string */
+    pull_request_url?: string;
+    /** The time of the comment's update */
+    updated_at?: string;
+    user?: User;
+}
+export declare const Comment: S.Schema<Comment>;
+/** 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 declare const ActivityOpType: any;
+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 declare const Activity: S.Schema<Activity>;
+export type OrgListActivityFeedsResponseBodyList = Array<Activity>;
+export declare const OrgListActivityFeedsResponseBodyList: S.Schema<OrgListActivityFeedsResponseBodyList>;
+export type OrgListActivityFeedsResponse = OrgListActivityFeedsResponseBodyList;
+export declare const OrgListActivityFeedsResponse: 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 declare const OrgListBlockedUsersRequest: S.Schema<OrgListBlockedUsersRequest>;
+export interface BlockedUser {
+    block_id?: number;
+    created_at?: string;
+}
+export declare const BlockedUser: S.Schema<BlockedUser>;
+export type OrgListBlockedUsersResponseBodyList = Array<BlockedUser>;
+export declare const OrgListBlockedUsersResponseBodyList: S.Schema<OrgListBlockedUsersResponseBodyList>;
+export type OrgListBlockedUsersResponse = OrgListBlockedUsersResponseBodyList;
+export declare const OrgListBlockedUsersResponse: S.Schema<OrgListBlockedUsersResponse>;
+export interface OrgListCurrentUserOrgsRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const OrgListCurrentUserOrgsRequest: S.Schema<OrgListCurrentUserOrgsRequest>;
+export type OrgListCurrentUserOrgsResponseBodyList = Array<Organization>;
+export declare const OrgListCurrentUserOrgsResponseBodyList: S.Schema<OrgListCurrentUserOrgsResponseBodyList>;
+export type OrgListCurrentUserOrgsResponse = OrgListCurrentUserOrgsResponseBodyList;
+export declare const OrgListCurrentUserOrgsResponse: 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 declare const OrgListHooksRequest: S.Schema<OrgListHooksRequest>;
+export type OrgListHooksResponseBodyList = Array<Hook>;
+export declare const OrgListHooksResponseBodyList: S.Schema<OrgListHooksResponseBodyList>;
+export type OrgListHooksResponse = OrgListHooksResponseBodyList;
+export declare const OrgListHooksResponse: S.Schema<OrgListHooksResponse>;
+export type OrgListLabelsRequestSort = "mostissues" | "leastissues" | "reversealphabetically";
+export declare const OrgListLabelsRequestSort: any;
+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 declare const OrgListLabelsRequest: S.Schema<OrgListLabelsRequest>;
+export type OrgListLabelsResponseBodyList = Array<Label>;
+export declare const OrgListLabelsResponseBodyList: S.Schema<OrgListLabelsResponseBodyList>;
+export type OrgListLabelsResponse = OrgListLabelsResponseBodyList;
+export declare const OrgListLabelsResponse: 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 declare const OrgListMembersRequest: S.Schema<OrgListMembersRequest>;
+export type OrgListMembersResponseBodyList = Array<User>;
+export declare const OrgListMembersResponseBodyList: S.Schema<OrgListMembersResponseBodyList>;
+export type OrgListMembersResponse = OrgListMembersResponseBodyList;
+export declare const OrgListMembersResponse: 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 declare const OrgListPublicMembersRequest: S.Schema<OrgListPublicMembersRequest>;
+export type OrgListPublicMembersResponseBodyList = Array<User>;
+export declare const OrgListPublicMembersResponseBodyList: S.Schema<OrgListPublicMembersResponseBodyList>;
+export type OrgListPublicMembersResponse = OrgListPublicMembersResponseBodyList;
+export declare const OrgListPublicMembersResponse: 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 declare const OrgListQuotaArtifactsRequest: 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 declare const QuotaUsedArtifact: S.Schema<QuotaUsedArtifact>;
+/** QuotaUsedArtifactList represents a list of artifacts counting towards a user's quota */
+export type QuotaUsedArtifactList = Array<QuotaUsedArtifact>;
+export declare const QuotaUsedArtifactList: S.Schema<QuotaUsedArtifactList>;
+export type OrgListQuotaArtifactsResponse = QuotaUsedArtifactList;
+export declare const OrgListQuotaArtifactsResponse: 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 declare const OrgListQuotaAttachmentsRequest: 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 declare const QuotaUsedAttachmentContainedIn: 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 declare const QuotaUsedAttachment: S.Schema<QuotaUsedAttachment>;
+/** QuotaUsedAttachmentList represents a list of attachment counting towards a user's quota */
+export type QuotaUsedAttachmentList = Array<QuotaUsedAttachment>;
+export declare const QuotaUsedAttachmentList: S.Schema<QuotaUsedAttachmentList>;
+export type OrgListQuotaAttachmentsResponse = QuotaUsedAttachmentList;
+export declare const OrgListQuotaAttachmentsResponse: 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 declare const OrgListQuotaPackagesRequest: 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 declare const QuotaUsedPackage: S.Schema<QuotaUsedPackage>;
+/** QuotaUsedPackageList represents a list of packages counting towards a user's quota */
+export type QuotaUsedPackageList = Array<QuotaUsedPackage>;
+export declare const QuotaUsedPackageList: S.Schema<QuotaUsedPackageList>;
+export type OrgListQuotaPackagesResponse = QuotaUsedPackageList;
+export declare const OrgListQuotaPackagesResponse: 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 declare const OrgListReposRequest: S.Schema<OrgListReposRequest>;
+export type OrgListReposResponseBodyList = Array<Repository>;
+export declare const OrgListReposResponseBodyList: S.Schema<OrgListReposResponseBodyList>;
+export type OrgListReposResponse = OrgListReposResponseBodyList;
+export declare const OrgListReposResponse: 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 declare const OrgListTeamActivityFeedsRequest: S.Schema<OrgListTeamActivityFeedsRequest>;
+export type OrgListTeamActivityFeedsResponseBodyList = Array<Activity>;
+export declare const OrgListTeamActivityFeedsResponseBodyList: S.Schema<OrgListTeamActivityFeedsResponseBodyList>;
+export type OrgListTeamActivityFeedsResponse = OrgListTeamActivityFeedsResponseBodyList;
+export declare const OrgListTeamActivityFeedsResponse: S.Schema<OrgListTeamActivityFeedsResponse>;
+export interface OrgListTeamMemberRequest {
+    /** id of the team */
+    id: number;
+    /** username of the member to list */
+    username: string;
+}
+export declare const OrgListTeamMemberRequest: 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 declare const OrgListTeamMembersRequest: S.Schema<OrgListTeamMembersRequest>;
+export type OrgListTeamMembersResponseBodyList = Array<User>;
+export declare const OrgListTeamMembersResponseBodyList: S.Schema<OrgListTeamMembersResponseBodyList>;
+export type OrgListTeamMembersResponse = OrgListTeamMembersResponseBodyList;
+export declare const OrgListTeamMembersResponse: 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 declare const OrgListTeamRepoRequest: 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 declare const OrgListTeamReposRequest: S.Schema<OrgListTeamReposRequest>;
+export type OrgListTeamReposResponseBodyList = Array<Repository>;
+export declare const OrgListTeamReposResponseBodyList: S.Schema<OrgListTeamReposResponseBodyList>;
+export type OrgListTeamReposResponse = OrgListTeamReposResponseBodyList;
+export declare const OrgListTeamReposResponse: 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 declare const OrgListTeamsRequest: S.Schema<OrgListTeamsRequest>;
+export type OrgListTeamsResponseBodyList = Array<Team>;
+export declare const OrgListTeamsResponseBodyList: S.Schema<OrgListTeamsResponseBodyList>;
+export type OrgListTeamsResponse = OrgListTeamsResponseBodyList;
+export declare const OrgListTeamsResponse: 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 declare const OrgListUserOrgsRequest: S.Schema<OrgListUserOrgsRequest>;
+export type OrgListUserOrgsResponseBodyList = Array<Organization>;
+export declare const OrgListUserOrgsResponseBodyList: S.Schema<OrgListUserOrgsResponseBodyList>;
+export type OrgListUserOrgsResponse = OrgListUserOrgsResponseBodyList;
+export declare const OrgListUserOrgsResponse: S.Schema<OrgListUserOrgsResponse>;
+export interface OrgPublicizeMemberRequest {
+    /** name of the organization */
+    org: string;
+    /** username of the user */
+    username: string;
+}
+export declare const OrgPublicizeMemberRequest: S.Schema<OrgPublicizeMemberRequest>;
+export interface OrgPublicizeMemberResponse {
+}
+export declare const OrgPublicizeMemberResponse: S.Schema<OrgPublicizeMemberResponse>;
+export interface OrgRemoveTeamMemberRequest {
+    /** id of the team */
+    id: number;
+    /** username of the user to remove */
+    username: string;
+}
+export declare const OrgRemoveTeamMemberRequest: S.Schema<OrgRemoveTeamMemberRequest>;
+export interface OrgRemoveTeamMemberResponse {
+}
+export declare const OrgRemoveTeamMemberResponse: 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 declare const OrgRemoveTeamRepositoryRequest: S.Schema<OrgRemoveTeamRepositoryRequest>;
+export interface OrgRemoveTeamRepositoryResponse {
+}
+export declare const OrgRemoveTeamRepositoryResponse: 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 declare const OrgSearchRunJobsRequest: S.Schema<OrgSearchRunJobsRequest>;
+/** the action run job needed ids */
+export type ActionRunJobNeedsList = Array<string>;
+export declare const ActionRunJobNeedsList: S.Schema<ActionRunJobNeedsList>;
+/** the action run job labels to run on */
+export type ActionRunJobRunsOnList = Array<string>;
+export declare const ActionRunJobRunsOnList: 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 declare const ActionRunJob: S.Schema<ActionRunJob>;
+export type OrgSearchRunJobsResponseBodyList = Array<ActionRunJob>;
+export declare const OrgSearchRunJobsResponseBodyList: S.Schema<OrgSearchRunJobsResponseBodyList>;
+export type OrgSearchRunJobsResponse = OrgSearchRunJobsResponseBodyList;
+export declare const OrgSearchRunJobsResponse: S.Schema<OrgSearchRunJobsResponse>;
+export interface OrgUnblockUserRequest {
+    /** name of the org */
+    org: string;
+    /** username of the user */
+    username: string;
+}
+export declare const OrgUnblockUserRequest: S.Schema<OrgUnblockUserRequest>;
+export interface OrgUnblockUserResponse {
+}
+export declare const OrgUnblockUserResponse: S.Schema<OrgUnblockUserResponse>;
+export interface OrgUpdateAvatarRequest {
+    /** name of the organization */
+    org: string;
+    /** image must be base64 encoded */
+    image?: string;
+}
+export declare const OrgUpdateAvatarRequest: S.Schema<OrgUpdateAvatarRequest>;
+export interface OrgUpdateAvatarResponse {
+}
+export declare const OrgUpdateAvatarResponse: 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 declare const RegisterOrgRunnerRequest: S.Schema<RegisterOrgRunnerRequest>;
+export interface RegisterRunnerResponse {
+    id?: number;
+    token?: string;
+    uuid?: string;
+}
+export declare const RegisterRunnerResponse: 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 declare const RenameOrgRequest: S.Schema<RenameOrgRequest>;
+export interface RenameOrgResponse {
+}
+export declare const RenameOrgResponse: 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 declare const SearchTeamRequest: S.Schema<SearchTeamRequest>;
+export type SearchTeamResponseDataList = Array<Team>;
+export declare const SearchTeamResponseDataList: S.Schema<SearchTeamResponseDataList>;
+export interface SearchTeamResponse {
+    data?: SearchTeamResponseDataList;
+    ok?: boolean;
+}
+export declare const SearchTeamResponse: 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 declare const UpdateOrgSecretRequest: S.Schema<UpdateOrgSecretRequest>;
+export interface UpdateOrgSecretResponse {
+}
+export declare const UpdateOrgSecretResponse: 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 declare const UpdateOrgVariableRequest: S.Schema<UpdateOrgVariableRequest>;
+export interface UpdateOrgVariableResponse {
+}
+export declare const UpdateOrgVariableResponse: S.Schema<UpdateOrgVariableResponse>;
+export type CreateOrgError = Forbidden | UnprocessableEntity | ForgejoOpError;
+/** Create an organization */
+export declare const createOrg: API.OperationMethod<CreateOrgRequest, Organization, CreateOrgError, ForgejoOpContext>;
+export type CreateOrgRepoError = BadRequest | Forbidden | NotFound | Conflict | ForgejoOpError;
+/** Create a repository in an organization */
+export declare const createOrgRepo: API.OperationMethod<CreateOrgRepoRequest, Repository, CreateOrgRepoError, ForgejoOpContext>;
+export type CreateOrgVariableError = BadRequest | NotFound | ForgejoOpError;
+/** Create a new variable in organization */
+export declare const createOrgVariable: API.OperationMethod<CreateOrgVariableRequest, CreateOrgVariableResponse, CreateOrgVariableError, ForgejoOpContext>;
+export type DeleteOrgError = NotFound | OrganizationOwnsRepositories | ForgejoOpError;
+/** Delete an organization */
+export declare const deleteOrg: API.OperationMethod<DeleteOrgRequest, DeleteOrgResponse, DeleteOrgError, ForgejoOpContext>;
+export type DeleteOrgRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Delete a particular runner that belongs to the organization */
+export declare const deleteOrgRunner: API.OperationMethod<DeleteOrgRunnerRequest, DeleteOrgRunnerResponse, DeleteOrgRunnerError, ForgejoOpContext>;
+export type DeleteOrgSecretError = BadRequest | NotFound | ForgejoOpError;
+/** Delete a secret in an organization */
+export declare const deleteOrgSecret: API.OperationMethod<DeleteOrgSecretRequest, DeleteOrgSecretResponse, DeleteOrgSecretError, ForgejoOpContext>;
+export type DeleteOrgVariableError = BadRequest | NotFound | ForgejoOpError;
+/** Delete organization's variable by name */
+export declare const deleteOrgVariable: API.OperationMethod<DeleteOrgVariableRequest, DeleteOrgVariableResponse, DeleteOrgVariableError, ForgejoOpContext>;
+export type EditOrgError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Edit an organization */
+export declare const editOrg: API.OperationMethod<EditOrgRequest, Organization, EditOrgError, ForgejoOpContext>;
+export type GetOrgError = NotFound | ForgejoOpError;
+/** Get an organization */
+export declare const getOrg: API.OperationMethod<GetOrgRequest, Organization, GetOrgError, ForgejoOpContext>;
+export type GetOrgRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Get a particular runner that belongs to the organization */
+export declare const getOrgRunner: API.OperationMethod<GetOrgRunnerRequest, ActionRunner, GetOrgRunnerError, ForgejoOpContext>;
+export type GetOrgRunnersError = BadRequest | NotFound | ForgejoOpError;
+/** Get the organization's runners */
+export declare const getOrgRunners: API.OperationMethod<GetOrgRunnersRequest, GetOrgRunnersResponse, GetOrgRunnersError, ForgejoOpContext>;
+export type GetOrgVariableError = BadRequest | NotFound | ForgejoOpError;
+/** Get organization's variable by name */
+export declare const getOrgVariable: API.OperationMethod<GetOrgVariableRequest, ActionVariable, GetOrgVariableError, ForgejoOpContext>;
+export type GetOrgVariablesListError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** List variables of an organization */
+export declare const getOrgVariablesList: API.OperationMethod<GetOrgVariablesListRequest, GetOrgVariablesListResponse, GetOrgVariablesListError, ForgejoOpContext>;
+export type OrgAddTeamMemberError = NotFound | ForgejoOpError;
+/** Add a team member */
+export declare const orgAddTeamMember: API.OperationMethod<OrgAddTeamMemberRequest, OrgAddTeamMemberResponse, OrgAddTeamMemberError, ForgejoOpContext>;
+export type OrgAddTeamRepositoryError = Forbidden | NotFound | ForgejoOpError;
+/** Add a repository to a team */
+export declare const orgAddTeamRepository: API.OperationMethod<OrgAddTeamRepositoryRequest, OrgAddTeamRepositoryResponse, OrgAddTeamRepositoryError, ForgejoOpContext>;
+export type OrgBlockUserError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Blocks a user from the organization */
+export declare const orgBlockUser: API.OperationMethod<OrgBlockUserRequest, OrgBlockUserResponse, OrgBlockUserError, ForgejoOpContext>;
+export type OrgCheckQuotaError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Check if the organization is over quota for a given subject */
+export declare const orgCheckQuota: API.OperationMethod<OrgCheckQuotaRequest, OrgCheckQuotaResponse, OrgCheckQuotaError, ForgejoOpContext>;
+export type OrgConcealMemberError = Forbidden | NotFound | ForgejoOpError;
+/** Conceal a user's membership */
+export declare const orgConcealMember: API.OperationMethod<OrgConcealMemberRequest, OrgConcealMemberResponse, OrgConcealMemberError, ForgejoOpContext>;
+export type OrgCreateHookError = NotFound | ForgejoOpError;
+/** Create a hook */
+export declare const orgCreateHook: API.OperationMethod<OrgCreateHookRequest, Hook, OrgCreateHookError, ForgejoOpContext>;
+export type OrgCreateLabelError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Create a label for an organization */
+export declare const orgCreateLabel: API.OperationMethod<OrgCreateLabelRequest, Label, OrgCreateLabelError, ForgejoOpContext>;
+export type OrgCreateTeamError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Create a team */
+export declare const orgCreateTeam: API.OperationMethod<OrgCreateTeamRequest, Team, OrgCreateTeamError, ForgejoOpContext>;
+export type OrgDeleteAvatarError = NotFound | ForgejoOpError;
+/** Delete an organization's avatar. It will be replaced by a default one */
+export declare const orgDeleteAvatar: API.OperationMethod<OrgDeleteAvatarRequest, OrgDeleteAvatarResponse, OrgDeleteAvatarError, ForgejoOpContext>;
+export type OrgDeleteHookError = NotFound | ForgejoOpError;
+/** Delete a hook */
+export declare const orgDeleteHook: API.OperationMethod<OrgDeleteHookRequest, OrgDeleteHookResponse, OrgDeleteHookError, ForgejoOpContext>;
+export type OrgDeleteLabelError = NotFound | ForgejoOpError;
+/** Delete a label */
+export declare const orgDeleteLabel: API.OperationMethod<OrgDeleteLabelRequest, OrgDeleteLabelResponse, OrgDeleteLabelError, ForgejoOpContext>;
+export type OrgDeleteMemberError = NotFound | ForgejoOpError;
+/** Remove a member from an organization */
+export declare const orgDeleteMember: API.OperationMethod<OrgDeleteMemberRequest, OrgDeleteMemberResponse, OrgDeleteMemberError, ForgejoOpContext>;
+export type OrgDeleteTeamError = NotFound | ForgejoOpError;
+/** Delete a team */
+export declare const orgDeleteTeam: API.OperationMethod<OrgDeleteTeamRequest, OrgDeleteTeamResponse, OrgDeleteTeamError, ForgejoOpContext>;
+export type OrgEditHookError = NotFound | ForgejoOpError;
+/** Update a hook */
+export declare const orgEditHook: API.OperationMethod<OrgEditHookRequest, Hook, OrgEditHookError, ForgejoOpContext>;
+export type OrgEditLabelError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Update a label */
+export declare const orgEditLabel: API.OperationMethod<OrgEditLabelRequest, Label, OrgEditLabelError, ForgejoOpContext>;
+export type OrgEditTeamError = NotFound | ForgejoOpError;
+/** Edit a team */
+export declare const orgEditTeam: API.OperationMethod<OrgEditTeamRequest, Team, OrgEditTeamError, ForgejoOpContext>;
+export type OrgGetAllError = ForgejoOpError;
+/** List all organizations */
+export declare const orgGetAll: API.OperationMethod<OrgGetAllRequest, OrgGetAllResponse, OrgGetAllError, ForgejoOpContext>;
+export type OrgGetHookError = NotFound | ForgejoOpError;
+/** Get a hook */
+export declare const orgGetHook: API.OperationMethod<OrgGetHookRequest, Hook, OrgGetHookError, ForgejoOpContext>;
+export type OrgGetLabelError = NotFound | ForgejoOpError;
+/** Get a single label */
+export declare const orgGetLabel: API.OperationMethod<OrgGetLabelRequest, Label, OrgGetLabelError, ForgejoOpContext>;
+export type OrgGetQuotaError = Forbidden | NotFound | ForgejoOpError;
+/** Get quota information for an organization */
+export declare const orgGetQuota: API.OperationMethod<OrgGetQuotaRequest, QuotaInfo, OrgGetQuotaError, ForgejoOpContext>;
+export type OrgGetTeamError = NotFound | ForgejoOpError;
+/** Get a team */
+export declare const orgGetTeam: API.OperationMethod<OrgGetTeamRequest, Team, OrgGetTeamError, ForgejoOpContext>;
+export type OrgGetUserPermissionsError = Forbidden | NotFound | ForgejoOpError;
+/** Get user permissions in organization */
+export declare const orgGetUserPermissions: API.OperationMethod<OrgGetUserPermissionsRequest, OrganizationPermissions, OrgGetUserPermissionsError, ForgejoOpContext>;
+export type OrgIsMemberError = NotFound | ForgejoOpError;
+/** Check if a user is a member of an organization */
+export declare const orgIsMember: API.OperationMethod<OrgIsMemberRequest, OrgIsMemberResponse, OrgIsMemberError, ForgejoOpContext>;
+export type OrgIsPublicMemberError = NotFound | ForgejoOpError;
+/** Check if a user is a public member of an organization */
+export declare const orgIsPublicMember: API.OperationMethod<OrgIsPublicMemberRequest, OrgIsPublicMemberResponse, OrgIsPublicMemberError, ForgejoOpContext>;
+export type OrgListActionsSecretsError = Forbidden | NotFound | ForgejoOpError;
+/** List actions secrets of an organization */
+export declare const orgListActionsSecrets: API.OperationMethod<OrgListActionsSecretsRequest, OrgListActionsSecretsResponse, OrgListActionsSecretsError, ForgejoOpContext>;
+export type OrgListActivityFeedsError = NotFound | ForgejoOpError;
+/** List an organization's activity feeds */
+export declare const orgListActivityFeeds: API.OperationMethod<OrgListActivityFeedsRequest, OrgListActivityFeedsResponse, OrgListActivityFeedsError, ForgejoOpContext>;
+export type OrgListBlockedUsersError = ForgejoOpError;
+/** List the organization's blocked users */
+export declare const orgListBlockedUsers: API.OperationMethod<OrgListBlockedUsersRequest, OrgListBlockedUsersResponse, OrgListBlockedUsersError, ForgejoOpContext>;
+export type OrgListCurrentUserOrgsError = Forbidden | NotFound | ForgejoOpError;
+/** List the current user's organizations */
+export declare const orgListCurrentUserOrgs: API.OperationMethod<OrgListCurrentUserOrgsRequest, OrgListCurrentUserOrgsResponse, OrgListCurrentUserOrgsError, ForgejoOpContext>;
+export type OrgListHooksError = NotFound | ForgejoOpError;
+/** List an organization's webhooks */
+export declare const orgListHooks: API.OperationMethod<OrgListHooksRequest, OrgListHooksResponse, OrgListHooksError, ForgejoOpContext>;
+export type OrgListLabelsError = NotFound | ForgejoOpError;
+/** List an organization's labels */
+export declare const orgListLabels: API.OperationMethod<OrgListLabelsRequest, OrgListLabelsResponse, OrgListLabelsError, ForgejoOpContext>;
+export type OrgListMembersError = NotFound | ForgejoOpError;
+/** List an organization's members */
+export declare const orgListMembers: API.OperationMethod<OrgListMembersRequest, OrgListMembersResponse, OrgListMembersError, ForgejoOpContext>;
+export type OrgListPublicMembersError = NotFound | ForgejoOpError;
+/** List an organization's public members */
+export declare const orgListPublicMembers: API.OperationMethod<OrgListPublicMembersRequest, OrgListPublicMembersResponse, OrgListPublicMembersError, ForgejoOpContext>;
+export type OrgListQuotaArtifactsError = Forbidden | NotFound | ForgejoOpError;
+/** List the artifacts affecting the organization's quota */
+export declare const orgListQuotaArtifacts: API.OperationMethod<OrgListQuotaArtifactsRequest, OrgListQuotaArtifactsResponse, OrgListQuotaArtifactsError, ForgejoOpContext>;
+export type OrgListQuotaAttachmentsError = Forbidden | NotFound | ForgejoOpError;
+/** List the attachments affecting the organization's quota */
+export declare const orgListQuotaAttachments: API.OperationMethod<OrgListQuotaAttachmentsRequest, OrgListQuotaAttachmentsResponse, OrgListQuotaAttachmentsError, ForgejoOpContext>;
+export type OrgListQuotaPackagesError = Forbidden | NotFound | ForgejoOpError;
+/** List the packages affecting the organization's quota */
+export declare const orgListQuotaPackages: API.OperationMethod<OrgListQuotaPackagesRequest, OrgListQuotaPackagesResponse, OrgListQuotaPackagesError, ForgejoOpContext>;
+export type OrgListReposError = NotFound | ForgejoOpError;
+/** List an organization's repos */
+export declare const orgListRepos: API.OperationMethod<OrgListReposRequest, OrgListReposResponse, OrgListReposError, ForgejoOpContext>;
+export type OrgListTeamActivityFeedsError = NotFound | ForgejoOpError;
+/** List a team's activity feeds */
+export declare const orgListTeamActivityFeeds: API.OperationMethod<OrgListTeamActivityFeedsRequest, OrgListTeamActivityFeedsResponse, OrgListTeamActivityFeedsError, ForgejoOpContext>;
+export type OrgListTeamMemberError = NotFound | ForgejoOpError;
+/** List a particular member of team */
+export declare const orgListTeamMember: API.OperationMethod<OrgListTeamMemberRequest, User, OrgListTeamMemberError, ForgejoOpContext>;
+export type OrgListTeamMembersError = Forbidden | NotFound | ForgejoOpError;
+/** List a team's members */
+export declare const orgListTeamMembers: API.OperationMethod<OrgListTeamMembersRequest, OrgListTeamMembersResponse, OrgListTeamMembersError, ForgejoOpContext>;
+export type OrgListTeamRepoError = NotFound | ForgejoOpError;
+/** List a particular repo of team */
+export declare const orgListTeamRepo: API.OperationMethod<OrgListTeamRepoRequest, Repository, OrgListTeamRepoError, ForgejoOpContext>;
+export type OrgListTeamReposError = NotFound | ForgejoOpError;
+/** List a team's repos */
+export declare const orgListTeamRepos: API.OperationMethod<OrgListTeamReposRequest, OrgListTeamReposResponse, OrgListTeamReposError, ForgejoOpContext>;
+export type OrgListTeamsError = Forbidden | NotFound | ForgejoOpError;
+/** List an organization's teams */
+export declare const orgListTeams: API.OperationMethod<OrgListTeamsRequest, OrgListTeamsResponse, OrgListTeamsError, ForgejoOpContext>;
+export type OrgListUserOrgsError = NotFound | ForgejoOpError;
+/** List a user's organizations */
+export declare const orgListUserOrgs: API.OperationMethod<OrgListUserOrgsRequest, OrgListUserOrgsResponse, OrgListUserOrgsError, ForgejoOpContext>;
+export type OrgPublicizeMemberError = Forbidden | NotFound | ForgejoOpError;
+/** Publicize a user's membership */
+export declare const orgPublicizeMember: API.OperationMethod<OrgPublicizeMemberRequest, OrgPublicizeMemberResponse, OrgPublicizeMemberError, ForgejoOpContext>;
+export type OrgRemoveTeamMemberError = NotFound | ForgejoOpError;
+/** Remove a team member */
+export declare const orgRemoveTeamMember: API.OperationMethod<OrgRemoveTeamMemberRequest, OrgRemoveTeamMemberResponse, OrgRemoveTeamMemberError, ForgejoOpContext>;
+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 declare const orgRemoveTeamRepository: API.OperationMethod<OrgRemoveTeamRepositoryRequest, OrgRemoveTeamRepositoryResponse, OrgRemoveTeamRepositoryError, ForgejoOpContext>;
+export type OrgSearchRunJobsError = Forbidden | ForgejoOpError;
+/** Search for organization's action jobs according filter conditions */
+export declare const orgSearchRunJobs: API.OperationMethod<OrgSearchRunJobsRequest, OrgSearchRunJobsResponse, OrgSearchRunJobsError, ForgejoOpContext>;
+export type OrgUnblockUserError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Unblock a user from the organization */
+export declare const orgUnblockUser: API.OperationMethod<OrgUnblockUserRequest, OrgUnblockUserResponse, OrgUnblockUserError, ForgejoOpContext>;
+export type OrgUpdateAvatarError = NotFound | ForgejoOpError;
+/** Update an organization's avatar */
+export declare const orgUpdateAvatar: API.OperationMethod<OrgUpdateAvatarRequest, OrgUpdateAvatarResponse, OrgUpdateAvatarError, ForgejoOpContext>;
+export type RegisterOrgRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Register a new organization-level runner */
+export declare const registerOrgRunner: API.OperationMethod<RegisterOrgRunnerRequest, RegisterRunnerResponse, RegisterOrgRunnerError, ForgejoOpContext>;
+export type RenameOrgError = Forbidden | UnprocessableEntity | ForgejoOpError;
+/** Rename an organization */
+export declare const renameOrg: API.OperationMethod<RenameOrgRequest, RenameOrgResponse, RenameOrgError, ForgejoOpContext>;
+export type SearchTeamError = NotFound | ForgejoOpError;
+/** Search for teams within an organization */
+export declare const searchTeam: API.OperationMethod<SearchTeamRequest, SearchTeamResponse, SearchTeamError, ForgejoOpContext>;
+export type UpdateOrgSecretError = BadRequest | NotFound | ForgejoOpError;
+/** Create or Update a secret value in an organization */
+export declare const updateOrgSecret: API.OperationMethod<UpdateOrgSecretRequest, UpdateOrgSecretResponse, UpdateOrgSecretError, ForgejoOpContext>;
+export type UpdateOrgVariableError = BadRequest | NotFound | ForgejoOpError;
+/** Update variable in organization */
+export declare const updateOrgVariable: API.OperationMethod<UpdateOrgVariableRequest, UpdateOrgVariableResponse, UpdateOrgVariableError, ForgejoOpContext>;
+//# sourceMappingURL=organization.d.ts.map