gitlab

  • Version 14.2.2
  • Published
  • 615 kB
  • 9 dependencies
  • MIT license

Install

npm i gitlab
yarn add gitlab
pnpm add gitlab

Overview

Full NodeJS implementation of the GitLab API. Supports Promises, Async/Await.

Index

Variables

Classes

Interfaces

Type Aliases

Variables

variable Gitlab

const Gitlab: Bundle<
typeof APIServices,
| 'Groups'
| 'GroupAccessRequests'
| 'GroupBadges'
| 'GroupCustomAttributes'
| 'GroupIssueBoards'
| 'GroupMembers'
| 'GroupMilestones'
| 'GroupProjects'
| 'GroupVariables'
| 'GroupLabels'
| 'Epics'
| 'EpicIssues'
| 'EpicNotes'
| 'EpicDiscussions'
| 'Users'
| 'UserCustomAttributes'
| 'UserEmails'
| 'UserImpersonationTokens'
| 'UserKeys'
| 'UserGPGKeys'
| 'Branches'
| 'Commits'
| 'CommitDiscussions'
| 'ContainerRegistry'
| 'DeployKeys'
| 'Deployments'
| 'Environments'
| 'Issues'
| 'IssuesStatistics'
| 'IssueAwardEmojis'
| 'IssueNotes'
| 'IssueDiscussions'
| 'Jobs'
| 'Labels'
| 'MergeRequests'
| 'MergeRequestAwardEmojis'
| 'MergeRequestDiscussions'
| 'MergeRequestNotes'
| 'Packages'
| 'Pipelines'
| 'PipelineSchedules'
| 'PipelineScheduleVariables'
| 'Projects'
| 'ProjectAccessRequests'
| 'ProjectBadges'
| 'ProjectCustomAttributes'
| 'ProjectImportExport'
| 'ProjectIssueBoards'
| 'ProjectHooks'
| 'ProjectMembers'
| 'ProjectMilestones'
| 'ProjectSnippets'
| 'ProjectSnippetNotes'
| 'ProjectSnippetDiscussions'
| 'ProjectSnippetAwardEmojis'
| 'ProtectedBranches'
| 'ProtectedTags'
| 'ProjectVariables'
| 'PushRules'
| 'Releases'
| 'ReleaseLinks'
| 'Repositories'
| 'RepositoryFiles'
| 'Runners'
| 'Services'
| 'Tags'
| 'Triggers'
| 'VulnerabilityFindings'
| 'Todos'
| 'ApplicationSettings'
| 'BroadcastMessages'
| 'Events'
| 'FeatureFlags'
| 'GeoNodes'
| 'GitignoreTemplates'
| 'GitLabCIYMLTemplates'
| 'Keys'
| 'Licence'
| 'LicenceTemplates'
| 'Lint'
| 'Namespaces'
| 'NotificationSettings'
| 'Markdown'
| 'PagesDomains'
| 'Search'
| 'SidekiqMetrics'
| 'Snippets'
| 'SystemHooks'
| 'Version'
| 'Wikis'
>;

    variable GroupsBundle

    const GroupsBundle: Bundle<
    {
    Groups: typeof APIServices.Groups;
    GroupAccessRequests: typeof APIServices.GroupAccessRequests;
    GroupBadges: typeof APIServices.GroupBadges;
    GroupCustomAttributes: typeof APIServices.GroupCustomAttributes;
    GroupIssueBoards: typeof APIServices.GroupIssueBoards;
    GroupMembers: typeof APIServices.GroupMembers;
    GroupMilestones: typeof APIServices.GroupMilestones;
    GroupProjects: typeof APIServices.GroupProjects;
    GroupVariables: typeof APIServices.GroupVariables;
    GroupLabels: typeof APIServices.GroupLabels;
    Epics: typeof APIServices.Epics;
    EpicIssues: typeof APIServices.EpicIssues;
    EpicNotes: typeof APIServices.EpicNotes;
    EpicDiscussions: typeof APIServices.EpicDiscussions;
    },
    | 'Groups'
    | 'GroupAccessRequests'
    | 'GroupBadges'
    | 'GroupCustomAttributes'
    | 'GroupIssueBoards'
    | 'GroupMembers'
    | 'GroupMilestones'
    | 'GroupProjects'
    | 'GroupVariables'
    | 'GroupLabels'
    | 'Epics'
    | 'EpicIssues'
    | 'EpicNotes'
    | 'EpicDiscussions'
    >;

      variable ProjectsBundle

      const ProjectsBundle: Bundle<
      {
      Branches: typeof APIServices.Branches;
      Commits: typeof APIServices.Commits;
      CommitDiscussions: typeof APIServices.CommitDiscussions;
      ContainerRegistry: typeof APIServices.ContainerRegistry;
      DeployKeys: typeof APIServices.DeployKeys;
      Deployments: typeof APIServices.Deployments;
      Environments: typeof APIServices.Environments;
      Issues: typeof APIServices.Issues;
      IssuesStatistics: typeof APIServices.IssuesStatistics;
      IssueAwardEmojis: typeof APIServices.IssueAwardEmojis;
      IssueNotes: typeof APIServices.IssueNotes;
      IssueDiscussions: typeof APIServices.IssueDiscussions;
      Jobs: typeof APIServices.Jobs;
      Labels: typeof APIServices.Labels;
      MergeRequests: typeof APIServices.MergeRequests;
      MergeRequestAwardEmojis: typeof APIServices.MergeRequestAwardEmojis;
      MergeRequestDiscussions: typeof APIServices.MergeRequestDiscussions;
      MergeRequestNotes: typeof APIServices.MergeRequestNotes;
      Packages: typeof APIServices.Packages;
      Pipelines: typeof APIServices.Pipelines;
      PipelineSchedules: typeof APIServices.PipelineSchedules;
      PipelineScheduleVariables: typeof APIServices.PipelineScheduleVariables;
      Projects: typeof APIServices.Projects;
      ProjectAccessRequests: typeof APIServices.ProjectAccessRequests;
      ProjectBadges: typeof APIServices.ProjectBadges;
      ProjectCustomAttributes: typeof APIServices.ProjectCustomAttributes;
      ProjectImportExport: typeof APIServices.ProjectImportExport;
      ProjectIssueBoards: typeof APIServices.ProjectIssueBoards;
      ProjectHooks: typeof APIServices.ProjectHooks;
      ProjectMembers: typeof APIServices.ProjectMembers;
      ProjectMilestones: typeof APIServices.ProjectMilestones;
      ProjectSnippets: typeof APIServices.ProjectSnippets;
      ProjectSnippetNotes: typeof APIServices.ProjectSnippetNotes;
      ProjectSnippetDiscussions: typeof APIServices.ProjectSnippetDiscussions;
      ProjectSnippetAwardEmojis: typeof APIServices.ProjectSnippetAwardEmojis;
      ProtectedBranches: typeof APIServices.ProtectedBranches;
      ProtectedTags: typeof APIServices.ProtectedTags;
      ProjectVariables: typeof APIServices.ProjectVariables;
      PushRules: typeof APIServices.PushRules;
      Releases: typeof APIServices.Releases;
      ReleaseLinks: typeof APIServices.ReleaseLinks;
      Repositories: typeof APIServices.Repositories;
      RepositoryFiles: typeof APIServices.RepositoryFiles;
      Runners: typeof APIServices.Runners;
      Services: typeof APIServices.Services;
      Tags: typeof APIServices.Tags;
      Triggers: typeof APIServices.Triggers;
      VulnerabilityFindings: typeof APIServices.VulnerabilityFindings;
      },
      | 'Branches'
      | 'Commits'
      | 'CommitDiscussions'
      | 'ContainerRegistry'
      | 'DeployKeys'
      | 'Deployments'
      | 'Environments'
      | 'Issues'
      | 'IssuesStatistics'
      | 'IssueAwardEmojis'
      | 'IssueNotes'
      | 'IssueDiscussions'
      | 'Jobs'
      | 'Labels'
      | 'MergeRequests'
      | 'MergeRequestAwardEmojis'
      | 'MergeRequestDiscussions'
      | 'MergeRequestNotes'
      | 'Packages'
      | 'Pipelines'
      | 'PipelineSchedules'
      | 'PipelineScheduleVariables'
      | 'Projects'
      | 'ProjectAccessRequests'
      | 'ProjectBadges'
      | 'ProjectCustomAttributes'
      | 'ProjectImportExport'
      | 'ProjectIssueBoards'
      | 'ProjectHooks'
      | 'ProjectMembers'
      | 'ProjectMilestones'
      | 'ProjectSnippets'
      | 'ProjectSnippetNotes'
      | 'ProjectSnippetDiscussions'
      | 'ProjectSnippetAwardEmojis'
      | 'ProtectedBranches'
      | 'ProtectedTags'
      | 'ProjectVariables'
      | 'PushRules'
      | 'Releases'
      | 'ReleaseLinks'
      | 'Repositories'
      | 'RepositoryFiles'
      | 'Runners'
      | 'Services'
      | 'Tags'
      | 'Triggers'
      | 'VulnerabilityFindings'
      >;

        variable UsersBundle

        const UsersBundle: Bundle<
        {
        Users: typeof APIServices.Users;
        UserCustomAttributes: typeof APIServices.UserCustomAttributes;
        UserEmails: typeof APIServices.UserEmails;
        UserImpersonationTokens: typeof APIServices.UserImpersonationTokens;
        UserKeys: typeof APIServices.UserKeys;
        UserGPGKeys: typeof APIServices.UserGPGKeys;
        },
        | 'Users'
        | 'UserCustomAttributes'
        | 'UserEmails'
        | 'UserImpersonationTokens'
        | 'UserKeys'
        | 'UserGPGKeys'
        >;

          Classes

          class ApplicationSettings

          class ApplicationSettings extends BaseService {}

            method all

            all: (options?: Sudo) => Promise<import('../infrastructure').GetResponse>;

              method edit

              edit: (options?: BaseRequestOptions) => Promise<object>;

                class Branches

                class Branches extends BaseService {}

                  method all

                  all: (
                  projectId: string | number,
                  options?: { search?: string } & PaginatedRequestOptions
                  ) => Promise<import('../infrastructure').GetResponse>;

                    method create

                    create: (
                    projectId: string | number,
                    branchName: string,
                    ref: string,
                    options?: Sudo
                    ) => Promise<object>;

                      method protect

                      protect: (
                      projectId: string | number,
                      branchName: string,
                      options?: BaseRequestOptions
                      ) => Promise<object>;

                        method remove

                        remove: (
                        projectId: string | number,
                        branchName: string,
                        options?: Sudo
                        ) => Promise<object>;

                          method show

                          show: (
                          projectId: string | number,
                          branchName: string,
                          options?: Sudo
                          ) => Promise<import('../infrastructure').GetResponse>;

                            method unprotect

                            unprotect: (
                            projectId: string | number,
                            branchName: string,
                            options?: Sudo
                            ) => Promise<object>;

                              class BroadcastMessages

                              class BroadcastMessages extends BaseService {}

                                method all

                                all: (
                                options?: PaginatedRequestOptions
                                ) => Promise<import('../infrastructure').GetResponse>;

                                  method create

                                  create: (options?: BaseRequestOptions) => Promise<object>;

                                    method edit

                                    edit: (
                                    broadcastMessageId: number,
                                    options?: BaseRequestOptions
                                    ) => Promise<object>;

                                      method remove

                                      remove: (broadcastMessageId: number) => Promise<object>;

                                        method show

                                        show: (
                                        broadcastMessageId: number,
                                        options?: BaseRequestOptions
                                        ) => Promise<import('../infrastructure').GetResponse>;

                                          class CommitDiscussions

                                          class CommitDiscussions extends ResourceDiscussions {}

                                            constructor

                                            constructor(options: BaseServiceOptions);

                                              class Commits

                                              class Commits extends BaseService {}

                                                method all

                                                all: (
                                                projectId: string | number,
                                                options?: PaginatedRequestOptions
                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                  method cherryPick

                                                  cherryPick: (
                                                  projectId: string | number,
                                                  sha: string,
                                                  branch: string,
                                                  options?: Sudo
                                                  ) => Promise<object>;

                                                    method comments

                                                    comments: (
                                                    projectId: string | number,
                                                    sha: string,
                                                    options?: Sudo
                                                    ) => Promise<import('../infrastructure').GetResponse>;

                                                      method create

                                                      create: (
                                                      projectId: string | number,
                                                      branch: string,
                                                      message: string,
                                                      actions?: CommitAction[],
                                                      options?: BaseRequestOptions
                                                      ) => Promise<object>;

                                                        method createComment

                                                        createComment: (
                                                        projectId: string | number,
                                                        sha: string,
                                                        note: string,
                                                        options?: BaseRequestOptions
                                                        ) => Promise<object>;

                                                          method diff

                                                          diff: (
                                                          projectId: string | number,
                                                          sha: string,
                                                          options?: Sudo
                                                          ) => Promise<import('../infrastructure').GetResponse>;

                                                            method editStatus

                                                            editStatus: (
                                                            projectId: string | number,
                                                            sha: string,
                                                            options?: BaseRequestOptions
                                                            ) => Promise<object>;

                                                              method mergeRequests

                                                              mergeRequests: (
                                                              projectId: string | number,
                                                              sha: string,
                                                              options?: BaseRequestOptions
                                                              ) => Promise<import('../infrastructure').GetResponse>;

                                                                method references

                                                                references: (
                                                                projectId: string | number,
                                                                sha: string,
                                                                options?: Sudo
                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                  method show

                                                                  show: (
                                                                  projectId: string | number,
                                                                  sha: string,
                                                                  options?: BaseRequestOptions
                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                    method status

                                                                    status: (
                                                                    projectId: string | number,
                                                                    sha: string,
                                                                    options?: BaseRequestOptions
                                                                    ) => Promise<import('../infrastructure').GetResponse>;

                                                                      class ContainerRegistry

                                                                      class ContainerRegistry extends BaseService {}

                                                                        method removeRepository

                                                                        removeRepository: (
                                                                        projectId: string | number,
                                                                        repositoryId: number,
                                                                        options?: Sudo
                                                                        ) => Promise<object>;

                                                                          method removeTag

                                                                          removeTag: (
                                                                          projectId: string | number,
                                                                          repositoryId: number,
                                                                          tagName: string,
                                                                          options?: Sudo
                                                                          ) => Promise<object>;

                                                                            method removeTags

                                                                            removeTags: (
                                                                            projectId: string | number,
                                                                            repositoryId: number,
                                                                            tagNameRegex: string,
                                                                            options?: Sudo & { keepN: string; olderThan: string }
                                                                            ) => Promise<object>;

                                                                              method repositories

                                                                              repositories: (
                                                                              projectId: string | number,
                                                                              options?: PaginatedRequestOptions
                                                                              ) => Promise<import('../infrastructure').GetResponse>;

                                                                                method showTag

                                                                                showTag: (
                                                                                projectId: string | number,
                                                                                repositoryId: number,
                                                                                tagName: string,
                                                                                options?: Sudo
                                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                                  method tags

                                                                                  tags: (
                                                                                  projectId: string | number,
                                                                                  repositoryId: number,
                                                                                  options?: PaginatedRequestOptions
                                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                                    class DeployKeys

                                                                                    class DeployKeys extends BaseService {}

                                                                                      method add

                                                                                      add: (projectId: string | number, options?: Sudo) => Promise<object>;

                                                                                        method all

                                                                                        all: ({
                                                                                        projectId,
                                                                                        ...options
                                                                                        }: { projectId?: string | number } & PaginatedRequestOptions) => Promise<
                                                                                        import('../infrastructure').GetResponse
                                                                                        >;

                                                                                          method edit

                                                                                          edit: (
                                                                                          projectId: string | number,
                                                                                          keyId: string,
                                                                                          options?: BaseRequestOptions
                                                                                          ) => Promise<object>;

                                                                                            method enable

                                                                                            enable: (
                                                                                            projectId: string | number,
                                                                                            keyId: string,
                                                                                            options?: Sudo
                                                                                            ) => Promise<object>;

                                                                                              method remove

                                                                                              remove: (
                                                                                              projectId: string | number,
                                                                                              keyId: string,
                                                                                              options?: Sudo
                                                                                              ) => Promise<object>;

                                                                                                method show

                                                                                                show: (
                                                                                                projectId: string | number,
                                                                                                keyId: string,
                                                                                                options?: Sudo
                                                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                  class Deployments

                                                                                                  class Deployments extends BaseService {}

                                                                                                    method all

                                                                                                    all: (
                                                                                                    projectId: string | number,
                                                                                                    options?: PaginatedRequestOptions
                                                                                                    ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                      method mergeRequests

                                                                                                      mergeRequests: (
                                                                                                      projectId: string | number,
                                                                                                      deploymentId: number,
                                                                                                      options?: Sudo
                                                                                                      ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                        method show

                                                                                                        show: (
                                                                                                        projectId: string | number,
                                                                                                        deploymentId: number,
                                                                                                        options?: Sudo
                                                                                                        ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                          class Environments

                                                                                                          class Environments extends BaseService {}

                                                                                                            method all

                                                                                                            all: (
                                                                                                            projectId: string | number,
                                                                                                            options?: PaginatedRequestOptions
                                                                                                            ) => Promise<EnvironmentSchema[]>;

                                                                                                              method create

                                                                                                              create: (
                                                                                                              projectId: string | number,
                                                                                                              options?: BaseRequestOptions
                                                                                                              ) => Promise<object>;

                                                                                                                method edit

                                                                                                                edit: (
                                                                                                                projectId: string | number,
                                                                                                                environmentId: number,
                                                                                                                options?: BaseRequestOptions
                                                                                                                ) => Promise<object>;

                                                                                                                  method remove

                                                                                                                  remove: (
                                                                                                                  projectId: string | number,
                                                                                                                  environmentId: number,
                                                                                                                  options?: Sudo
                                                                                                                  ) => Promise<object>;

                                                                                                                    method show

                                                                                                                    show: (
                                                                                                                    projectId: string | number,
                                                                                                                    environmentId: number,
                                                                                                                    options?: Sudo
                                                                                                                    ) => Promise<EnvironmentDetailSchema>;

                                                                                                                      method stop

                                                                                                                      stop: (
                                                                                                                      projectId: string | number,
                                                                                                                      environmentId: number,
                                                                                                                      options?: Sudo
                                                                                                                      ) => Promise<object>;

                                                                                                                        class EpicDiscussions

                                                                                                                        class EpicDiscussions extends ResourceDiscussions {}

                                                                                                                          constructor

                                                                                                                          constructor(options: BaseServiceOptions);

                                                                                                                            class EpicIssues

                                                                                                                            class EpicIssues extends BaseService {}

                                                                                                                              method all

                                                                                                                              all: (
                                                                                                                              groupId: string | number,
                                                                                                                              epicId: number,
                                                                                                                              options?: PaginatedRequestOptions
                                                                                                                              ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                method assign

                                                                                                                                assign: (
                                                                                                                                groupId: string | number,
                                                                                                                                epicId: number,
                                                                                                                                issueId: number,
                                                                                                                                options?: Sudo
                                                                                                                                ) => Promise<object>;

                                                                                                                                  method edit

                                                                                                                                  edit: (
                                                                                                                                  groupId: string | number,
                                                                                                                                  epicId: number,
                                                                                                                                  issueId: number,
                                                                                                                                  options?: BaseRequestOptions
                                                                                                                                  ) => Promise<object>;

                                                                                                                                    method remove

                                                                                                                                    remove: (
                                                                                                                                    groupId: string | number,
                                                                                                                                    epicId: number,
                                                                                                                                    issueId: number,
                                                                                                                                    options?: Sudo
                                                                                                                                    ) => Promise<object>;

                                                                                                                                      class EpicNotes

                                                                                                                                      class EpicNotes extends ResourceNotes {}

                                                                                                                                        constructor

                                                                                                                                        constructor(options: BaseServiceOptions);

                                                                                                                                          class Epics

                                                                                                                                          class Epics extends BaseService {}

                                                                                                                                            method all

                                                                                                                                            all: (
                                                                                                                                            groupId: string | number,
                                                                                                                                            options?: PaginatedRequestOptions
                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                              method create

                                                                                                                                              create: (
                                                                                                                                              groupId: string | number,
                                                                                                                                              title: string,
                                                                                                                                              options?: BaseRequestOptions
                                                                                                                                              ) => Promise<object>;

                                                                                                                                                method edit

                                                                                                                                                edit: (
                                                                                                                                                groupId: string | number,
                                                                                                                                                epicId: number,
                                                                                                                                                options?: BaseRequestOptions
                                                                                                                                                ) => Promise<object>;

                                                                                                                                                  method remove

                                                                                                                                                  remove: (
                                                                                                                                                  groupId: string | number,
                                                                                                                                                  epicId: number,
                                                                                                                                                  options?: Sudo
                                                                                                                                                  ) => Promise<object>;

                                                                                                                                                    method show

                                                                                                                                                    show: (
                                                                                                                                                    groupId: string | number,
                                                                                                                                                    epicId: number,
                                                                                                                                                    options?: Sudo
                                                                                                                                                    ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                      class Events

                                                                                                                                                      class Events extends BaseService {}

                                                                                                                                                        method all

                                                                                                                                                        all: (
                                                                                                                                                        options?: PaginatedRequestOptions & EventOptions
                                                                                                                                                        ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                          class FeatureFlags

                                                                                                                                                          class FeatureFlags extends BaseService {}

                                                                                                                                                            method all

                                                                                                                                                            all: (
                                                                                                                                                            options?: PaginatedRequestOptions
                                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                              method set

                                                                                                                                                              set: (name: string, options?: BaseRequestOptions) => Promise<object>;

                                                                                                                                                                class GeoNodes

                                                                                                                                                                class GeoNodes extends BaseService {}

                                                                                                                                                                  method all

                                                                                                                                                                  all: (
                                                                                                                                                                  options?: PaginatedRequestOptions
                                                                                                                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                    method create

                                                                                                                                                                    create: (geonodeId: number, options?: BaseRequestOptions) => Promise<object>;

                                                                                                                                                                      method edit

                                                                                                                                                                      edit: (geonodeId: number, options?: BaseRequestOptions) => Promise<object>;

                                                                                                                                                                        method failures

                                                                                                                                                                        failures: (options?: BaseRequestOptions) => Promise<object>;

                                                                                                                                                                          method repair

                                                                                                                                                                          repair: (geonodeId: number, options?: Sudo) => Promise<object>;

                                                                                                                                                                            method show

                                                                                                                                                                            show: (
                                                                                                                                                                            geonodeId: number,
                                                                                                                                                                            options?: Sudo
                                                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                              method status

                                                                                                                                                                              status: (
                                                                                                                                                                              geonodeId: number,
                                                                                                                                                                              options?: Sudo
                                                                                                                                                                              ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                method statuses

                                                                                                                                                                                statuses: (
                                                                                                                                                                                options?: PaginatedRequestOptions
                                                                                                                                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                  class GitignoreTemplates

                                                                                                                                                                                  class GitignoreTemplates extends ResourceTemplates {}

                                                                                                                                                                                    constructor

                                                                                                                                                                                    constructor(options: BaseServiceOptions);

                                                                                                                                                                                      class GitLabCIYMLTemplates

                                                                                                                                                                                      class GitLabCIYMLTemplates extends ResourceTemplates {}

                                                                                                                                                                                        constructor

                                                                                                                                                                                        constructor(options: BaseServiceOptions);

                                                                                                                                                                                          class GroupAccessRequests

                                                                                                                                                                                          class GroupAccessRequests extends ResourceAccessRequests {}

                                                                                                                                                                                            constructor

                                                                                                                                                                                            constructor(options: BaseServiceOptions);

                                                                                                                                                                                              class GroupBadges

                                                                                                                                                                                              class GroupBadges extends ResourceBadges {}

                                                                                                                                                                                                constructor

                                                                                                                                                                                                constructor(options: BaseServiceOptions);

                                                                                                                                                                                                  class GroupCustomAttributes

                                                                                                                                                                                                  class GroupCustomAttributes extends ResourceCustomAttributes {}

                                                                                                                                                                                                    constructor

                                                                                                                                                                                                    constructor(options: BaseServiceOptions);

                                                                                                                                                                                                      class GroupIssueBoards

                                                                                                                                                                                                      class GroupIssueBoards extends ResourceIssueBoards {}

                                                                                                                                                                                                        constructor

                                                                                                                                                                                                        constructor(options: BaseServiceOptions);

                                                                                                                                                                                                          class GroupLabels

                                                                                                                                                                                                          class GroupLabels extends ResourceLabels {}

                                                                                                                                                                                                            constructor

                                                                                                                                                                                                            constructor(options: BaseServiceOptions);

                                                                                                                                                                                                              class GroupMembers

                                                                                                                                                                                                              class GroupMembers extends ResourceMembers {}

                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                  class GroupMilestones

                                                                                                                                                                                                                  class GroupMilestones extends ResourceMilestones {}

                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                    constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                      class GroupProjects

                                                                                                                                                                                                                      class GroupProjects extends BaseService {}

                                                                                                                                                                                                                        method add

                                                                                                                                                                                                                        add: (
                                                                                                                                                                                                                        groupId: string | number,
                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                        options?: BaseRequestOptions
                                                                                                                                                                                                                        ) => Promise<object>;

                                                                                                                                                                                                                          method all

                                                                                                                                                                                                                          all: (
                                                                                                                                                                                                                          groupId: string | number,
                                                                                                                                                                                                                          options?: PaginatedRequestOptions
                                                                                                                                                                                                                          ) => Promise<ProjectSchema[]>;

                                                                                                                                                                                                                            class Groups

                                                                                                                                                                                                                            class Groups extends BaseService {}

                                                                                                                                                                                                                              method all

                                                                                                                                                                                                                              all: (options?: PaginatedRequestOptions) => Promise<GroupSchema[]>;

                                                                                                                                                                                                                                method create

                                                                                                                                                                                                                                create: (options?: BaseRequestOptions) => Promise<object>;
                                                                                                                                                                                                                                  createLDAPLink: (
                                                                                                                                                                                                                                  groupId: string | number,
                                                                                                                                                                                                                                  cn: any,
                                                                                                                                                                                                                                  groupAccess: any,
                                                                                                                                                                                                                                  provider: string,
                                                                                                                                                                                                                                  options?: Sudo
                                                                                                                                                                                                                                  ) => Promise<object>;

                                                                                                                                                                                                                                    method edit

                                                                                                                                                                                                                                    edit: (
                                                                                                                                                                                                                                    groupId: string | number,
                                                                                                                                                                                                                                    options?: BaseRequestOptions
                                                                                                                                                                                                                                    ) => Promise<object>;

                                                                                                                                                                                                                                      method projects

                                                                                                                                                                                                                                      projects: (
                                                                                                                                                                                                                                      groupId: string | number,
                                                                                                                                                                                                                                      options?: BaseRequestOptions
                                                                                                                                                                                                                                      ) => Promise<ProjectSchema[]>;

                                                                                                                                                                                                                                        method remove

                                                                                                                                                                                                                                        remove: (groupId: string | number, options?: Sudo) => Promise<object>;
                                                                                                                                                                                                                                          removeLDAPLink: (
                                                                                                                                                                                                                                          groupId: string | number,
                                                                                                                                                                                                                                          cn: any,
                                                                                                                                                                                                                                          { provider, ...options }?: Sudo & { provider?: string }
                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                            method search

                                                                                                                                                                                                                                            search: (
                                                                                                                                                                                                                                            nameOrPath: string,
                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                              method show

                                                                                                                                                                                                                                              show: (
                                                                                                                                                                                                                                              groupId: string | number,
                                                                                                                                                                                                                                              options?: BaseRequestOptions
                                                                                                                                                                                                                                              ) => Promise<GroupDetailSchema>;

                                                                                                                                                                                                                                                method subgroups

                                                                                                                                                                                                                                                subgroups: (
                                                                                                                                                                                                                                                groupId: string | number,
                                                                                                                                                                                                                                                options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                ) => Promise<GroupDetailSchema[]>;

                                                                                                                                                                                                                                                  method syncLDAP

                                                                                                                                                                                                                                                  syncLDAP: (groupId: string | number, options?: Sudo) => Promise<object>;

                                                                                                                                                                                                                                                    class GroupVariables

                                                                                                                                                                                                                                                    class GroupVariables extends ResourceVariables {}

                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                      constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                        class IssueAwardEmojis

                                                                                                                                                                                                                                                        class IssueAwardEmojis extends ResourceAwardEmojis {}

                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                          constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                            class IssueDiscussions

                                                                                                                                                                                                                                                            class IssueDiscussions extends ResourceDiscussions {}

                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                              constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                class IssueNotes

                                                                                                                                                                                                                                                                class IssueNotes extends ResourceNotes {}

                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                  constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                    class Issues

                                                                                                                                                                                                                                                                    class Issues extends BaseService {}

                                                                                                                                                                                                                                                                      method addSpentTime

                                                                                                                                                                                                                                                                      addSpentTime: (
                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                      issueId: number,
                                                                                                                                                                                                                                                                      duration: string,
                                                                                                                                                                                                                                                                      options?: Sudo
                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                        method addTimeEstimate

                                                                                                                                                                                                                                                                        addTimeEstimate: (
                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                        issueId: number,
                                                                                                                                                                                                                                                                        duration: string,
                                                                                                                                                                                                                                                                        options?: Sudo
                                                                                                                                                                                                                                                                        ) => Promise<object>;

                                                                                                                                                                                                                                                                          method all

                                                                                                                                                                                                                                                                          all: ({
                                                                                                                                                                                                                                                                          projectId,
                                                                                                                                                                                                                                                                          groupId,
                                                                                                                                                                                                                                                                          ...options
                                                                                                                                                                                                                                                                          }?: ({ projectId?: string | number } | { groupId?: string | number } | {}) &
                                                                                                                                                                                                                                                                          PaginatedRequestOptions) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                            method create

                                                                                                                                                                                                                                                                            create: (
                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                            options?: BaseRequestOptions
                                                                                                                                                                                                                                                                            ) => Promise<object>;

                                                                                                                                                                                                                                                                              method edit

                                                                                                                                                                                                                                                                              edit: (
                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                              issueId: number,
                                                                                                                                                                                                                                                                              options?: BaseRequestOptions
                                                                                                                                                                                                                                                                              ) => Promise<object>;
                                                                                                                                                                                                                                                                                link: (
                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                issueIId: number,
                                                                                                                                                                                                                                                                                targetProjectId: string | number,
                                                                                                                                                                                                                                                                                targetIssueId: number,
                                                                                                                                                                                                                                                                                options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                ) => Promise<object>;

                                                                                                                                                                                                                                                                                  method participants

                                                                                                                                                                                                                                                                                  participants: (
                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                  issueId: number,
                                                                                                                                                                                                                                                                                  options?: Sudo
                                                                                                                                                                                                                                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                    method remove

                                                                                                                                                                                                                                                                                    remove: (
                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                    issueId: number,
                                                                                                                                                                                                                                                                                    options?: Sudo
                                                                                                                                                                                                                                                                                    ) => Promise<object>;

                                                                                                                                                                                                                                                                                      method resetSpentTime

                                                                                                                                                                                                                                                                                      resetSpentTime: (
                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                      issueId: number,
                                                                                                                                                                                                                                                                                      options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                        method resetTimeEstimate

                                                                                                                                                                                                                                                                                        resetTimeEstimate: (
                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                        issueId: number,
                                                                                                                                                                                                                                                                                        options?: Sudo
                                                                                                                                                                                                                                                                                        ) => Promise<object>;

                                                                                                                                                                                                                                                                                          method show

                                                                                                                                                                                                                                                                                          show: (
                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                          issueId: number,
                                                                                                                                                                                                                                                                                          options?: Sudo
                                                                                                                                                                                                                                                                                          ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                            method subscribe

                                                                                                                                                                                                                                                                                            subscribe: (
                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                            issueId: number,
                                                                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                                                                            ) => Promise<object>;

                                                                                                                                                                                                                                                                                              method timeStats

                                                                                                                                                                                                                                                                                              timeStats: (
                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                              issueId: number,
                                                                                                                                                                                                                                                                                              options?: Sudo
                                                                                                                                                                                                                                                                                              ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                method unsubscribe

                                                                                                                                                                                                                                                                                                unsubscribe: (
                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                issueId: number,
                                                                                                                                                                                                                                                                                                options?: Sudo
                                                                                                                                                                                                                                                                                                ) => Promise<object>;

                                                                                                                                                                                                                                                                                                  class IssuesStatistics

                                                                                                                                                                                                                                                                                                  class IssuesStatistics extends BaseService {}

                                                                                                                                                                                                                                                                                                    method all

                                                                                                                                                                                                                                                                                                    all: ({
                                                                                                                                                                                                                                                                                                    projectId,
                                                                                                                                                                                                                                                                                                    groupId,
                                                                                                                                                                                                                                                                                                    ...options
                                                                                                                                                                                                                                                                                                    }?: ({ projectId?: string | number } | { groupId?: string | number } | {}) &
                                                                                                                                                                                                                                                                                                    BaseRequestOptions) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                      class Jobs

                                                                                                                                                                                                                                                                                                      class Jobs extends BaseService {}

                                                                                                                                                                                                                                                                                                        method all

                                                                                                                                                                                                                                                                                                        all: (
                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                        options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                                                                        ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                          method cancel

                                                                                                                                                                                                                                                                                                          cancel: (
                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                          jobId: number,
                                                                                                                                                                                                                                                                                                          options?: Sudo
                                                                                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                                                                                            method downloadLatestArtifactFile

                                                                                                                                                                                                                                                                                                            downloadLatestArtifactFile: (
                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                            ref: string,
                                                                                                                                                                                                                                                                                                            name: string,
                                                                                                                                                                                                                                                                                                            { stream, ...options }: { stream?: boolean } & BaseRequestOptions
                                                                                                                                                                                                                                                                                                            ) => any;

                                                                                                                                                                                                                                                                                                              method downloadSingleArtifactFile

                                                                                                                                                                                                                                                                                                              downloadSingleArtifactFile: (
                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                              jobId: number,
                                                                                                                                                                                                                                                                                                              artifactPath: string,
                                                                                                                                                                                                                                                                                                              { stream, ...options }: { stream?: boolean } & BaseRequestOptions
                                                                                                                                                                                                                                                                                                              ) => any;

                                                                                                                                                                                                                                                                                                                method downloadSingleArtifactFileFromRef

                                                                                                                                                                                                                                                                                                                downloadSingleArtifactFileFromRef: (
                                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                                ref: string,
                                                                                                                                                                                                                                                                                                                artifactPath: string,
                                                                                                                                                                                                                                                                                                                name: string,
                                                                                                                                                                                                                                                                                                                { stream, ...options }: { stream?: boolean } & BaseRequestOptions
                                                                                                                                                                                                                                                                                                                ) => any;

                                                                                                                                                                                                                                                                                                                  method downloadTraceFile

                                                                                                                                                                                                                                                                                                                  downloadTraceFile: (
                                                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                                                  jobId: number,
                                                                                                                                                                                                                                                                                                                  options?: Sudo
                                                                                                                                                                                                                                                                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                    method erase

                                                                                                                                                                                                                                                                                                                    erase: (
                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                    jobId: number,
                                                                                                                                                                                                                                                                                                                    options?: Sudo
                                                                                                                                                                                                                                                                                                                    ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                      method eraseArtifacts

                                                                                                                                                                                                                                                                                                                      eraseArtifacts: (
                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                      jobId: number,
                                                                                                                                                                                                                                                                                                                      options?: Sudo
                                                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                        method keepArtifacts

                                                                                                                                                                                                                                                                                                                        keepArtifacts: (
                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                        jobId: number,
                                                                                                                                                                                                                                                                                                                        options?: Sudo
                                                                                                                                                                                                                                                                                                                        ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                          method play

                                                                                                                                                                                                                                                                                                                          play: (
                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                          jobId: number,
                                                                                                                                                                                                                                                                                                                          options?: Sudo
                                                                                                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                            method retry

                                                                                                                                                                                                                                                                                                                            retry: (
                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                            jobId: number,
                                                                                                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                                                                                                            ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                              method show

                                                                                                                                                                                                                                                                                                                              show: (
                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                              jobId: number,
                                                                                                                                                                                                                                                                                                                              options?: Sudo
                                                                                                                                                                                                                                                                                                                              ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                method showPipelineJobs

                                                                                                                                                                                                                                                                                                                                showPipelineJobs: (
                                                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                                                pipelineId: number,
                                                                                                                                                                                                                                                                                                                                options?: { scope?: JobScope } & Sudo
                                                                                                                                                                                                                                                                                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                  class Keys

                                                                                                                                                                                                                                                                                                                                  class Keys extends BaseService {}

                                                                                                                                                                                                                                                                                                                                    method show

                                                                                                                                                                                                                                                                                                                                    show: (
                                                                                                                                                                                                                                                                                                                                    keyId: string,
                                                                                                                                                                                                                                                                                                                                    options?: Sudo
                                                                                                                                                                                                                                                                                                                                    ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                      class Labels

                                                                                                                                                                                                                                                                                                                                      class Labels extends ResourceLabels {}

                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                        constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                          class Licence

                                                                                                                                                                                                                                                                                                                                          class Licence extends BaseService {}

                                                                                                                                                                                                                                                                                                                                            method all

                                                                                                                                                                                                                                                                                                                                            all: (options?: Sudo) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                              method create

                                                                                                                                                                                                                                                                                                                                              create: (options?: Sudo) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                class LicenceTemplates

                                                                                                                                                                                                                                                                                                                                                class LicenceTemplates extends ResourceTemplates {}

                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                  constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                    class Lint

                                                                                                                                                                                                                                                                                                                                                    class Lint extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                      method lint

                                                                                                                                                                                                                                                                                                                                                      lint: (content: string, options?: Sudo) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                        class Markdown

                                                                                                                                                                                                                                                                                                                                                        class Markdown extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                                                                          render: (
                                                                                                                                                                                                                                                                                                                                                          text: string,
                                                                                                                                                                                                                                                                                                                                                          options?: { gfm?: string; project?: string | number } & Sudo
                                                                                                                                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                            class MergeRequestAwardEmojis

                                                                                                                                                                                                                                                                                                                                                            class MergeRequestAwardEmojis extends ResourceAwardEmojis {}

                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                              constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                                class MergeRequestDiscussions

                                                                                                                                                                                                                                                                                                                                                                class MergeRequestDiscussions extends ResourceDiscussions {}

                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                  constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                                    class MergeRequestNotes

                                                                                                                                                                                                                                                                                                                                                                    class MergeRequestNotes extends ResourceNotes {}

                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                      constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                                        class MergeRequests

                                                                                                                                                                                                                                                                                                                                                                        class MergeRequests extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                          method accept

                                                                                                                                                                                                                                                                                                                                                                          accept: (
                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                          mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                          options?: AcceptMergeRequestOptions & BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                            method addSpentTime

                                                                                                                                                                                                                                                                                                                                                                            addSpentTime: (
                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                            mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                            duration: string,
                                                                                                                                                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                              method addTimeEstimate

                                                                                                                                                                                                                                                                                                                                                                              addTimeEstimate: (
                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                              mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                              duration: string,
                                                                                                                                                                                                                                                                                                                                                                              options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                method all

                                                                                                                                                                                                                                                                                                                                                                                all: ({
                                                                                                                                                                                                                                                                                                                                                                                projectId,
                                                                                                                                                                                                                                                                                                                                                                                groupId,
                                                                                                                                                                                                                                                                                                                                                                                ...options
                                                                                                                                                                                                                                                                                                                                                                                }: ({ projectId: string | number } | { groupId: string | number } | {}) &
                                                                                                                                                                                                                                                                                                                                                                                PaginatedRequestOptions) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                  method approvals

                                                                                                                                                                                                                                                                                                                                                                                  approvals: (
                                                                                                                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                  {
                                                                                                                                                                                                                                                                                                                                                                                  mergerequestIId,
                                                                                                                                                                                                                                                                                                                                                                                  ...options
                                                                                                                                                                                                                                                                                                                                                                                  }?: { mergerequestIId?: number } & BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                    method approvalState

                                                                                                                                                                                                                                                                                                                                                                                    approvalState: (
                                                                                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                    mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                    options?: { sha?: string } & BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                      method approve

                                                                                                                                                                                                                                                                                                                                                                                      approve: (
                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                      mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                      options?: { sha?: string } & BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                        method approvers

                                                                                                                                                                                                                                                                                                                                                                                        approvers: (
                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                        approverIds: number[],
                                                                                                                                                                                                                                                                                                                                                                                        approverGroupIds: (string | number)[],
                                                                                                                                                                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                                                                                                                                                                        mergerequestIId,
                                                                                                                                                                                                                                                                                                                                                                                        ...options
                                                                                                                                                                                                                                                                                                                                                                                        }?: { mergerequestIId?: number } & BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                          method cancelOnPipelineSucess

                                                                                                                                                                                                                                                                                                                                                                                          cancelOnPipelineSucess: (
                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                          mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                          options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                            method changes

                                                                                                                                                                                                                                                                                                                                                                                            changes: (
                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                            mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                              method closesIssues

                                                                                                                                                                                                                                                                                                                                                                                              closesIssues: (
                                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                              mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                              options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                method commits

                                                                                                                                                                                                                                                                                                                                                                                                commits: (
                                                                                                                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                                options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                  method create

                                                                                                                                                                                                                                                                                                                                                                                                  create: (
                                                                                                                                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                  sourceBranch: string,
                                                                                                                                                                                                                                                                                                                                                                                                  targetBranch: string,
                                                                                                                                                                                                                                                                                                                                                                                                  title: string,
                                                                                                                                                                                                                                                                                                                                                                                                  options?: CreateMergeRequestOptions & BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                    method edit

                                                                                                                                                                                                                                                                                                                                                                                                    edit: (
                                                                                                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                    mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                                    options?: UpdateMergeRequestOptions & BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                      method editApprovals

                                                                                                                                                                                                                                                                                                                                                                                                      editApprovals: (
                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                      mergerequestIId,
                                                                                                                                                                                                                                                                                                                                                                                                      ...options
                                                                                                                                                                                                                                                                                                                                                                                                      }?: { mergerequestIId?: number } & BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                        method participants

                                                                                                                                                                                                                                                                                                                                                                                                        participants: (
                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                        mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                                        options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                          method pipelines

                                                                                                                                                                                                                                                                                                                                                                                                          pipelines: (
                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                          mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                                          options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                            method remove

                                                                                                                                                                                                                                                                                                                                                                                                            remove: (
                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                            mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                              method resetSpentTime

                                                                                                                                                                                                                                                                                                                                                                                                              resetSpentTime: (
                                                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                              mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                                              options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                method resetTimeEstimate

                                                                                                                                                                                                                                                                                                                                                                                                                resetTimeEstimate: (
                                                                                                                                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                  method show

                                                                                                                                                                                                                                                                                                                                                                                                                  show: (
                                                                                                                                                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                  mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                  options?: ShowMergeRequestOptions & BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                    method timeStats

                                                                                                                                                                                                                                                                                                                                                                                                                    timeStats: (
                                                                                                                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                    mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                    options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                      method unapprove

                                                                                                                                                                                                                                                                                                                                                                                                                      unapprove: (
                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                      mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                      options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                        method unsubscribe

                                                                                                                                                                                                                                                                                                                                                                                                                        unsubscribe: (
                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                        mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                        options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                          method version

                                                                                                                                                                                                                                                                                                                                                                                                                          version: (
                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                          mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                          versionId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                          options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                            method versions

                                                                                                                                                                                                                                                                                                                                                                                                                            versions: (
                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                            mergerequestIId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                              class Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                              class Namespaces extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                method all

                                                                                                                                                                                                                                                                                                                                                                                                                                all: (
                                                                                                                                                                                                                                                                                                                                                                                                                                options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method show

                                                                                                                                                                                                                                                                                                                                                                                                                                  show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  namespaceId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: { search?: string } & Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                    class NotificationSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                    class NotificationSettings extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      method all

                                                                                                                                                                                                                                                                                                                                                                                                                                      all: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId,
                                                                                                                                                                                                                                                                                                                                                                                                                                      groupId,
                                                                                                                                                                                                                                                                                                                                                                                                                                      ...options
                                                                                                                                                                                                                                                                                                                                                                                                                                      }: ({ projectId: string | number } | { groupId: string | number }) &
                                                                                                                                                                                                                                                                                                                                                                                                                                      PaginatedRequestOptions) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method edit

                                                                                                                                                                                                                                                                                                                                                                                                                                        edit: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId,
                                                                                                                                                                                                                                                                                                                                                                                                                                        groupId,
                                                                                                                                                                                                                                                                                                                                                                                                                                        ...options
                                                                                                                                                                                                                                                                                                                                                                                                                                        }: { level?: NotificationSettingLevel } & (
                                                                                                                                                                                                                                                                                                                                                                                                                                        | { projectId: string | number }
                                                                                                                                                                                                                                                                                                                                                                                                                                        | { groupId: string | number }
                                                                                                                                                                                                                                                                                                                                                                                                                                        ) &
                                                                                                                                                                                                                                                                                                                                                                                                                                        BaseRequestOptions) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          class Packages

                                                                                                                                                                                                                                                                                                                                                                                                                                          class Packages extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            method all

                                                                                                                                                                                                                                                                                                                                                                                                                                            all: (
                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                              remove: (
                                                                                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                              packageId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                packageId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method showFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                  showFiles: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  packageId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    class PagesDomains

                                                                                                                                                                                                                                                                                                                                                                                                                                                    class PagesDomains extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                      all: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...options
                                                                                                                                                                                                                                                                                                                                                                                                                                                      }?: { projectId?: string | number } & PaginatedRequestOptions) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                      import('../infrastructure').GetResponse
                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                        create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        domain: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                          edit: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          domain: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                            remove: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            domain: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                              show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              domain: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Pipelines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Pipelines extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  all: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method allVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    allVariables: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pipelineId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method cancel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cancel: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pipelineId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ref: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pipelineId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method retry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            retry: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pipelineId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pipelineId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method showJobs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showJobs: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pipelineId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: { scope: JobScope } & Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class PipelineSchedules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class PipelineSchedules extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    all: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      description: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ref: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cron: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        edit: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scheduleId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          remove: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scheduleId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scheduleId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method takeOwnership

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              takeOwnership: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scheduleId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class PipelineScheduleVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class PipelineScheduleVariables extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  all: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pipelineScheduleId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pipelineScheduleId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      edit: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pipelineScheduleId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      keyId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        remove: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pipelineScheduleId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keyId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pipelineScheduleId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keyId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ProjectAccessRequests

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ProjectAccessRequests extends ResourceAccessRequests {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ProjectBadges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ProjectBadges extends ResourceBadges {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ProjectCustomAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ProjectCustomAttributes extends ResourceCustomAttributes {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ProjectHooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ProjectHooks extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          add: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            all: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              edit: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hookId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              url: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                remove: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hookId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hookId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ProjectImportExport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ProjectImportExport extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method download

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      download: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method exportStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        exportStatus: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method import

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          import: (content: string, path: string, options?: Sudo) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method importStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            importStatus: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method schedule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              schedule: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ProjectIssueBoards

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ProjectIssueBoards extends ResourceIssueBoards {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ProjectMembers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ProjectMembers extends ResourceMembers {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ProjectMilestones

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ProjectMilestones extends ResourceMilestones {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Projects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Projects extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              all: (options?: PaginatedRequestOptions) => Promise<ProjectSchema[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method archive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                archive: (projectId: string | number, options?: Sudo) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  create: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  userId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }: { userId?: number } & BaseRequestOptions) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    edit: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method events

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      events: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: BaseRequestOptions & EventOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method fork

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fork: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { forkedFromId, ...options }?: { forkedFromId?: number } & BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method forks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          forks: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method languages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            languages: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method mirrorPull

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mirrorPull: (projectId: string | number, options?: Sudo) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                remove: (projectId: string | number, options?: Sudo) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method removeFork

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  removeFork: (projectId: string | number, options?: Sudo) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method search

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    search: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method share

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      share: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      groupId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      groupAccess: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<ProjectSchema>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method star

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          star: (projectId: string | number, options?: Sudo) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method statuses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            statuses: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sha: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            state: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method transfer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              transfer: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespaceId: string | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method unarchive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                unarchive: (projectId: string | number, options?: Sudo) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method unshare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  unshare: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  groupId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method unstar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unstar: (projectId: string | number, options?: Sudo) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method upload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      upload: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      content: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { metadata, sudo }?: { metadata?: UploadMetadata } & Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ProjectSnippetAwardEmojis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ProjectSnippetAwardEmojis extends ResourceAwardEmojis {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ProjectSnippetDiscussions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ProjectSnippetDiscussions extends ResourceDiscussions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ProjectSnippetNotes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ProjectSnippetNotes extends ResourceNotes {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ProjectSnippets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ProjectSnippets extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      all: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        content: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        snippetId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          title: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fileName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          code: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          visibility: SnippetVisibility,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            edit: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            snippetId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              remove: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              snippetId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                snippetId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method userAgentDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  userAgentDetails: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  snippetId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ProjectVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ProjectVariables extends ResourceVariables {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(options: BaseServiceOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ProtectedBranches

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ProtectedBranches extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          all: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method protect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protect: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            branchName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              branchName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method unprotect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                unprotect: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                branchName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ProtectedTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ProtectedTags extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    all: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method protect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protect: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method unprotect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unprotect: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class PushRules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class PushRules extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                edit: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  remove: (projectId: string | number, options?: Sudo) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<import('../infrastructure').GetResponse>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class ReleaseLinks extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        all: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            edit: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            linkId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: Sudo & ({ name: string } | { url: string })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              remove: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              linkId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                linkId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Releases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Releases extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    all: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: PaginatedRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        edit: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          remove: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Repositories

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Repositories extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method compare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                compare: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                from: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                to: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method contributors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  contributors: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method mergeBase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mergeBase: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    refs: string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method showArchive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      showArchive: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: { sha: string } & Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method showBlob

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        showBlob: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sha: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method showBlobRaw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          showBlobRaw: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sha: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method tree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tree: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class RepositoryFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class RepositoryFiles extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                filePath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                branch: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                content: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                commitMessage: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  edit: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  filePath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  branch: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  content: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  commitMessage: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    remove: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filePath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    branch: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    commitMessage: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      filePath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ref: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<RepositoryFileSchema>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method showBlame

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        showBlame: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        filePath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method showRaw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          showRaw: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filePath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ref: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Runners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Runners extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              all: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }: { projectId: string | number } & PaginatedRequestOptions) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              import('../infrastructure').GetResponse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method allOwned

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                allOwned: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method disable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  disable: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  runnerId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    edit: (runnerId: number, options?: BaseRequestOptions) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enable: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      runnerId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method jobs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        jobs: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        runnerId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          remove: (runnerId: number, options?: Sudo) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            runnerId: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<import('../infrastructure').GetResponse>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Search extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                all: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scope: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                search: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                groupId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectId?: string | number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                groupId?: string | number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } & BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Services

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Services extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    edit: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    serviceName: SupportedService,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: BaseRequestOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      remove: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serviceName: SupportedService,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<object>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        show: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectId: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        serviceName: SupportedService,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: Sudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<import('../infrastructure').GetResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class SidekiqMetrics

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class SidekiqMetrics extends BaseService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method compoundMetrics

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            compoundMetrics: (