@gitbeaker/core 34.4.0 → 34.4.1

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

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

package/dist/types/resources/MergeRequestNotes.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 MergeRequestNoteSchema extends NoteSchema {
+    attachment?: string;
+    system: boolean;
+    noteable_id: number;
+    noteable_type: string;
+    noteable_iid: number;
+    resolvable: boolean;
+}
+export interface MergeRequestNotes<C extends boolean = false> extends ResourceNotes<C> {
+    all(projectId: string | number, mergerequestId: string | number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, MergeRequestNoteSchema>[]>;
+    create(projectId: string | number, mergerequestId: string | number, body: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, MergeRequestNoteSchema>>;
+    edit(projectId: string | number, mergerequestId: string | number, noteId: number, body: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, MergeRequestNoteSchema>>;
+    remove(projectId: string | number, mergerequestId: string | number, noteId: number, options?: Sudo): Promise<void>;
+    show(projectId: string | number, mergerequestIdepicId: string | number, noteId: number, options?: Sudo): Promise<CamelizedRecord<C, MergeRequestNoteSchema>>;
+}
+export declare class MergeRequestNotes<C extends boolean = false> extends ResourceNotes<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

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

@@ -0,0 +1,191 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { PipelineSchema } from './Pipelines';
+import { IssueSchema, TimeStatsSchema } from './Issues';
+import { CommitSchema, CommitDiffSchema } from './Commits';
+import { MilestoneSchema } from '../templates/types';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface AcceptMergeRequestOptions {
+    mergeCommitMessage?: string;
+    squashCommitMessage?: string;
+    squash?: boolean;
+    shouldRemoveSourceBranch?: boolean;
+    mergeWhenPipelineSucceeds?: boolean;
+    sha?: string;
+}
+export interface ShowMergeRequestOptions {
+    renderHtml?: boolean;
+    includeDivergedCommitsCount?: true;
+    includeRebaseInProgress?: boolean;
+}
+export interface CreateMergeRequestOptions {
+    assigneeId?: number;
+    description?: string;
+    targetProjectId?: number;
+    labels?: string | Array<string>;
+    milestoneId?: number;
+    removeSourceBranch?: boolean;
+    allowCollaboration?: boolean;
+    allowMaintainerToPush?: boolean;
+    squash?: boolean;
+}
+export interface UpdateMergeRequestOptions {
+    targetBranch?: number;
+    title?: string;
+    assigneeId?: number;
+    milestoneId?: number;
+    labels?: string | Array<string>;
+    description?: string;
+    stateEvent?: string;
+    removeSourceBranch?: boolean;
+    squash?: boolean;
+    discussionLocked?: boolean;
+    allowCollaboration?: boolean;
+    allowMaintainerToPush?: boolean;
+}
+export interface AllMergeRequestsOptions {
+    state?: 'opened' | 'closed' | 'locked' | 'merged';
+    orderBy?: 'created_at' | 'updated_at';
+    sort?: 'asc' | 'desc';
+    milestone?: 'None' | string;
+    view?: string;
+    labels?: string | Array<string>;
+    withLabelsDetails?: boolean;
+    withMergeStatusRecheck?: boolean;
+    createdAfter?: string;
+    createdBefore?: string;
+    updatedBefore?: string;
+    updatedAfter?: string;
+    scope?: 'created_by_me' | 'assigned_to_me' | 'all';
+    authorId?: number;
+    authorUsername?: string;
+    asigneeId?: number;
+    assigneeUsername?: string;
+    approverIds?: Array<number>;
+    approvedByIds?: Array<number>;
+    reviewerId?: number;
+    reviewerUsername?: string;
+    myReactionEmoji?: string;
+    sourceBranch?: string;
+    targetBranch?: string;
+    in?: string;
+    wip?: string;
+    iids?: number[];
+    mergeCommitMessage?: string;
+    squashCommitMessage?: string;
+    squash?: boolean;
+    shouldRemoveSourceBranch?: boolean;
+    mergeWhenPipelineSucceeds?: boolean;
+    sha?: string;
+    search?: string;
+    not?: {
+        labels?: string | Array<string>;
+        milestone?: string;
+        authorId?: number;
+        authorUsername?: string;
+        assigneeId?: number;
+        assigneeUsername?: string;
+        reviewerId?: number;
+        reviewerUsername?: string;
+        myReactionEmoji?: string;
+    };
+    environment?: string;
+    deployedBefore?: string;
+    deployedAfter?: string;
+}
+export interface ReferenceSchema {
+    short: string;
+    relative: string;
+    full: string;
+}
+export interface TaskCompletionStatusSchema {
+    count: number;
+    completed_count: number;
+}
+export interface RebaseSchema extends Record<string, unknown> {
+    rebase_in_progress?: boolean;
+    merge_error?: string;
+}
+export interface DiffSchema extends Record<string, unknown> {
+    id: number;
+    head_commit_sha: string;
+    base_commit_sha: string;
+    start_commit_sha: string;
+    created_at: string;
+    merge_request_id: number;
+    state: string;
+    real_size: string;
+    commits?: CommitSchema[];
+    diffs?: CommitDiffSchema[];
+}
+export interface MergeRequestSchema extends Record<string, unknown> {
+    id: number;
+    iid: number;
+    project_id: number;
+    title: string;
+    description: string;
+    state: string;
+    merged_by: Omit<UserSchema, 'created_at'>;
+    merged_at: string;
+    closed_by?: string;
+    closed_at?: string;
+    created_at: string;
+    updated_at: string;
+    target_branch: string;
+    source_branch: string;
+    upvotes: number;
+    downvotes: number;
+    author: Omit<UserSchema, 'created_at'>;
+    assignee: Omit<UserSchema, 'created_at'>;
+    assignees?: Omit<UserSchema, 'created_at'>[];
+    reviewers?: Omit<UserSchema, 'created_at'>[];
+    source_project_id: number;
+    target_project_id: number;
+    labels?: string[];
+    work_in_progress: boolean;
+    milestone: MilestoneSchema;
+    merge_when_pipeline_succeeds: boolean;
+    merge_status: string;
+    sha: string;
+    merge_commit_sha?: string;
+    squash_commit_sha?: string;
+    user_notes_count: number;
+    discussion_locked?: string;
+    should_remove_source_branch: boolean;
+    force_remove_source_branch: boolean;
+    web_url: string;
+    references: ReferenceSchema;
+    time_stats: TimeStatsSchema;
+    squash: boolean;
+    task_completion_status: TaskCompletionStatusSchema;
+    has_conflicts: boolean;
+    blocking_discussions_resolved: boolean;
+    changes?: CommitDiffSchema[];
+}
+export declare class MergeRequests<C extends boolean = false> extends BaseResource<C> {
+    accept(projectId: string | number, mergerequestIid: number, options?: AcceptMergeRequestOptions & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>>;
+    addSpentTime(projectId: string | number, mergerequestIid: number, duration: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TimeStatsSchema>>;
+    addTimeEstimate(projectId: string | number, mergerequestIid: number, duration: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TimeStatsSchema>>;
+    all({ projectId, groupId, ...options }?: {
+        projectId?: string | number;
+        groupId?: string | number;
+    } & AllMergeRequestsOptions & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>[]>;
+    cancelOnPipelineSucess(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>>;
+    changes(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>>;
+    closesIssues(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, IssueSchema>[]>;
+    commits(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, CommitSchema>[]>;
+    create(projectId: string | number, sourceBranch: string, targetBranch: string, title: string, options?: CreateMergeRequestOptions & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>>;
+    edit(projectId: string | number, mergerequestIid: number, options?: UpdateMergeRequestOptions & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>>;
+    participants(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Omit<UserSchema, "created_at">>[]>;
+    pipelines(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Pick<PipelineSchema, "id" | "sha" | "ref" | "status">>[]>;
+    rebase(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, RebaseSchema>>;
+    remove(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<void>;
+    resetSpentTime(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TimeStatsSchema>>;
+    resetTimeEstimate(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TimeStatsSchema>>;
+    show(projectId: string | number, mergerequestIid: number, options?: ShowMergeRequestOptions & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>>;
+    subscribe(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>>;
+    timeStats(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TimeStatsSchema>>;
+    version(projectId: string | number, mergerequestIid: number, versionId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, DiffSchema>>;
+    versions(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, DiffSchema>[]>;
+    unsubscribe(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>>;
+}

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

@@ -0,0 +1,22 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface NamespaceSchema extends Record<string, unknown> {
+    id: number;
+    name: string;
+    path: string;
+    kind: string;
+    full_path: string;
+    parent_id?: number;
+    avatar_url: string;
+    web_url: string;
+    billable_members_count: number;
+    plan: string;
+    trial_ends_on?: string;
+    trial: boolean;
+}
+export declare class Namespaces<C extends boolean = false> extends BaseResource<C> {
+    all(options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, NamespaceSchema>[]>;
+    show(namespaceId: string | number, options?: {
+        search?: string;
+    } & Sudo): Promise<import("../infrastructure").CamelizedRecord<C, NamespaceSchema>>;
+}

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

@@ -0,0 +1,21 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions } from '../infrastructure';
+export declare type NotificationSettingLevel = 'disabled' | 'participating' | 'watch' | 'global' | 'mention' | 'custom';
+export interface NotificationSettingSchema extends Record<string, unknown> {
+    level: NotificationSettingLevel;
+    notification_email: string;
+}
+export declare class NotificationSettings<C extends boolean = false> extends BaseResource<C> {
+    all({ projectId, groupId, ...options }?: ({
+        projectId?: string | number;
+    } | {
+        groupId?: string | number;
+    }) & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, NotificationSettingSchema>[]>;
+    edit({ projectId, groupId, ...options }?: {
+        level?: NotificationSettingLevel;
+    } & ({
+        projectId?: string | number;
+    } | {
+        groupId?: string | number;
+    }) & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, NotificationSettingSchema>>;
+}

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

@@ -0,0 +1,14 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { Sudo } from '../infrastructure';
+export declare class PackageRegistry<C extends boolean = false> extends BaseResource<C> {
+    publish(projectId: string | number, packageName: string, packageVersion: string, filename: string, content: string, { contentType, ...options }?: {
+        contentType?: string;
+    } & {
+        status?: 'default' | 'hidden';
+    }): Promise<import("../infrastructure").CamelizedRecord<C, {
+        message: string;
+    }>>;
+    download(projectId: string | number, packageName: string, packageVersion: string, filename: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, {
+        message: string;
+    }>>;
+}

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

@@ -0,0 +1,30 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { PipelineSchema } from './Pipelines';
+import { PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface PackageSchema extends Record<string, unknown> {
+    id: number;
+    name: string;
+    version: string;
+    package_type: string;
+    created_at: string;
+}
+export interface PackageFileSchema extends Record<string, unknown> {
+    id: number;
+    package_id: number;
+    created_at: string;
+    file_name: string;
+    size: number;
+    file_md5: string;
+    file_sha1: string;
+    pipelines?: PipelineSchema[];
+}
+export declare class Packages<C extends boolean = false> extends BaseResource<C> {
+    all({ projectId, groupId, ...options }?: {
+        projectId?: string | number;
+        groupId?: string | number;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PackageSchema>[]>;
+    remove(projectId: string | number, packageId: number, options?: Sudo): Promise<void>;
+    removeFile(projectId: string | number, packageId: number, projectFileId: number, options?: Sudo): Promise<void>;
+    show(projectId: string | number, packageId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, PackageSchema>>;
+    showFiles(projectId: string | number, packageId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, PackageFileSchema>[]>;
+}

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

@@ -0,0 +1,21 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface PagesDomainSchema extends Record<string, unknown> {
+    domain: string;
+    url: string;
+    project_id: number;
+    auto_ssl_enabled: boolean;
+    certificate: {
+        expired: boolean;
+        expiration: string;
+    };
+}
+export declare class PagesDomains<C extends boolean = false> extends BaseResource<C> {
+    all({ projectId, ...options }?: {
+        projectId?: string | number;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PagesDomainSchema>[]>;
+    create(projectId: string | number, domain: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PagesDomainSchema>>;
+    edit(projectId: string | number, domain: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PagesDomainSchema>>;
+    show(projectId: string | number, domain: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, PagesDomainSchema>>;
+    remove(projectId: string | number, domain: string, options?: Sudo): Promise<void>;
+}

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

@@ -0,0 +1,10 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { PipelineVariableSchema } from './Pipelines';
+import { BaseRequestOptions, PaginatedRequestOptions } from '../infrastructure';
+export declare class PipelineScheduleVariables<C extends boolean = false> extends BaseResource<C> {
+    all(projectId: string | number, pipelineScheduleId: number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineVariableSchema>[]>;
+    create(projectId: string | number, pipelineScheduleId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineVariableSchema>>;
+    edit(projectId: string | number, pipelineScheduleId: number, keyId: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineVariableSchema>>;
+    show(projectId: string | number, pipelineScheduleId: number, keyId: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineVariableSchema>>;
+    remove(projectId: string | number, pipelineScheduleId: number, keyId: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineVariableSchema>>;
+}

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

@@ -0,0 +1,29 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { PipelineSchema, PipelineVariableSchema } from './Pipelines';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface PipelineScheduleSchema extends Record<string, unknown> {
+    id: number;
+    description: string;
+    ref: string;
+    cron: string;
+    cron_timezone: string;
+    next_run_at: string;
+    active: boolean;
+    created_at: string;
+    updated_at: string;
+    owner: Pick<UserSchema, 'name' | 'username' | 'id' | 'state' | 'avatar_url' | 'web_url'>;
+}
+export interface PipelineScheduleExtendedSchema extends PipelineScheduleSchema {
+    last_pipeline: Pick<PipelineSchema, 'id' | 'sha' | 'ref' | 'status'>;
+}
+export declare class PipelineSchedules<C extends boolean = false> extends BaseResource<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineScheduleSchema>[]>;
+    create(projectId: string | number, description: string, ref: string, cron: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineScheduleSchema & {
+        variables?: PipelineVariableSchema[] | undefined;
+    }>>;
+    edit(projectId: string | number, scheduleId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineScheduleExtendedSchema>>;
+    remove(projectId: string | number, scheduleId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, PipelineScheduleExtendedSchema>>;
+    show(projectId: string | number, scheduleId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, PipelineScheduleExtendedSchema>>;
+    takeOwnership(projectId: string | number, scheduleId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, PipelineScheduleExtendedSchema>>;
+}

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

@@ -0,0 +1,40 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export declare type PipelineStatus = 'created' | 'waiting_for_resource' | 'preparing' | 'pending' | 'running' | 'failed' | 'success' | 'canceled' | 'skipped' | 'manual' | 'scheduled';
+export interface PipelineSchema extends Record<string, unknown> {
+    id: number;
+    status: PipelineStatus;
+    ref: string;
+    sha: string;
+    web_url: string;
+    created_at: string;
+    updated_at: string;
+    user: Pick<UserSchema, 'name' | 'avatar_url'>;
+}
+export interface PipelineExtendedSchema extends PipelineSchema {
+    project_id: number;
+    before_sha: string;
+    tag: boolean;
+    yaml_errors?: string;
+    user: Pick<UserSchema, 'name' | 'username' | 'id' | 'state' | 'avatar_url' | 'web_url'>;
+    started_at?: string;
+    finished_at: string;
+    committed_at?: string;
+    duration?: string;
+    coverage?: string;
+}
+export interface PipelineVariableSchema extends Record<string, unknown> {
+    key: string;
+    variable_type?: string;
+    value: string;
+}
+export declare class Pipelines<C extends boolean = false> extends BaseResource<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineSchema>[]>;
+    create(projectId: string | number, ref: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineSchema>>;
+    delete(projectId: string | number, pipelineId: number, options?: Sudo): Promise<void>;
+    show(projectId: string | number, pipelineId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, PipelineSchema>>;
+    retry(projectId: string | number, pipelineId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, PipelineExtendedSchema>>;
+    cancel(projectId: string | number, pipelineId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, PipelineExtendedSchema>>;
+    allVariables(projectId: string | number, pipelineId: number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineVariableSchema>[]>;
+}

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

@@ -0,0 +1,15 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceAccessRequests } from '../templates';
+import { AccessRequestSchema, AccessLevel } from '../templates/types';
+import { Sudo, CamelizedRecord } from '../infrastructure';
+export interface ProjectAccessRequests<C extends boolean = false> extends ResourceAccessRequests<C> {
+    all(projectId: string | number): Promise<CamelizedRecord<C, AccessRequestSchema>[]>;
+    request(projectId: string | number): Promise<CamelizedRecord<C, AccessRequestSchema>>;
+    approve(projectId: string | number, userId: number, options?: {
+        accessLevel?: AccessLevel;
+    } & Sudo): Promise<CamelizedRecord<C, AccessRequestSchema>>;
+    deny(projectId: string | number, userId: number): Promise<void>;
+}
+export declare class ProjectAccessRequests<C extends boolean = false> extends ResourceAccessRequests<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

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

@@ -0,0 +1,18 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceBadges } from '../templates';
+import { BadgeSchema } from '../templates/types';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface ProjectBadgeSchema extends BadgeSchema {
+    kind: 'project';
+}
+export interface ProjectBadges<C extends boolean = false> extends ResourceBadges<C> {
+    add(productId: string | number, options?: BaseRequestOptions): Promise<CamelizedRecord<C, ProjectBadgeSchema>>;
+    all(productId: string | number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, ProjectBadgeSchema>[]>;
+    edit(productId: string | number, badgeId: number, options?: BaseRequestOptions): Promise<CamelizedRecord<C, ProjectBadgeSchema>>;
+    preview(productId: string | number, linkUrl: string, imageUrl: string, options?: Sudo): Promise<CamelizedRecord<C, Omit<ProjectBadgeSchema, 'id' | 'name' | 'kind'>>>;
+    remove(productId: string | number, badgeId: number, options?: Sudo): Promise<void>;
+    show(productId: string | number, badgeId: number, options?: Sudo): Promise<CamelizedRecord<C, ProjectBadgeSchema>>;
+}
+export declare class ProjectBadges<C extends boolean = false> extends ResourceBadges<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

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

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

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

@@ -0,0 +1,14 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceDeployTokens } from '../templates';
+import { DeployTokenScope, DeployTokenSchema } from '../templates/types';
+import { BaseRequestOptions, PaginatedRequestOptions, CamelizedRecord, Sudo } from '../infrastructure';
+export interface ProjectDeployTokens<C extends boolean = false> extends ResourceDeployTokens<C> {
+    add(projectId: string | number, tokenName: string, tokenScopes: DeployTokenScope[], options?: BaseRequestOptions): Promise<CamelizedRecord<C, DeployTokenSchema>>;
+    all(options?: {
+        projectId?: string | number;
+    } & PaginatedRequestOptions): Promise<CamelizedRecord<C, DeployTokenSchema>[]>;
+    remove(projectId: string | number, tokenId: number, options?: Sudo): Promise<void>;
+}
+export declare class ProjectDeployTokens<C extends boolean = false> extends ResourceDeployTokens<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

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

@@ -0,0 +1,29 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface ProjectHookSchema extends Record<string, unknown> {
+    id: number;
+    url: string;
+    project_id: number;
+    push_events: boolean;
+    push_events_branch_filter: string;
+    issues_events: boolean;
+    confidential_issues_events: boolean;
+    merge_requests_events: boolean;
+    tag_push_events: boolean;
+    note_events: boolean;
+    confidential_note_events: boolean;
+    job_events: boolean;
+    pipeline_events: boolean;
+    wiki_page_events: boolean;
+    deployment_events: boolean;
+    releases_events: boolean;
+    enable_ssl_verification: boolean;
+    created_at: string;
+}
+export declare class ProjectHooks<C extends boolean = false> extends BaseResource<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectHookSchema>[]>;
+    show(projectId: string | number, hookId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ProjectHookSchema>>;
+    add(projectId: string | number, url: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectHookSchema>>;
+    edit(projectId: string | number, hookId: number, url: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectHookSchema>>;
+    remove(projectId: string | number, hookId: number, options?: Sudo): Promise<void>;
+}

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

@@ -0,0 +1,54 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { Sudo, BaseRequestOptions } from '../infrastructure';
+export interface ExportStatusSchema extends Record<string, unknown> {
+    id: number;
+    description: string;
+    name: string;
+    name_with_namespace: string;
+    path: string;
+    path_with_namespace: string;
+    created_at: string;
+    export_status: string;
+    _links: {
+        api_url: string;
+        web_url: string;
+    };
+}
+export interface FailedRelationSchema {
+    id: number;
+    created_at: string;
+    exception_class: string;
+    exception_message: string;
+    source: string;
+    relation_name: string;
+}
+export interface ImportStatusSchema extends Record<string, unknown> {
+    id: number;
+    description: string;
+    name: string;
+    name_with_namespace: string;
+    path: string;
+    path_with_namespace: string;
+    created_at: string;
+    import_status: string;
+    correlation_id: string;
+    failed_relations?: FailedRelationSchema[];
+}
+export interface UploadMetadata {
+    filename?: string;
+    contentType?: string;
+}
+export declare const defaultMetadata: {
+    filename: string;
+};
+export declare class ProjectImportExport<C extends boolean = false> extends BaseResource<C> {
+    download(projectId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    exportStatus(projectId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ExportStatusSchema>>;
+    import(content: string, path: string, { metadata, ...options }?: {
+        metadata?: UploadMetadata;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ImportStatusSchema>>;
+    importStatus(projectId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ImportStatusSchema>>;
+    schedule(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, {
+        message: string;
+    }>>;
+}

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

@@ -0,0 +1,23 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ProjectSchema } from './Projects';
+import { ResourceIssueBoards } from '../templates';
+import { IssueBoardSchema, IssueBoardListSchema } from '../templates/types';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface ProjectIssueBoardSchema extends IssueBoardSchema {
+    project: Pick<ProjectSchema, 'id' | 'name' | 'name_with_namespace' | 'path' | 'path_with_namespace' | 'http_url_to_repo' | 'web_url'>;
+}
+export interface ProjectIssueBoards<C extends boolean = false> extends ResourceIssueBoards<C> {
+    all(groupId: string | number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, ProjectIssueBoardSchema>[]>;
+    create(groupId: string | number, name: string, options?: Sudo): Promise<CamelizedRecord<C, ProjectIssueBoardSchema>>;
+    createList(groupId: string | number, boardId: number, labelId: number | string, options?: Sudo): Promise<CamelizedRecord<C, IssueBoardListSchema>>;
+    edit(groupId: string | number, boardId: number, options?: BaseRequestOptions): Promise<CamelizedRecord<C, ProjectIssueBoardSchema>>;
+    editList(groupId: string | number, boardId: number, listId: number, position: number, options?: Sudo): Promise<CamelizedRecord<C, IssueBoardListSchema>>;
+    lists(groupId: string | number, boardId: number, options?: Sudo): Promise<CamelizedRecord<C, IssueBoardListSchema>[]>;
+    remove(groupId: string | number, boardId: number, options?: Sudo): Promise<void>;
+    removeList(groupId: string | number, boardId: number, listId: number, options?: Sudo): Promise<void>;
+    show(groupId: string | number, boardId: number, options?: Sudo): Promise<CamelizedRecord<C, ProjectIssueBoardSchema>>;
+    showList(groupId: string | number, boardId: number, listId: number, options?: Sudo): Promise<CamelizedRecord<C, IssueBoardListSchema>>;
+}
+export declare class ProjectIssueBoards<C extends boolean = false> extends ResourceIssueBoards<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

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

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