gitlab

gitlab

Version 14.2.2
Published 4 years ago
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

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>;

method createLDAPLink

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>;

method removeLDAPLink

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>;

method link

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>;

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>;

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

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

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: () => Promise<import('../infrastructure').GetResponse>;

method jobStats

jobStats: () => Promise<import('../infrastructure').GetResponse>;

method processMetrics

processMetrics: () => Promise<import('../infrastructure').GetResponse>;

method queueMetrics

queueMetrics: () => Promise<import('../infrastructure').GetResponse>;

class Snippets

class Snippets extends BaseService {}

method all

all: ({
    public: p,
    ...options
}: { public: boolean } & PaginatedRequestOptions) => Promise<
    import('../infrastructure').GetResponse
>;

method content

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

method create

create: (
    title: string,
    fileName: string,
    content: string,
    visibility: SnippetVisibility,
    options?: BaseRequestOptions
) => Promise<object>;

method edit

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

method remove

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

method show

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

method userAgentDetails

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

class SystemHooks

class SystemHooks extends BaseService {}

method add

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

method all

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

method edit

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

method remove

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

class Tags

class Tags 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 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 Todos

class Todos extends BaseService {}

method all

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

method create

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

method done

done: ({ todoId, ...options }: { todoId?: number } & Sudo) => Promise<object>;

class Triggers

class Triggers extends BaseService {}

method add

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

method all

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

method edit

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

method pipeline

pipeline: (
    projectId: string | number,
    ref: string,
    token: string,
    { sudo, ...options }?: BaseRequestOptions
) => Promise<object>;

method remove

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

method show

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

class UserCustomAttributes

class UserCustomAttributes extends ResourceCustomAttributes {}

constructor

constructor(options: BaseServiceOptions);

class UserEmails

class UserEmails extends BaseService {}

method add

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

method all

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

method remove

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

method show

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

class UserGPGKeys

class UserGPGKeys extends BaseService {}

method add

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

method all

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

method remove

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

method show

show: (
    keyId: number,
    { userId, ...options }?: { userId?: number } & BaseRequestOptions
) => Promise<import('../infrastructure').GetResponse>;

class UserImpersonationTokens

class UserImpersonationTokens extends BaseService {}

method add

add: (
    userId: number,
    name: string,
    scopes: ImpersonationTokenScope,
    expiresAt: string,
    options?: Sudo
) => Promise<object>;

method all

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

method revoke

revoke: (userId: number, tokenId: number, options?: Sudo) => Promise<object>;

method show

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

class UserKeys

class UserKeys extends BaseService {}

method all

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

method create

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

method remove

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

method show

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

class Users

class Users extends BaseService {}

method activities

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

method all

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

method block

block: (userId: number, options?: Sudo) => Promise<object>;

method create

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

method current

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

method edit

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

method events

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

method projects

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

method remove

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

method search

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

method show

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

method unblock

unblock: (userId: number, options?: Sudo) => Promise<object>;

class Version

class Version extends BaseService {}

method show

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

class VulnerabilityFindings

class VulnerabilityFindings extends BaseService {}

method all

all: (
    projectId: string | number,
    options?: {
        id: string | number;
        reportType: string[];
        scope: string;
        severity: string[];
        confidence: string[];
        pipelineId: string | number;
    } & PaginatedRequestOptions
) => Promise<import('../infrastructure').GetResponse>;

class Wikis

class Wikis 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,
    slug: string,
    options?: BaseRequestOptions
) => Promise<object>;

method remove

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

method show

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

Interfaces

interface AcceptMergeRequestOptions

interface AcceptMergeRequestOptions {}

property merge_commit_message

merge_commit_message?: string;

property merge_when_pipeline_succeeds

merge_when_pipeline_succeeds?: boolean;

property sha

sha?: string;

property should_remove_source_branch

should_remove_source_branch?: boolean;

property squash

squash?: boolean;

property squash_commit_message

squash_commit_message?: string;

interface ArtifactSchema

interface ArtifactSchema {}

property file_format

file_format?: string;

property file_type

file_type: string;

property filename

filename: string;

property size

size: number;

interface CommitSchema

interface CommitSchema {}

property author_email

author_email: string;

property author_name

author_name: string;

property authored_date

authored_date?: Date;

property committed_date

committed_date?: Date;

property committer_email

committer_email?: string;

property committer_name

committer_name?: string;

property created_at

created_at: Date;

property id

id: string;

property message

message: string;

property parent_ids

parent_ids?: string[];

property short_id

short_id: string;

property title

title: string;

interface CreateMergeRequestOptions

interface CreateMergeRequestOptions {}

property allow_collaboration

allow_collaboration?: boolean;

property allow_maintainer_to_push

allow_maintainer_to_push?: boolean;

property assignee_id

assignee_id?: number;

property description

description?: string;

property labels

labels?: string;

property milestone_id

milestone_id?: number;

property remove_source_branch

remove_source_branch?: boolean;

property squash

squash?: boolean;

property target_project_id

target_project_id?: number;

interface Deployable

interface Deployable {}

property commit

commit?: CommitSchema;

property coverage

coverage?: string;

property created_at

created_at?: Date;

property finished_at

finished_at?: Date;

property id

id: number;

property name

name: string;

property pipeline

pipeline?: PipelineSchema;

property ref

ref: string;

property runner

runner?: RunnerSchema;

property stage

stage?: string;

property started_at

started_at?: Date;

property status

status?: DeploymentStatus;

property tag

tag: boolean;

property user

user?: UserSchema;

interface DeploymentSchema

interface DeploymentSchema {}

property id

id: number;

property iid

iid: number;

property ref

ref: string;

property sha

sha: string;

property user

user: UserSchema;

interface EnvironmentDetailSchema

interface EnvironmentDetailSchema extends EnvironmentSchema {}

property deployable

deployable?: DeploymentSchema;

property last_deployment

last_deployment?: DeploymentSchema;

interface EnvironmentSchema

interface EnvironmentSchema {}

property external_url

external_url?: string;

property id

id: number;

property name

name: string;

property project

project?: ProjectSchema;

property slug

slug?: string;

property state

state?: string;

interface EventOptions

interface EventOptions {}

property action

action?:
    | 'created'
    | 'updated'
    | 'closed'
    | 'reopened'
    | 'pushed'
    | 'commented'
    | 'merged'
    | 'joined'
    | 'left'
    | 'destroyed'
    | 'expired';

property targetType

targetType?:
    | 'issue'
    | 'milestone'
    | 'merge_request'
    | 'note'
    | 'project'
    | 'snippet'
    | 'user';

interface GroupDetailSchema

interface GroupDetailSchema extends GroupSchema {}

property projects

projects: ProjectSchema[];

property runners_token

runners_token: string;

property shared_projects

shared_projects: ProjectSchema[];

interface GroupSchema

interface GroupSchema {}

property auto_devops_enabled

auto_devops_enabled?: boolean;

property avatar_url

avatar_url: string;

property description

description: string;

property emails_disabled

emails_disabled?: boolean;

property full_name

full_name: string;

property full_path

full_path: string;

property id

id: number;

property lfs_enabled

lfs_enabled: boolean;

property name

name: string;

property parent_id

parent_id?: number;

property path

path: string;

property project_creation_level

project_creation_level: string;

property request_access_enabled

request_access_enabled: boolean;

property require_two_factor_authentication

require_two_factor_authentication: boolean;

property share_with_group_lock

share_with_group_lock: boolean;

property subgroup_creation_level

subgroup_creation_level: string;

property two_factor_grace_period

two_factor_grace_period: number;

property visibility

visibility: string;

property web_url

web_url: string;

interface JobSchema

interface JobSchema {}

property allow_failure

allow_failure: boolean;

property artifacts

artifacts: ArtifactSchema[];

property artifacts_expire_at

artifacts_expire_at?: Date;

property commit

commit: CommitSchema;

property coverage

coverage?: string;

property created_at

created_at: Date;

property duration

duration?: number;

property finished_at

finished_at?: Date;

property id

id: number;

property name

name: string;

property pipeline

pipeline: PipelineSchema;

property ref

ref: string;

property runner

runner: RunnerSchema;

property stage

stage: string;

property started_at

started_at?: Date;

property status

status: string;

property tag

tag: boolean;

property user

user: UserSchema;

property web_url

web_url: string;

interface NamespaceInfoSchema

interface NamespaceInfoSchema {}

property avatar_url

avatar_url: string;

property full_path

full_path: string;

property id

id: number;

property kind

kind: string;

property name

name: string;

property parent_id

parent_id?: number;

property path

path: string;

property web_url

web_url: string;

interface PipelineSchema

interface PipelineSchema {}

property created_at

created_at: Date;

property id

id: number;

property ref

ref: string;

property sha

sha: string;

property status

status: string;

property updated_at

updated_at: Date;

property web_url

web_url: string;

interface ProjectSchema

interface ProjectSchema {}

property archived

archived: boolean;

property auto_cancel_pending_pipelines

auto_cancel_pending_pipelines?: string;

property auto_devops_deploy_strategy

auto_devops_deploy_strategy: string;

property auto_devops_enabled

auto_devops_enabled: boolean;

property avatar_url

avatar_url: string;

property build_coverage_regex

build_coverage_regex?: string;

property build_timeout

build_timeout: number;

property builds_access_level

builds_access_level: string;

property ci_config_path

ci_config_path?: string;

property ci_default_git_depth

ci_default_git_depth: number;

property container_registry_enabled

container_registry_enabled: boolean;

property created_at

created_at: Date;

property creator_id

creator_id: number;

property default_branch

default_branch: string;

property description

description: string;

property empty_repo

empty_repo: boolean;

property forks_count

forks_count: number;

property http_url_to_repo

http_url_to_repo: string;

property id

id: number;

property import_status

import_status: string;

property issues_access_level

issues_access_level: string;

property issues_enabled

issues_enabled: boolean;

property jobs_enabled

jobs_enabled: boolean;

property last_activity_at

last_activity_at: Date;

property lfs_enabled

lfs_enabled: boolean;

property merge_method

merge_method: string;

property merge_requests_access_level

merge_requests_access_level: string;

property merge_requests_enabled

merge_requests_enabled: boolean;

property name

name: string;

property name_with_namespace

name_with_namespace: string;

property namespace

namespace: NamespaceInfoSchema;

property only_allow_merge_if_all_discussions_are_resolved

only_allow_merge_if_all_discussions_are_resolved: boolean;

property only_allow_merge_if_pipeline_succeeds

only_allow_merge_if_pipeline_succeeds: boolean;

property open_issues_count

open_issues_count: number;

property owner

owner: UserSchema;

property path

path: string;

property path_with_namespace

path_with_namespace: string;

property printing_merge_request_link_enabled

printing_merge_request_link_enabled: boolean;

property public_jobs

public_jobs: boolean;

property readme_url

readme_url: string;

property remove_source_branch_after_merge

remove_source_branch_after_merge: boolean;

property repository_access_level

repository_access_level: string;

property request_access_enabled

request_access_enabled: boolean;

property resolve_outdated_diff_discussions

resolve_outdated_diff_discussions: boolean;

property shared_runners_enabled

shared_runners_enabled: boolean;

property shared_with_groups

shared_with_groups: GroupSchema[];

property snippets_access_level

snippets_access_level: string;

property snippets_enabled

snippets_enabled: boolean;

property ssh_url_to_repo

ssh_url_to_repo: string;

property star_count

star_count: number;

tag_list: string[];

property visibility

visibility: string;

property web_url

web_url: string;

property wiki_access_level

wiki_access_level: string;

property wiki_enabled

wiki_enabled: boolean;

interface RepositoryFileSchema

interface RepositoryFileSchema {}

property blob_id

blob_id: string;

property commit_id

commit_id: string;

property content

content: string;

property content_sha256

content_sha256: string;

property encoding

encoding: string;

property file_name

file_name: string;

property file_path

file_path: string;

property last_commit_id

last_commit_id: string;

property ref

ref: string;

property size

size: number;

interface ResourceVariableSchema

interface ResourceVariableSchema {}

property key

key: string;

property value

value: string;

property variable_type

variable_type: 'env_var' | 'file';

interface RunnerSchema

interface RunnerSchema {}

property active

active: boolean;

property description

description: string;

property id

id: number;

property ip_address

ip_address: string;

property is_shared

is_shared: boolean;

property name

name: string;

property online

online: boolean;

property status

status: string;

interface ShowMergeRequestOptions

interface ShowMergeRequestOptions {}

property include_diverged_commits_count

include_diverged_commits_count?: true;

property include_rebase_in_progress

include_rebase_in_progress?: boolean;

property render_html

render_html?: boolean;

interface UpdateMergeRequestOptions

interface UpdateMergeRequestOptions {}

property allow_collaboration

allow_collaboration?: boolean;

property allow_maintainer_to_push

allow_maintainer_to_push?: boolean;

property assignee_id

assignee_id?: number;

property description

description?: string;

property discussion_locked

discussion_locked?: boolean;

property labels

labels?: string;

property milestone_id

milestone_id?: number;

property remove_source_branch

remove_source_branch?: boolean;

property squash

squash?: boolean;

property state_event

state_event?: string;

property target_branch

target_branch?: number;

property title

title?: string;

interface UploadMetadata

interface UploadMetadata {}

property contentType

contentType?: string;

property filename

filename?: string;

interface UserDetailSchema

interface UserDetailSchema extends UserSchema {}

property bio

bio?: string;

property created_at

created_at: Date;

property linkedin

linkedin: string;

property location

location?: string;

property organization

organization?: string;

property public_email

public_email: string;

property skype

skype: string;

property twitter

twitter: string;

property website_url

website_url?: string;

interface UserSchema

interface UserSchema {}

property avatar_url

avatar_url: string;

property id

id: number;

property name

name: string;

property state

state: string;

property username

username: string;

property web_url

web_url: string;

Type Aliases

type AccessLevel

type AccessLevel = 10 | 20 | 30 | 40 | 50;

type DeploymentStatus

type DeploymentStatus = 'created' | 'running' | 'success' | 'failed' | 'canceled';

type Gitlab

type Gitlab = InstanceType<typeof Gitlab>;

type GroupId

type GroupId = string | number;

type GroupProjectId

type GroupProjectId = string | number;

type GroupsBundle

type GroupsBundle = InstanceType<typeof GroupsBundle>;

type JobScope

type JobScope =
    | 'created'
    | 'pending'
    | 'running'
    | 'failed'
    | 'success'
    | 'canceled'
    | 'skipped'
    | 'manual';

type KeyId

type KeyId = string;

type NamespaceId

type NamespaceId = string | number;

type ProjectId

type ProjectId = string | number;

type ProjectsBundle

type ProjectsBundle = InstanceType<typeof ProjectsBundle>;

type ResourceId

type ResourceId = string | number;

type SnippetVisibility

type SnippetVisibility = 'private' | 'public' | 'internal';

type SupportedService

type SupportedService =
    | 'asana'
    | 'assembla'
    | 'bamboo'
    | 'bugzilla'
    | 'buildkite'
    | 'campfire'
    | 'custom-issue-tracker'
    | 'drone-ci'
    | 'emails-on-push'
    | 'external-wiki'
    | 'flowdock'
    | 'hangouts_chat'
    | 'hipchat'
    | 'irker'
    | 'jira'
    | 'kubernetes'
    | 'slack-slash-commands'
    | 'slack'
    | 'packagist'
    | 'pipelines-email'
    | 'pivotaltracker'
    | 'prometheus'
    | 'pushover'
    | 'redmine'
    | 'microsoft-teams'
    | 'mattermost'
    | 'mattermost-slash-commands'
    | 'teamcity'
    | 'jenkins'
    | 'jenkins-deprecated'
    | 'mock-ci';

type UsersBundle

type UsersBundle = InstanceType<typeof UsersBundle>;

Package Files (93)

Dependencies (9)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/gitlab.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/gitlab)

HTML

<a href="https://www.jsdocs.io/package/gitlab"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 year ago.
Package analyzed in 10897 ms.
Missing or incorrect documentation? Open an issue for this package.