@gitbeaker/core 34.4.0 → 34.4.1

package/dist/types/resources/GroupMembers.d.ts

@@ -0,0 +1,14 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceMembers } from '../templates';
+import { MemberSchema, AccessLevel, IncludeInherited } from '../templates/types';
+import { BaseRequestOptions, PaginatedRequestOptions, CamelizedRecord, Sudo } from '../infrastructure';
+export interface GroupMembers<C extends boolean = false> extends ResourceMembers<C> {
+    add(groupId: string | number, userId: number, accessLevel: AccessLevel, options?: BaseRequestOptions): Promise<CamelizedRecord<C, MemberSchema>>;
+    all(groupId: string | number, options?: IncludeInherited & PaginatedRequestOptions): Promise<CamelizedRecord<C, MemberSchema>[]>;
+    edit(groupId: string | number, userId: number, accessLevel: AccessLevel, options?: BaseRequestOptions): Promise<CamelizedRecord<C, MemberSchema>>;
+    show(groupId: string | number, userId: number, options?: IncludeInherited & Sudo): Promise<CamelizedRecord<C, MemberSchema>>;
+    remove(groupId: string | number, userId: number, options?: Sudo): Promise<void>;
+}
+export declare class GroupMembers<C extends boolean = false> extends ResourceMembers<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

package/dist/types/resources/GroupMilestones.d.ts

@@ -0,0 +1,17 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceMilestones } from '../templates';
+import { MilestoneSchema } from '../templates/types';
+import { PaginatedRequestOptions, BaseRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+import { IssueSchema } from './Issues';
+import { MergeRequestSchema } from './MergeRequests';
+export interface GroupMilestones<C extends boolean = false> extends ResourceMilestones<C> {
+    all(groupId: string | number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, MilestoneSchema>[]>;
+    create(groupId: string | number, title: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, MilestoneSchema>>;
+    edit(groupId: string | number, milestoneId: number, options?: BaseRequestOptions): Promise<CamelizedRecord<C, MilestoneSchema>>;
+    issues(groupId: string | number, milestoneId: number, options?: Sudo): Promise<CamelizedRecord<C, IssueSchema>[]>;
+    mergeRequests(groupId: string | number, milestoneId: number, options?: Sudo): Promise<CamelizedRecord<C, MergeRequestSchema>[]>;
+    show(groupId: string | number, milestoneId: number, options?: Sudo): Promise<CamelizedRecord<C, MilestoneSchema>>;
+}
+export declare class GroupMilestones<C extends boolean = false> extends ResourceMilestones<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

package/dist/types/resources/GroupRunners.d.ts

@@ -0,0 +1,6 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { PaginatedRequestOptions, ShowExpanded } from '../infrastructure';
+import { RunnerSchema } from './Runners';
+export declare class GroupRunners<C extends boolean = false> extends BaseResource<C> {
+    all(groupId: string | number, options?: PaginatedRequestOptions & ShowExpanded): Promise<import("../infrastructure").CamelizedRecord<C, RunnerSchema>[] | import("../infrastructure").CamelizedRecord<C, RunnerSchema>[] | import("../infrastructure").PaginationResponse<import("../infrastructure").CamelizedRecord<C, RunnerSchema>[]>>;
+}

package/dist/types/resources/GroupVariables.d.ts

@@ -0,0 +1,14 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceVariables } from '../templates';
+import { VariableSchema } from '../templates/types';
+import { PaginatedRequestOptions, BaseRequestOptions, CamelizedRecord } from '../infrastructure';
+export interface GroupVariables<C extends boolean = false> extends ResourceVariables<C> {
+    all(groupId: string | number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, VariableSchema>[]>;
+    create(groupId: string | number, options?: BaseRequestOptions): Promise<CamelizedRecord<C, VariableSchema>>;
+    edit(groupId: string | number, key: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, VariableSchema>>;
+    show(groupId: string | number, key: string, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, VariableSchema>>;
+    remove(groupId: string | number, key: string, options?: PaginatedRequestOptions): Promise<void>;
+}
+export declare class GroupVariables<C extends boolean = false> extends ResourceVariables<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

package/dist/types/resources/Groups.d.ts

@@ -0,0 +1,67 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions, ShowExpanded, Sudo } from '../infrastructure';
+import { ProjectSchema } from './Projects';
+export interface GroupSchema extends Record<string, unknown> {
+    id: number;
+    name: string;
+    path: string;
+    full_name: string;
+    full_path: string;
+    parent_id: number;
+    visibility: string;
+    avatar_url: string;
+    web_url: string;
+    description: string;
+    share_with_group_lock: boolean;
+    require_two_factor_authentication: boolean;
+    two_factor_grace_period: number;
+    project_creation_level: string;
+    auto_devops_enabled: boolean;
+    subgroup_creation_level: string;
+    emails_disabled: boolean;
+    mentions_disabled: boolean;
+    lfs_enabled: boolean;
+    default_branch_protection: number;
+    request_access_enabled: boolean;
+    file_template_project_id: number;
+    created_at: string;
+}
+export declare type GroupDetailSchema = {
+    id: number;
+    name: string;
+    path: string;
+    full_name: string;
+    full_path: string;
+    parent_id: number;
+    visibility: string;
+    avatar_url: string;
+    web_url: string;
+    description: string;
+    request_access_enabled: boolean;
+    file_template_project_id: number;
+    runners_token: string;
+    shared_with_groups: {
+        group_id: number;
+        group_name: string;
+        group_full_path: string;
+        group_access_level: number;
+        expires_at: string;
+    }[];
+    created_at: string;
+};
+export declare class Groups<C extends boolean = false> extends BaseResource<C> {
+    all(options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, GroupSchema>[]>;
+    create(name: string, path: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, GroupSchema>>;
+    createLDAPLink(groupId: string | number, cn: string, groupAccess: number, provider: string, options?: Sudo & ShowExpanded): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>> | import("../infrastructure").ExpandedResponse<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>>;
+    edit(groupId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, GroupSchema>>;
+    projects(groupId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectSchema>[]>;
+    remove(groupId: string | number, options?: Sudo & ShowExpanded): Promise<void>;
+    removeLDAPLink(groupId: string | number, cn: string, { provider, ...options }?: Sudo & ShowExpanded & {
+        provider?: string;
+    }): Promise<void>;
+    search(nameOrPath: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    show(groupId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, GroupDetailSchema>>;
+    subgroups(groupId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    syncLDAP(groupId: string | number, options?: Sudo & ShowExpanded): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>> | import("../infrastructure").ExpandedResponse<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>>;
+    transferProject(groupId: string | number, projectId: string | number, options?: BaseRequestOptions & ShowExpanded): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>> | import("../infrastructure").ExpandedResponse<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>>;
+}

package/dist/types/resources/IssueAwardEmojis.d.ts

@@ -0,0 +1,13 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceAwardEmojis } from '../templates';
+import { AwardEmojiSchema } from '../templates/types';
+import { PaginatedRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface IssueAwardEmojis<C extends boolean = false> extends ResourceAwardEmojis<C> {
+    all(projectId: string | number, issueIId: number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, AwardEmojiSchema>[]>;
+    award(projectId: string | number, issueIId: number, name: string, options?: Sudo): Promise<CamelizedRecord<C, AwardEmojiSchema>>;
+    remove(projectId: string | number, issueIId: number, awardId: number, options?: Sudo): Promise<void>;
+    show(projectId: string | number, issueIId: number, awardId: number, options?: Sudo): Promise<CamelizedRecord<C, AwardEmojiSchema>>;
+}
+export declare class IssueAwardEmojis<C extends boolean = false> extends ResourceAwardEmojis<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

package/dist/types/resources/IssueDiscussions.d.ts

@@ -0,0 +1,17 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceDiscussions } from '../templates';
+import { DiscussionSchema } from '../templates/types';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface IssueDiscussions<C extends boolean = false> extends ResourceDiscussions<C> {
+    addNote(projectId: string | number, issueIId: number, discussionId: number, noteId: number, body: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, DiscussionSchema>>;
+    all(projectId: string | number, issueIId: number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, DiscussionSchema>[]>;
+    create(projectId: string | number, issueIId: number, body: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, DiscussionSchema>>;
+    editNote(projectId: string | number, issueIId: number, discussionId: number, noteId: number, options: BaseRequestOptions & {
+        body: string;
+    }): Promise<CamelizedRecord<C, DiscussionSchema>>;
+    removeNote(projectId: string | number, issueIId: number, discussionId: number, noteId: number, options?: Sudo): Promise<void>;
+    show(projectId: string | number, issueIId: number, discussionId: number, options?: Sudo): Promise<CamelizedRecord<C, DiscussionSchema>>;
+}
+export declare class IssueDiscussions<C extends boolean = false> extends ResourceDiscussions<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

package/dist/types/resources/IssueNoteAwardEmojis.d.ts

@@ -0,0 +1,13 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceNoteAwardEmojis } from '../templates';
+import { AwardEmojiSchema } from '../templates/types';
+import { PaginatedRequestOptions, CamelizedRecord, Sudo } from '../infrastructure';
+export interface IssueNoteAwardEmojis<C extends boolean = false> extends ResourceNoteAwardEmojis<C> {
+    all(projectId: string | number, issueIId: number, noteId: number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, AwardEmojiSchema>[]>;
+    award(projectId: string | number, issueIId: number, noteId: number, name: string, options?: Sudo): Promise<CamelizedRecord<C, AwardEmojiSchema>>;
+    remove(projectId: string | number, issueIId: number, noteId: number, awardId: number, options?: Sudo): Promise<void>;
+    show(projectId: string | number, issueIId: number, noteId: number, awardId: number, options?: Sudo): Promise<CamelizedRecord<C, AwardEmojiSchema>>;
+}
+export declare class IssueNoteAwardEmojis<C extends boolean = false> extends ResourceNoteAwardEmojis<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

package/dist/types/resources/IssueNotes.d.ts

@@ -0,0 +1,22 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceNotes } from '../templates';
+import { NoteSchema } from '../templates/types';
+import { PaginatedRequestOptions, BaseRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface IssueNoteSchema extends NoteSchema {
+    attachment?: string;
+    system: boolean;
+    noteable_id: number;
+    noteable_type: string;
+    noteable_iid: number;
+    resolvable: boolean;
+}
+export interface IssueNotes<C extends boolean = false> extends ResourceNotes<C> {
+    all(projectId: string | number, issueIId: number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, IssueNoteSchema>[]>;
+    create(projectId: string | number, issueIId: number, body: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, IssueNoteSchema>>;
+    edit(projectId: string | number, issueIId: number, noteId: number, body: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, IssueNoteSchema>>;
+    remove(projectId: string | number, issueIId: number, noteId: number, options?: Sudo): Promise<void>;
+    show(projectId: string | number, issueIId: number, noteId: number, options?: Sudo): Promise<CamelizedRecord<C, IssueNoteSchema>>;
+}
+export declare class IssueNotes<C extends boolean = false> extends ResourceNotes<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

package/dist/types/resources/Issues.d.ts

@@ -0,0 +1,109 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { MergeRequestSchema } from './MergeRequests';
+import { MilestoneSchema } from '../templates/types';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface TimeStatsSchema extends Record<string, unknown> {
+    time_estimate: number;
+    total_time_spent: number;
+    human_time_estimate: string;
+    human_total_time_spent: string;
+}
+export interface IssueLinkSchema extends Record<string, unknown> {
+    id: number;
+    iid: number;
+    project_id: number;
+    issue_link_id: number;
+    state: string;
+    description: string;
+    weight?: number;
+    author: Omit<UserSchema, 'created_at'>;
+    milestone: MilestoneSchema;
+    assignees?: Omit<UserSchema, 'created_at'>[];
+    title: string;
+    labels?: string[];
+    user_notes_count: number;
+    due_date: string;
+    web_url: string;
+    confidential: boolean;
+    updated_at: string;
+    link_type: 'relates_to' | 'blocks' | 'is_blocked_by';
+    link_created_at: string;
+    link_updated_at: string;
+}
+export interface IssueSchema extends Record<string, unknown> {
+    state: string;
+    description: string;
+    weight?: number;
+    health_status?: string;
+    author: Omit<UserSchema, 'created_at'>;
+    milestone: MilestoneSchema;
+    project_id: number;
+    assignees?: Omit<UserSchema, 'created_at'>[];
+    updated_at: string;
+    closed_at?: string;
+    closed_by?: string;
+    id: number;
+    title: string;
+    created_at: string;
+    moved_to_id?: string;
+    iid: number;
+    labels?: string[];
+    upvotes: number;
+    downvotes: number;
+    merge_requests_count: number;
+    user_notes_count: number;
+    due_date: string;
+    web_url: string;
+    references: {
+        short: string;
+        relative: string;
+        full: string;
+    };
+    time_stats: TimeStatsSchema;
+    has_tasks: boolean;
+    task_status: string;
+    confidential: boolean;
+    discussion_locked: boolean;
+    _links: {
+        self: string;
+        notes: string;
+        award_emoji: string;
+        project: string;
+    };
+    task_completion_status: {
+        count: number;
+        completed_count: number;
+    };
+    subscribed: boolean;
+    epic?: {
+        id: number;
+        iid: number;
+        title: string;
+        url: string;
+        group_id: number;
+    };
+}
+export declare class Issues<C extends boolean = false> extends BaseResource<C> {
+    addSpentTime(projectId: string | number, issueIid: number, duration: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TimeStatsSchema>>;
+    addTimeEstimate(projectId: string | number, issueIid: number, duration: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TimeStatsSchema>>;
+    all({ projectId, groupId, ...options }?: {
+        projectId?: string | number;
+        groupId?: string | number;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Omit<IssueSchema, "epic">>[]>;
+    create(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, IssueSchema>>;
+    closedBy(projectId: string | number, issueIid: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>[]>;
+    edit(projectId: string | number, issueIid: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, IssueSchema>>;
+    link(projectId: string | number, issueIId: number, targetProjectId: string | number, targetIssueIId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, IssueLinkSchema>>;
+    links(projectId: string | number, issueIid: number): Promise<import("../infrastructure").CamelizedRecord<C, IssueLinkSchema>[]>;
+    participants(projectId: string | number, issueIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Omit<UserSchema, "created_at">>>;
+    relatedMergeRequests(projectId: string | number, issueIid: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>>;
+    removeLink(projectId: string | number, issueIid: number, issueLinkId: string | number, options?: BaseRequestOptions): Promise<void>;
+    remove(projectId: string | number, issueIid: number, options?: Sudo): Promise<void>;
+    resetSpentTime(projectId: string | number, issueIid: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, TimeStatsSchema>>;
+    resetTimeEstimate(projectId: string | number, issueIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TimeStatsSchema>>;
+    show(projectId: string | number, issueIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, IssueSchema>>;
+    subscribe(projectId: string | number, issueIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, IssueSchema>>;
+    timeStats(projectId: string | number, issueIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TimeStatsSchema>>;
+    unsubscribe(projectId: string | number, issueIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, IssueSchema>>;
+}

package/dist/types/resources/IssuesStatistics.d.ts

@@ -0,0 +1,17 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions } from '../infrastructure';
+export interface StatisticsSchema extends Record<string, unknown> {
+    statistics: {
+        counts: {
+            all: number;
+            closed: number;
+            opened: number;
+        };
+    };
+}
+export declare class IssuesStatistics<C extends boolean = false> extends BaseResource<C> {
+    all({ projectId, groupId, ...options }?: {
+        projectId?: string | number;
+        groupId?: string | number;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, StatisticsSchema>>;
+}

package/dist/types/resources/Jobs.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+import { CommitSchema } from './Commits';
+import { RunnerSchema } from './Runners';
+import { UserSchema } from './Users';
+import { PipelineSchema } from './Pipelines';
+export declare type JobScope = 'created' | 'pending' | 'running' | 'failed' | 'success' | 'canceled' | 'skipped' | 'manual';
+export interface ArtifactSchema extends Record<string, unknown> {
+    file_type: string;
+    size: number;
+    filename: string;
+    file_format?: string;
+}
+export interface JobSchema extends Record<string, unknown> {
+    id: number;
+    status: string;
+    stage: string;
+    name: string;
+    ref: string;
+    tag: boolean;
+    coverage?: string;
+    allow_failure: boolean;
+    created_at: Date;
+    started_at?: Date;
+    finished_at?: Date;
+    duration?: number;
+    user: UserSchema;
+    commit: CommitSchema;
+    pipeline: PipelineSchema;
+    web_url: string;
+    artifacts: ArtifactSchema[];
+    runner: RunnerSchema;
+    artifacts_expire_at?: Date;
+    tag_list?: string[];
+}
+export interface BridgeSchema extends Record<string, unknown> {
+    commit: Pick<CommitSchema, 'id' | 'short_id' | 'author_name' | 'author_email' | 'message' | 'title' | 'created_at'>;
+    coverage?: string;
+    allow_failure: boolean;
+    created_at: string;
+    started_at: string;
+    finished_at: string;
+    duration: number;
+    queued_duration: number;
+    id: number;
+    name: string;
+    pipeline: Omit<PipelineSchema & {
+        project_id: number;
+    }, 'user'>;
+    ref: string;
+    stage: string;
+    status: string;
+    tag: boolean;
+    web_url: string;
+    user: UserSchema;
+    downstream_pipeline: Omit<PipelineSchema, 'user'>;
+}
+export declare class Jobs<C extends boolean = false> extends BaseResource<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>[]>;
+    cancel(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>>;
+    downloadSingleArtifactFile(projectId: string | number, jobId: number, artifactPath: string, { stream, ...options }?: {
+        stream?: boolean;
+    } & BaseRequestOptions): NodeJS.ReadableStream | Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    downloadSingleArtifactFileFromRef(projectId: string | number, ref: string, artifactPath: string, jobName: string, { stream, ...options }?: {
+        stream?: boolean;
+    } & BaseRequestOptions): NodeJS.ReadableStream | Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    downloadLatestArtifactFile(projectId: string | number, ref: string, jobName: string, { stream, ...options }?: {
+        stream?: boolean;
+    } & BaseRequestOptions): NodeJS.ReadableStream | Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    downloadTraceFile(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    erase(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>>;
+    eraseArtifacts(projectId: string | number, jobId: number, options?: Sudo): Promise<void>;
+    keepArtifacts(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    play(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>>;
+    retry(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>>;
+    show(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>>;
+    showPipelineJobs(projectId: string | number, pipelineId: number, options?: {
+        scope?: JobScope;
+    } & Sudo): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>[]>;
+    showPipelineBridges(projectId: string | number, pipelineId: number, options?: {
+        scope?: JobScope;
+    } & Sudo): Promise<import("../infrastructure").CamelizedRecord<C, BridgeSchema>>;
+}

package/dist/types/resources/Keys.d.ts

@@ -0,0 +1,14 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { UserExtendedSchema } from './Users';
+import { Sudo } from '../infrastructure';
+export interface KeySchema extends Record<string, unknown> {
+    id: number;
+    title: string;
+    key: string;
+    created_at: string;
+    expires_at: string;
+    user: UserExtendedSchema;
+}
+export declare class Keys<C extends boolean = false> extends BaseResource<C> {
+    show(keyId: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, KeySchema>>;
+}

package/dist/types/resources/Labels.d.ts

@@ -0,0 +1,15 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions, CamelizedRecord, Sudo } from '../infrastructure';
+import { ResourceLabels } from '../templates';
+import { LabelSchema } from '../templates/types';
+export interface Labels<C extends boolean = false> extends ResourceLabels<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, LabelSchema>[]>;
+    create(projectId: string | number, labelName: string, color: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, LabelSchema>>;
+    edit(projectId: string | number, labelId: number | string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, LabelSchema>>;
+    remove(projectId: string | number, labelId: number | string, options?: Sudo): Promise<void>;
+    subscribe(projectId: string | number, labelId: number | string, options?: Sudo): Promise<CamelizedRecord<C, LabelSchema>>;
+    unsubscribe(projectId: string | number, labelId: number | string, options?: Sudo): Promise<CamelizedRecord<C, LabelSchema>>;
+}
+export declare class Labels<C extends boolean = false> extends ResourceLabels<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

package/dist/types/resources/License.d.ts

@@ -0,0 +1,28 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { Sudo } from '../infrastructure';
+export interface LicenseSchema extends Record<string, unknown> {
+    id: number;
+    plan: string;
+    created_at: string;
+    starts_at: string;
+    expires_at: string;
+    historical_max: number;
+    maximum_user_count: number;
+    expired: boolean;
+    overage: number;
+    user_limit: number;
+    active_users: number;
+    licensee: {
+        Name: string;
+    };
+    add_ons: {
+        GitLab_FileLocks: number;
+        GitLab_Auditor_User: number;
+    };
+}
+export declare class License<C extends boolean = false> extends BaseResource<C> {
+    add(license: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, LicenseSchema>>;
+    all(options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, LicenseSchema>[]>;
+    show(options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, LicenseSchema>>;
+    remove(licenceId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, LicenseSchema>>;
+}

package/dist/types/resources/LicenseTemplates.d.ts

@@ -0,0 +1,23 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceTemplates } from '../templates';
+import { PaginatedRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface LicenseTemplateSchema extends Record<string, unknown> {
+    key: string;
+    name: string;
+    nickname?: string;
+    featured: boolean;
+    html_url: string;
+    source_url: string;
+    description: string;
+    conditions?: string[];
+    permissions?: string[];
+    limitations?: string[];
+    content: string;
+}
+export interface LicenseTemplates<C extends boolean = false> extends ResourceTemplates<C> {
+    all(options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, LicenseTemplateSchema>[]>;
+    show(key: string | number, options?: Sudo): Promise<CamelizedRecord<C, LicenseTemplateSchema>>;
+}
+export declare class LicenseTemplates<C extends boolean = false> extends ResourceTemplates<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

package/dist/types/resources/Lint.d.ts

@@ -0,0 +1,10 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { Sudo } from '../infrastructure';
+export interface LintSchema extends Record<string, unknown> {
+    status: string;
+    errors?: string[];
+    warnings?: string[];
+}
+export declare class Lint<C extends boolean = false> extends BaseResource<C> {
+    lint(content: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, LintSchema>>;
+}

package/dist/types/resources/Markdown.d.ts

@@ -0,0 +1,11 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { Sudo } from '../infrastructure';
+export interface MarkdownSchema extends Record<string, unknown> {
+    html: string;
+}
+export declare class Markdown<C extends boolean = false> extends BaseResource<C> {
+    render(text: string, options?: {
+        gfm?: string;
+        project?: string | number;
+    } & Sudo): Promise<import("../infrastructure").CamelizedRecord<C, MarkdownSchema>>;
+}

package/dist/types/resources/MergeRequestApprovals.d.ts

@@ -0,0 +1,98 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, Sudo } from '../infrastructure';
+import { UserSchema } from './Users';
+import { GroupSchema } from './Groups';
+import { ProtectedBranchSchema } from './ProtectedBranches';
+export interface ProjectLevelMergeRequestApprovalSchema extends Record<string, unknown> {
+    approvals_before_merge: number;
+    reset_approvals_on_push: boolean;
+    disable_overriding_approvers_per_merge_request: boolean;
+    merge_requests_author_approval: boolean;
+    merge_requests_disable_committers_approval: boolean;
+    require_password_to_approve: boolean;
+}
+export interface ApprovedByEntity {
+    user: Pick<UserSchema, 'name' | 'username' | 'id' | 'state' | 'avatar_url' | 'web_url'>;
+}
+export interface MergeRequestLevelMergeRequestApprovalSchema extends Record<string, unknown> {
+    id: number;
+    iid: number;
+    project_id: number;
+    title: string;
+    description: string;
+    state: string;
+    created_at: string;
+    updated_at: string;
+    merge_status: string;
+    approvals_required: number;
+    approvals_left: number;
+    approved_by?: ApprovedByEntity[];
+}
+export declare type ApprovalRulesRequestOptions = {
+    userIds?: number[];
+    groupIds?: number[];
+    protectedBranchIds?: number[];
+};
+export interface ApprovalRuleSchema extends Record<string, unknown> {
+    id: number;
+    name: string;
+    rule_type: string;
+    eligible_approvers?: Pick<UserSchema, 'name' | 'username' | 'id' | 'state' | 'avatar_url' | 'web_url'>[];
+    approvals_required: number;
+    users?: Pick<UserSchema, 'name' | 'username' | 'id' | 'state' | 'avatar_url' | 'web_url'>[];
+    groups?: GroupSchema[];
+    contains_hidden_groups: boolean;
+    overridden: boolean;
+}
+export interface ProjectLevelApprovalRuleSchema extends ApprovalRuleSchema {
+    protected_branches?: ProtectedBranchSchema[];
+}
+export interface MergeRequestLevelApprovalRuleSchema extends ApprovalRuleSchema {
+    source_rule?: string;
+}
+export declare class MergeRequestApprovals<C extends boolean = false> extends BaseResource<C> {
+    configuration(projectId: string | number, options?: {
+        mergerequestIid?: undefined;
+    } & BaseRequestOptions): Promise<ProjectLevelMergeRequestApprovalSchema>;
+    configuration(projectId: string | number, options: {
+        mergerequestIid: number;
+    } & BaseRequestOptions): Promise<MergeRequestLevelMergeRequestApprovalSchema>;
+    editConfiguration(projectId: string | number, options?: {
+        mergerequestIid?: undefined;
+    } & BaseRequestOptions): Promise<ProjectLevelMergeRequestApprovalSchema>;
+    editConfiguration(projectId: string | number, options: {
+        mergerequestIid: number;
+    } & BaseRequestOptions): Promise<MergeRequestLevelMergeRequestApprovalSchema>;
+    approvalRule(projectId: string | number, approvalRuleId: number, options: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    approvalRules(projectId: string | number, options?: {
+        mergerequestIid?: undefined;
+    } & BaseRequestOptions): Promise<ProjectLevelApprovalRuleSchema[]>;
+    approvalRules(projectId: string | number, options: {
+        mergerequestIid: number;
+    } & BaseRequestOptions): Promise<MergeRequestLevelApprovalRuleSchema[]>;
+    addApprovalRule(projectId: string | number, name: string, approvalsRequired: number, options?: {
+        mergerequestIid?: undefined;
+    } & ApprovalRulesRequestOptions & BaseRequestOptions): Promise<ProjectLevelApprovalRuleSchema>;
+    addApprovalRule(projectId: string | number, name: string, approvalsRequired: number, options: {
+        mergerequestIid: number;
+    } & ApprovalRulesRequestOptions & BaseRequestOptions): Promise<MergeRequestLevelApprovalRuleSchema>;
+    approvalState(projectId: string | number, mergerequestIid: number, options?: {
+        sha?: string;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    editApprovalRule(projectId: string | number, approvalRuleId: number, name: string, approvalsRequired: number, options?: {
+        mergerequestIid?: undefined;
+    } & ApprovalRulesRequestOptions & BaseRequestOptions): Promise<ProjectLevelApprovalRuleSchema>;
+    editApprovalRule(projectId: string | number, approvalRuleId: number, name: string, approvalsRequired: number, options: {
+        mergerequestIid: number;
+    } & ApprovalRulesRequestOptions & BaseRequestOptions): Promise<MergeRequestLevelApprovalRuleSchema>;
+    removeApprovalRule(projectId: string | number, approvalRuleId: number, options?: {
+        mergerequestIid?: undefined;
+    } & Sudo): Promise<void>;
+    removeApprovalRule(projectId: string | number, approvalRuleId: number, options: {
+        mergerequestIid: number;
+    } & Sudo): Promise<void>;
+    approve(projectId: string | number, mergerequestIid: number, options?: {
+        sha?: string;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestLevelMergeRequestApprovalSchema>>;
+    unapprove(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<void>;
+}

package/dist/types/resources/MergeRequestAwardEmojis.d.ts

@@ -0,0 +1,13 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceAwardEmojis } from '../templates';
+import { AwardEmojiSchema } from '../templates/types';
+import { PaginatedRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface MergeRequestAwardEmojis<C extends boolean = false> extends ResourceAwardEmojis<C> {
+    all(projectId: string | number, mergerequestIId: number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, AwardEmojiSchema>[]>;
+    award(projectId: string | number, mergerequestIId: number, name: string, options?: Sudo): Promise<CamelizedRecord<C, AwardEmojiSchema>>;
+    remove(projectId: string | number, mergerequestIId: number, awardId: number, options?: Sudo): Promise<void>;
+    show(projectId: string | number, mergerequestIId: number, awardId: number, options?: Sudo): Promise<CamelizedRecord<C, AwardEmojiSchema>>;
+}
+export declare class MergeRequestAwardEmojis<C extends boolean = false> extends ResourceAwardEmojis<C> {
+    constructor(options: BaseResourceOptions<C>);
+}