@gitbeaker/core 34.4.0 → 34.7.0

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

@@ -0,0 +1,37 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+export interface ProcessMetricSchema {
+    hostname: string;
+    pid: number;
+    tag: string;
+    started_at: string;
+    queues?: string[];
+    labels?: string[];
+    concurrency: number;
+    busy: number;
+}
+export interface SidekickProcessMetricsSchema extends Record<string, unknown> {
+    processes?: ProcessMetricSchema[];
+}
+export interface SidekickQueueMetricsSchema extends Record<string, unknown> {
+    queues: {
+        default: {
+            backlog: number;
+            latency: number;
+        };
+    };
+}
+export interface SidekickJobStatsSchema extends Record<string, unknown> {
+    jobs: {
+        processed: number;
+        failed: number;
+        enqueued: number;
+        dead: number;
+    };
+}
+export declare type SidekickCompoundMetricsSchema = SidekickJobStatsSchema & SidekickQueueMetricsSchema & SidekickProcessMetricsSchema;
+export declare class SidekiqMetrics<C extends boolean = false> extends BaseResource<C> {
+    queueMetrics(): Promise<import("../infrastructure").CamelizedRecord<C, SidekickQueueMetricsSchema>>;
+    processMetrics(): Promise<import("../infrastructure").CamelizedRecord<C, SidekickProcessMetricsSchema>>;
+    jobStats(): Promise<import("../infrastructure").CamelizedRecord<C, SidekickJobStatsSchema>>;
+    compoundMetrics(): Promise<import("../infrastructure").CamelizedRecord<C, SidekickCompoundMetricsSchema>>;
+}

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

@@ -0,0 +1,42 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export declare type SnippetVisibility = 'private' | 'public' | 'internal';
+export interface SnippetSchema extends Record<string, unknown> {
+    id: number;
+    title: string;
+    file_name: string;
+    description?: string;
+    visibility: string;
+    author: Pick<UserSchema, 'name' | 'username' | 'id' | 'state' | 'avatar_url' | 'web_url'>;
+    updated_at: string;
+    created_at: string;
+    project_id?: string | number;
+    web_url: string;
+    raw_url: string;
+}
+export interface SnippetExtendedSchema extends SnippetSchema {
+    expires_at?: string;
+    ssh_url_to_repo: string;
+    http_url_to_repo: string;
+    files?: {
+        path: string;
+        raw_url: string;
+    }[];
+}
+export interface UserAgentDetailSchema extends Record<string, unknown> {
+    user_agent: string;
+    ip_address: string;
+    akismet_submitted: boolean;
+}
+export declare class Snippets<C extends boolean = false> extends BaseResource<C> {
+    all({ public: p, ...options }?: {
+        public?: boolean;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, SnippetSchema>[]>;
+    content(snippetId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    create(title: string, fileName: string, content: string, visibility: SnippetVisibility, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, SnippetExtendedSchema>>;
+    edit(snippetId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, SnippetExtendedSchema>>;
+    remove(snippetId: number, options?: Sudo): Promise<void>;
+    show(snippetId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, SnippetSchema>>;
+    userAgentDetails(snippetId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, UserAgentDetailSchema>>;
+}

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

@@ -0,0 +1,18 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface SystemHookSchema extends Record<string, unknown> {
+    id: number;
+    url: string;
+    created_at: string;
+    push_events: boolean;
+    tag_push_events: boolean;
+    merge_requests_events: boolean;
+    repository_update_events: boolean;
+    enable_ssl_verification: boolean;
+}
+export declare class SystemHooks<C extends boolean = false> extends BaseResource<C> {
+    add(url: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, SystemHookSchema>>;
+    all(options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, SystemHookSchema>[]>;
+    edit(hookId: number, url: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, SystemHookSchema>>;
+    remove(hookId: number, options?: Sudo): Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { CommitSchema } from './Commits';
+import { ReleaseSchema } from './Releases';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface TagSchema extends Record<string, unknown> {
+    commit: CommitSchema;
+    release: Pick<ReleaseSchema, 'tag_name' | 'description'>;
+    name: string;
+    target: string;
+    message?: string;
+    protected: boolean;
+}
+export declare class Tags<C extends boolean = false> extends BaseResource<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, TagSchema>[]>;
+    create(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, TagSchema>>;
+    remove(projectId: string | number, tagName: string, options?: Sudo): Promise<void>;
+    show(projectId: string | number, tagName: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TagSchema>>;
+}

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

@@ -0,0 +1,48 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { ProjectSchema } from './Projects';
+import { MilestoneSchema } from '../templates/types';
+import { PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface TodoSchema extends Record<string, unknown> {
+    id: number;
+    project: Pick<ProjectSchema, 'id' | 'name' | 'name_with_namespace' | 'path' | 'path_with_namespace'>;
+    author: Pick<UserSchema, 'name' | 'username' | 'id' | 'state' | 'avatar_url' | 'web_url'>;
+    action_name: string;
+    target_type: string;
+    target: {
+        id: number;
+        iid: number;
+        project_id: number;
+        title: string;
+        description: string;
+        state: string;
+        created_at: string;
+        updated_at: string;
+        target_branch: string;
+        source_branch: string;
+        upvotes: number;
+        downvotes: number;
+        author: Pick<UserSchema, 'name' | 'username' | 'id' | 'state' | 'avatar_url' | 'web_url'>;
+        assignee: Pick<UserSchema, 'name' | 'username' | 'id' | 'state' | 'avatar_url' | 'web_url'>;
+        source_project_id: number;
+        target_project_id: number;
+        labels?: string[];
+        work_in_progress: boolean;
+        milestone: Omit<MilestoneSchema, 'start_date' | 'expired' | 'web_url'>;
+        merge_when_pipeline_succeeds: boolean;
+        merge_status: string;
+        user_notes_count: number;
+    };
+    target_url: string;
+    body: string;
+    state: string;
+    created_at: string;
+    updated_at: string;
+}
+export declare class Todos<C extends boolean = false> extends BaseResource<C> {
+    all(options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, TodoSchema>[]>;
+    create(projectId: string | number, resourceId: number, resourceName: 'mergerequest' | 'issue', options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TodoSchema>>;
+    done({ todoId, ...options }?: {
+        todoId?: number;
+    } & Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TodoSchema>> | Promise<void>;
+}

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

@@ -0,0 +1,22 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface PipelineTriggerSchema extends Record<string, unknown> {
+    id: number;
+    description: string;
+    created_at: string;
+    last_used?: string;
+    token: string;
+    updated_at: string;
+    owner: Pick<UserSchema, 'id' | 'name' | 'created_at'>;
+}
+export declare class Triggers<C extends boolean = false> extends BaseResource<C> {
+    add(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineTriggerSchema>>;
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineTriggerSchema>[]>;
+    edit(projectId: string | number, triggerId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PipelineTriggerSchema>>;
+    pipeline(projectId: string | number, ref: string, token: string, { variables }?: {
+        variables?: Record<string, string>;
+    }): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    remove(projectId: string | number, triggerId: number, options?: Sudo): Promise<void>;
+    show(projectId: string | number, triggerId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, PipelineTriggerSchema>>;
+}

package/dist/types/resources/UserCustomAttributes.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 UserCustomAttributes<C extends boolean = false> extends ResourceCustomAttributes<C> {
+    all(userId: string | number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, CustomAttributeSchema>[]>;
+    set(userId: string | number, customAttributeId: number, value: string, options?: Sudo): Promise<CamelizedRecord<C, CustomAttributeSchema>>;
+    remove(userId: string | number, customAttributeId: number, options?: Sudo): Promise<void>;
+    show(userId: string | number, customAttributeId: number, options?: Sudo): Promise<CamelizedRecord<C, CustomAttributeSchema>>;
+}
+export declare class UserCustomAttributes<C extends boolean = false> extends ResourceCustomAttributes<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

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

@@ -0,0 +1,19 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions } from '../infrastructure';
+export interface UserEmailSchema extends Record<string, unknown> {
+    id: number;
+    email: string;
+    confirmed_at: string;
+}
+export declare class UserEmails<C extends boolean = false> extends BaseResource<C> {
+    all({ userId, ...options }?: {
+        userId?: number;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserEmailSchema>[]>;
+    add(email: string, { userId, ...options }?: {
+        userId?: number;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserEmailSchema>>;
+    show(emailId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserEmailSchema>>;
+    remove(emailId: number, { userId, ...options }?: {
+        userId?: number;
+    } & BaseRequestOptions): Promise<void>;
+}

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

@@ -0,0 +1,21 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions } from '../infrastructure';
+export interface UserGPGKeySchema extends Record<string, unknown> {
+    id: number;
+    key: string;
+    created_at: string;
+}
+export declare class UserGPGKeys<C extends boolean = false> extends BaseResource<C> {
+    all({ userId, ...options }?: {
+        userId?: number;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserGPGKeySchema>[]>;
+    add(key: string, { userId, ...options }?: {
+        userId?: number;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserGPGKeySchema>>;
+    show(keyId: number, { userId, ...options }?: {
+        userId?: number;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserGPGKeySchema>>;
+    remove(keyId: number, { userId, ...options }?: {
+        userId?: number;
+    } & BaseRequestOptions): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { PaginatedRequestOptions, Sudo } from '../infrastructure';
+export declare type ImpersonationTokenScope = 'api' | 'read_user';
+export declare type ImpersonationTokenState = 'all' | 'active' | 'inactive';
+export interface UserImpersonationTokenSchema extends Record<string, unknown> {
+    active: boolean;
+    user_id: number;
+    scopes?: string[];
+    revoked: boolean;
+    name: string;
+    id: number;
+    created_at: string;
+    impersonation: boolean;
+    expires_at: string;
+}
+export declare class UserImpersonationTokens<C extends boolean = false> extends BaseResource<C> {
+    all(userId: number, options?: {
+        state?: ImpersonationTokenState;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserImpersonationTokenSchema>[]>;
+    add(userId: number, name: string, scopes: ImpersonationTokenScope, expiresAt: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, UserImpersonationTokenSchema>>;
+    show(userId: number, tokenId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, UserImpersonationTokenSchema>>;
+    revoke(userId: number, tokenId: number, options?: Sudo): Promise<void>;
+}

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

@@ -0,0 +1,22 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions } from '../infrastructure';
+export interface UserSSHKeySchema extends Record<string, unknown> {
+    id: number;
+    key: string;
+    title: string;
+    created_at: string;
+}
+export declare class UserSSHKeys<C extends boolean = false> extends BaseResource<C> {
+    all({ userId, ...options }?: {
+        userId?: number;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserSSHKeySchema>[]>;
+    create(title: string, key: string, { userId, ...options }?: {
+        userId?: number;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserSSHKeySchema>>;
+    show(keyId: number, { userId, ...options }?: {
+        userId?: number;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserSSHKeySchema>>;
+    remove(keyId: number, { userId, ...options }?: {
+        userId?: number;
+    } & BaseRequestOptions): Promise<void>;
+}

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

@@ -0,0 +1,57 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+import { ProjectExtendedSchema } from './Projects';
+import { EventOptions, EventSchema } from './Events';
+export interface UserSchema extends Record<string, unknown> {
+    id: number;
+    name: string;
+    username: string;
+    state: string;
+    avatar_url: string;
+    web_url: string;
+    created_at?: string;
+}
+export interface UserExtendedSchema extends UserSchema {
+    bio?: string;
+    location?: string;
+    public_email: string;
+    skype: string;
+    linkedin: string;
+    twitter: string;
+    website_url: string;
+    organization?: string;
+    last_sign_in_at: string;
+    confirmed_at: string;
+    last_activity_on: string;
+    email: string;
+    theme_id: number;
+    color_scheme_id: number;
+    projects_limit: number;
+    current_sign_in_at?: string;
+    identities?: string[];
+    can_create_group: boolean;
+    can_create_project: boolean;
+    two_factor_enabled: boolean;
+    external: boolean;
+    private_profile?: string;
+}
+export interface UserActivitySchema extends Record<string, unknown> {
+    username: string;
+    last_activity_on: string;
+    last_activity_at: string;
+}
+export declare class Users<C extends boolean = false> extends BaseResource<C> {
+    all(options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserSchema>[]>;
+    activities(options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, UserActivitySchema>[]>;
+    projects(userId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ProjectExtendedSchema>[]>;
+    block(userId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    create(options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserSchema>>;
+    current(options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, UserSchema>>;
+    edit(userId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserSchema>>;
+    events(userId: number, options?: BaseRequestOptions & EventOptions): Promise<import("../infrastructure").CamelizedRecord<C, EventSchema>[]>;
+    search(emailOrUsername: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, UserSchema>[]>;
+    show(userId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, UserSchema>>;
+    remove(userId: number, options?: Sudo): Promise<void>;
+    unblock(userId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    username(username: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, UserSchema>[]>;
+}

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

@@ -0,0 +1,9 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { Sudo } from '../infrastructure';
+export interface VersionSchema extends Record<string, unknown> {
+    version: string;
+    revision: string;
+}
+export declare class Version<C extends boolean = false> extends BaseResource<C> {
+    show(options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, VersionSchema>>;
+}

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

@@ -0,0 +1,69 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { PaginatedRequestOptions } from '../infrastructure';
+export interface VulnerabilityFindingIdentifier {
+    external_type: string;
+    external_id: string;
+    name: string;
+    url: string;
+}
+export interface VulnerabilityFindingDetailItem {
+    type: string;
+    href: string;
+}
+export interface VulnerabilityFindingSchema extends Record<string, unknown> {
+    id: number;
+    report_type: string;
+    name: string;
+    severity: string;
+    confidence: string;
+    scanner: {
+        external_id: string;
+        name: string;
+    };
+    identifiers?: VulnerabilityFindingIdentifier[];
+    project_fingerprint: string;
+    uuid: string;
+    create_vulnerability_feedback_issue_path: string;
+    create_vulnerability_feedback_merge_request_path: string;
+    create_vulnerability_feedback_dismissal_path: string;
+    project: {
+        id: number;
+        name: string;
+        full_path: string;
+        full_name: string;
+    };
+    dismissal_feedback?: string;
+    issue_feedback?: string;
+    merge_request_feedback?: string;
+    description: string;
+    links?: {
+        url: string;
+    }[];
+    location: {
+        file: string;
+        dependency: {
+            package: {
+                name: string;
+            };
+            version: string;
+        };
+    };
+    details: {
+        [custom_field: string]: {
+            name: string;
+            type: string;
+            items?: VulnerabilityFindingDetailItem[];
+        };
+    };
+    solution: string;
+    blob_path: string;
+}
+export declare class VulnerabilityFindings<C extends boolean = false> extends BaseResource<C> {
+    all(projectId: string | number, options?: {
+        reportType?: string[];
+        scope?: string;
+        severity?: string[];
+        confidence?: string[];
+        pipelineId?: string | number;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, VulnerabilityFindingSchema>[]>;
+}

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

@@ -0,0 +1,15 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface WikiSchema extends Record<string, unknown> {
+    content: string;
+    format: string;
+    slug: string;
+    title: string;
+}
+export declare class Wikis<C extends boolean = false> extends BaseResource<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, WikiSchema>[]>;
+    create(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, WikiSchema>>;
+    edit(projectId: string | number, slug: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, WikiSchema>>;
+    show(projectId: string | number, slug: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, WikiSchema>>;
+    remove(projectId: string | number, slug: string, options?: Sudo): Promise<void>;
+}

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

@@ -0,0 +1,98 @@
+export { Groups } from './Groups';
+export { GroupAccessRequests } from './GroupAccessRequests';
+export { GroupBadges } from './GroupBadges';
+export { GroupCustomAttributes } from './GroupCustomAttributes';
+export { GroupIssueBoards } from './GroupIssueBoards';
+export { GroupMembers } from './GroupMembers';
+export { GroupMilestones } from './GroupMilestones';
+export { GroupRunners } from './GroupRunners';
+export { GroupVariables } from './GroupVariables';
+export { GroupLabels } from './GroupLabels';
+export { GroupDeployTokens } from './GroupDeployTokens';
+export { Epics } from './Epics';
+export { EpicIssues } from './EpicIssues';
+export { EpicNotes } from './EpicNotes';
+export { EpicDiscussions } from './EpicDiscussions';
+export { Users } from './Users';
+export { UserCustomAttributes } from './UserCustomAttributes';
+export { UserEmails } from './UserEmails';
+export { UserImpersonationTokens } from './UserImpersonationTokens';
+export { UserSSHKeys } from './UserSSHKeys';
+export { UserGPGKeys } from './UserGPGKeys';
+export { Branches } from './Branches';
+export { Commits } from './Commits';
+export { CommitDiscussions } from './CommitDiscussions';
+export { ContainerRegistry } from './ContainerRegistry';
+export { Deployments } from './Deployments';
+export { DeployKeys } from './DeployKeys';
+export { Environments } from './Environments';
+export { FreezePeriods } from './FreezePeriods';
+export { Issues } from './Issues';
+export { IssuesStatistics } from './IssuesStatistics';
+export { IssueNotes } from './IssueNotes';
+export { IssueNoteAwardEmojis } from './IssueNoteAwardEmojis';
+export { IssueDiscussions } from './IssueDiscussions';
+export { IssueAwardEmojis } from './IssueAwardEmojis';
+export { Jobs } from './Jobs';
+export { Labels } from './Labels';
+export { MergeRequests } from './MergeRequests';
+export { MergeRequestApprovals } from './MergeRequestApprovals';
+export { MergeRequestAwardEmojis } from './MergeRequestAwardEmojis';
+export { MergeRequestDiscussions } from './MergeRequestDiscussions';
+export { MergeRequestNotes } from './MergeRequestNotes';
+export { Packages } from './Packages';
+export { PackageRegistry } from './PackageRegistry';
+export { Pipelines } from './Pipelines';
+export { PipelineSchedules } from './PipelineSchedules';
+export { PipelineScheduleVariables } from './PipelineScheduleVariables';
+export { Projects } from './Projects';
+export { ProjectAccessRequests } from './ProjectAccessRequests';
+export { ProjectBadges } from './ProjectBadges';
+export { ProjectCustomAttributes } from './ProjectCustomAttributes';
+export { ProjectImportExport } from './ProjectImportExport';
+export { ProjectIssueBoards } from './ProjectIssueBoards';
+export { ProjectHooks } from './ProjectHooks';
+export { ProjectMembers } from './ProjectMembers';
+export { ProjectMilestones } from './ProjectMilestones';
+export { ProjectSnippets } from './ProjectSnippets';
+export { ProjectSnippetNotes } from './ProjectSnippetNotes';
+export { ProjectSnippetDiscussions } from './ProjectSnippetDiscussions';
+export { ProjectSnippetAwardEmojis } from './ProjectSnippetAwardEmojis';
+export { ProtectedBranches } from './ProtectedBranches';
+export { ProtectedTags } from './ProtectedTags';
+export { ProjectVariables } from './ProjectVariables';
+export { ProjectDeployTokens } from './ProjectDeployTokens';
+export { PushRules } from './PushRules';
+export { Releases } from './Releases';
+export { ReleaseLinks } from './ReleaseLinks';
+export { Repositories } from './Repositories';
+export { RepositoryFiles } from './RepositoryFiles';
+export { RepositorySubmodules } from './RepositorySubmodules';
+export { Runners } from './Runners';
+export { Services } from './Services';
+export { Tags } from './Tags';
+export { Todos } from './Todos';
+export { Triggers } from './Triggers';
+export { VulnerabilityFindings } from './VulnerabilityFindings';
+export { ApplicationSettings } from './ApplicationSettings';
+export { BroadcastMessages } from './BroadcastMessages';
+export { Events } from './Events';
+export { FeatureFlags } from './FeatureFlags';
+export { GeoNodes } from './GeoNodes';
+export { GitignoreTemplates } from './GitignoreTemplates';
+export { GitLabCIYMLTemplates } from './GitLabCIYMLTemplates';
+export { Keys } from './Keys';
+export { License } from './License';
+export { LicenseTemplates } from './LicenseTemplates';
+export { Lint } from './Lint';
+export { Namespaces } from './Namespaces';
+export { NotificationSettings } from './NotificationSettings';
+export { Markdown } from './Markdown';
+export { PagesDomains } from './PagesDomains';
+export { Search } from './Search';
+export { SidekiqMetrics } from './SidekiqMetrics';
+export { Snippets } from './Snippets';
+export { SystemHooks } from './SystemHooks';
+export { Version } from './Version';
+export { Wikis } from './Wikis';
+export { Gitlab } from './Gitlab';

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

@@ -0,0 +1,68 @@
+export { GroupSchema, GroupDetailSchema } from './Groups';
+export { GroupBadgeSchema } from './GroupBadges';
+export { GroupIssueBoardSchema } from './GroupIssueBoards';
+export { EpicSchema } from './Epics';
+export { EpicIssueSchema } from './EpicIssues';
+export { EpicNoteSchema } from './EpicNotes';
+export { UserSchema, UserExtendedSchema, UserActivitySchema } from './Users';
+export { UserEmailSchema } from './UserEmails';
+export { UserImpersonationTokenSchema, ImpersonationTokenScope, ImpersonationTokenState, } from './UserImpersonationTokens';
+export { UserSSHKeySchema } from './UserSSHKeys';
+export { UserGPGKeySchema } from './UserGPGKeys';
+export { BranchSchema } from './Branches';
+export { CommitAction, CommitSchema, CommitExtendedSchema, GPGSignatureSchema, X509SignatureSchema, MissingSignatureSchema, CommitSignatureSchema, CommentSchema, CommitDiffSchema, CommitStatusSchema, CommitReferenceSchema, } from './Commits';
+export { RegistryRepositoryTagSchema, RegistryRepositorySchema } from './ContainerRegistry';
+export { DeploymentStatus, DeployableSchema, DeploymentSchema } from './Deployments';
+export { DeployKeySchema } from './DeployKeys';
+export { EnvironmentSchema } from './Environments';
+export { FreezePeriodSchema } from './FreezePeriods';
+export { TimeStatsSchema, IssueSchema } from './Issues';
+export { StatisticsSchema } from './IssuesStatistics';
+export { IssueNoteSchema } from './IssueNotes';
+export { JobScope, ArtifactSchema, JobSchema, BridgeSchema } from './Jobs';
+export { AcceptMergeRequestOptions, ShowMergeRequestOptions, CreateMergeRequestOptions, UpdateMergeRequestOptions, AllMergeRequestsOptions, ReferenceSchema, TaskCompletionStatusSchema, RebaseSchema, DiffSchema, MergeRequestSchema, } from './MergeRequests';
+export { ProjectLevelMergeRequestApprovalSchema, ApprovedByEntity, MergeRequestLevelMergeRequestApprovalSchema, ApprovalRulesRequestOptions, ApprovalRuleSchema, ProjectLevelApprovalRuleSchema, MergeRequestLevelApprovalRuleSchema, } from './MergeRequestApprovals';
+export { MergeRequestNoteSchema } from './MergeRequestNotes';
+export { PackageSchema, PackageFileSchema } from './Packages';
+export { PipelineStatus, PipelineSchema, PipelineExtendedSchema, PipelineVariableSchema, } from './Pipelines';
+export { PipelineScheduleSchema } from './PipelineSchedules';
+export { ProjectSchema, ProjectExtendedSchema, ProjectFileUploadSchema, AccessSchema, SharedWithGroupSchema, } from './Projects';
+export { ProjectBadgeSchema } from './ProjectBadges';
+export { ExportStatusSchema, FailedRelationSchema, ImportStatusSchema, UploadMetadata, } from './ProjectImportExport';
+export { ProjectIssueBoardSchema } from './ProjectIssueBoards';
+export { ProjectHookSchema } from './ProjectHooks';
+export { ProjectSnippetSchema } from './ProjectSnippets';
+export { SnippetNoteSchema } from './ProjectSnippetNotes';
+export { ProtectedBranchAccessLevel, ProtectedBranchSchema } from './ProtectedBranches';
+export { ProtectedTagSchema, ProtectedTagAccessLevel } from './ProtectedTags';
+export { PushRulesSchema } from './PushRules';
+export { ReleaseEvidence, ReleaseAssetSource, ReleaseAssetLink, ReleaseSchema } from './Releases';
+export { ReleaseLinkSchema } from './ReleaseLinks';
+export { RepositoryCompareSchema, RepositoryContributorSchema, RepositoryTreeSchema, } from './Repositories';
+export { RepositoryFileExtendedSchema, RepositoryFileBlameSchema, RepositoryFileSchema, } from './RepositoryFiles';
+export { RepositorySubmoduleSchema } from './RepositorySubmodules';
+export { RunnerSchema, RunnerExtendedSchema } from './Runners';
+export { SupportedService, ServiceSchema } from './Services';
+export { TagSchema } from './Tags';
+export { TodoSchema } from './Todos';
+export { PipelineTriggerSchema } from './Triggers';
+export { VulnerabilityFindingSchema, VulnerabilityFindingDetailItem, VulnerabilityFindingIdentifier, } from './VulnerabilityFindings';
+export { ApplicationSettingsSchema } from './ApplicationSettings';
+export { BroadcastMessageSchema } from './BroadcastMessages';
+export { EventOptions, EventSchema } from './Events';
+export { FeatureFlagSchema, FeatureFlagStrategy, FeatureFlagStrategyScope } from './FeatureFlags';
+export { GeoNodeSchema, GeoNodeFailureSchema, GeoNodeStatusSchema } from './GeoNodes';
+export { KeySchema } from './Keys';
+export { LicenseSchema } from './License';
+export { LicenseTemplateSchema } from './LicenseTemplates';
+export { LintSchema } from './Lint';
+export { NamespaceSchema } from './Namespaces';
+export { NotificationSettingSchema, NotificationSettingLevel } from './NotificationSettings';
+export { MarkdownSchema } from './Markdown';
+export { PagesDomainSchema } from './PagesDomains';
+export { SearchResultSchema } from './Search';
+export { SidekickProcessMetricsSchema, ProcessMetricSchema, SidekickQueueMetricsSchema, SidekickJobStatsSchema, SidekickCompoundMetricsSchema, } from './SidekiqMetrics';
+export { SnippetVisibility, SnippetSchema, SnippetExtendedSchema, UserAgentDetailSchema, } from './Snippets';
+export { SystemHookSchema } from './SystemHooks';
+export { VersionSchema } from './Version';
+export { WikiSchema } from './Wikis';

package/dist/types/templates/ResourceAccessRequests.d.ts

@@ -0,0 +1,20 @@
+import { BaseResource, BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { Sudo } from '../infrastructure';
+export declare type AccessLevel = 0 | 5 | 10 | 20 | 30 | 40 | 50;
+export interface AccessRequestSchema extends Record<string, unknown> {
+    id: number;
+    username: string;
+    name: string;
+    state: string;
+    created_at: string;
+    requested_at: string;
+}
+export declare class ResourceAccessRequests<C extends boolean = false> extends BaseResource<C> {
+    constructor(resourceType: string, options: BaseResourceOptions<C>);
+    all(resourceId: string | number): Promise<import("../infrastructure").CamelizedRecord<C, AccessRequestSchema>[]>;
+    request(resourceId: string | number): Promise<import("../infrastructure").CamelizedRecord<C, AccessRequestSchema>>;
+    approve(resourceId: string | number, userId: number, options?: {
+        accessLevel?: AccessLevel;
+    } & Sudo): Promise<import("../infrastructure").CamelizedRecord<C, AccessRequestSchema>>;
+    deny(resourceId: string | number, userId: number): Promise<void>;
+}