@gitbeaker/core 34.4.0 → 34.4.1

package/dist/types/resources/EpicDiscussions.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 EpicDiscussions<C extends boolean = false> extends ResourceDiscussions<C> {
+    addNote(groupId: string | number, epicId: number, discussionId: number, noteId: number, body: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, DiscussionSchema>>;
+    all(groupId: string | number, epicId: number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, DiscussionSchema>[]>;
+    create(groupId: string | number, epicId: number, body: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, DiscussionSchema>>;
+    editNote(groupId: string | number, epicId: number, discussionId: number, noteId: number, options: BaseRequestOptions & {
+        body: string;
+    }): Promise<CamelizedRecord<C, DiscussionSchema>>;
+    removeNote(groupId: string | number, epicId: number, discussionId: number, noteId: number, options?: Sudo): Promise<void>;
+    show(groupId: string | number, epicId: number, discussionId: number, options?: Sudo): Promise<CamelizedRecord<C, DiscussionSchema>>;
+}
+export declare class EpicDiscussions<C extends boolean = false> extends ResourceDiscussions<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

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

@@ -0,0 +1,12 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { IssueSchema } from './Issues';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface EpicIssueSchema extends Omit<IssueSchema, 'references' | 'task_completion_status'> {
+    epic_issue_id: number;
+}
+export declare class EpicIssues<C extends boolean = false> extends BaseResource<C> {
+    all(groupId: string | number, epicIId: number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, EpicIssueSchema>[]>;
+    assign(groupId: string | number, epicIId: number, epicIssueId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, EpicIssueSchema>>;
+    edit(groupId: string | number, epicIId: number, epicIssueId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, EpicIssueSchema>>;
+    remove(groupId: string | number, epicIId: number, epicIssueId: number, options?: Sudo): Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceNotes } from '../templates';
+import { NoteSchema } from '../templates/types';
+import { PaginatedRequestOptions, BaseRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface EpicNoteSchema extends NoteSchema {
+    file_name: string;
+    expires_at: string;
+}
+export interface EpicNotes<C extends boolean = false> extends ResourceNotes<C> {
+    all(groupId: string | number, epicId: number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, EpicNoteSchema>[]>;
+    create(groupId: string | number, epicId: number, body: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, EpicNoteSchema>>;
+    edit(groupId: string | number, epicId: number, noteId: number, body: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, EpicNoteSchema>>;
+    remove(groupId: string | number, epicId: number, noteId: number, options?: Sudo): Promise<void>;
+    show(groupId: string | number, epicId: number, noteId: number, options?: Sudo): Promise<CamelizedRecord<C, EpicNoteSchema>>;
+}
+export declare class EpicNotes<C extends boolean = false> extends ResourceNotes<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

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

@@ -0,0 +1,47 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface EpicSchema extends Record<string, unknown> {
+    id: number;
+    iid: number;
+    group_id: number;
+    parent_id: number;
+    title: string;
+    description: string;
+    state: string;
+    confidential: string;
+    web_url: string;
+    reference: string;
+    references: {
+        short: string;
+        relative: string;
+        full: string;
+    };
+    author: Omit<UserSchema, 'created_at'>;
+    start_date?: string;
+    start_date_is_fixed: boolean;
+    start_date_fixed?: string;
+    start_date_from_inherited_source?: string;
+    due_date: string;
+    due_date_is_fixed: boolean;
+    due_date_fixed?: string;
+    due_date_from_inherited_source: string;
+    created_at: string;
+    updated_at: string;
+    closed_at: string;
+    labels?: string[];
+    upvotes: number;
+    downvotes: number;
+    _links: {
+        self: string;
+        epic_issues: string;
+        group: string;
+    };
+}
+export declare class Epics<C extends boolean = false> extends BaseResource<C> {
+    all(groupId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, EpicSchema>[]>;
+    create(groupId: string | number, title: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, EpicSchema>>;
+    edit(groupId: string | number, epicId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, EpicSchema>>;
+    remove(groupId: string | number, epicId: number, options?: Sudo): Promise<void>;
+    show(groupId: string | number, epicId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, EpicSchema>>;
+}

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

@@ -0,0 +1,29 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { PaginatedRequestOptions } from '../infrastructure';
+export interface EventOptions {
+    action?: 'created' | 'updated' | 'closed' | 'reopened' | 'pushed' | 'commented' | 'merged' | 'joined' | 'left' | 'destroyed' | 'expired';
+    targetType?: 'issue' | 'milestone' | 'merge_request' | 'note' | 'project' | 'snippet' | 'user';
+    before?: string;
+    after?: string;
+    scope?: string;
+    sort?: 'asc' | 'desc';
+}
+export interface EventSchema extends Record<string, unknown> {
+    id: number;
+    title?: string;
+    project_id: number;
+    action_name: string;
+    target_id: number;
+    target_type: string;
+    author_id: number;
+    target_title: string;
+    created_at: string;
+    author: Omit<UserSchema, 'created_at'>;
+    author_username: string;
+}
+export declare class Events<C extends boolean = false> extends BaseResource<C> {
+    all({ projectId, ...options }?: {
+        projectId?: string | number;
+    } & PaginatedRequestOptions & EventOptions): Promise<import("../infrastructure").CamelizedRecord<C, EventSchema>[]>;
+}

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

@@ -0,0 +1,33 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface FeatureFlagStrategyScope {
+    id: number;
+    environment_scope: string;
+}
+export interface FeatureFlagStrategy {
+    id: number;
+    name: string;
+    parameters: {
+        user_ids: string;
+    };
+    scopes?: FeatureFlagStrategyScope[];
+}
+export interface FeatureFlagSchema extends Record<string, unknown> {
+    name: string;
+    description: string;
+    active: boolean;
+    version: string;
+    created_at: string;
+    updated_at: string;
+    scopes?: string[];
+    strategies?: FeatureFlagStrategy[];
+}
+export declare class FeatureFlags<C extends boolean = false> extends BaseResource<C> {
+    all(projectId: string | number, options?: {
+        scopes?: 'enabled' | 'disabled';
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, FeatureFlagSchema>[]>;
+    create(projectId: string | number, flagName: string, version: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, FeatureFlagSchema>>;
+    edit(projectId: string | number, flagName: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, FeatureFlagSchema>>;
+    remove(projectId: string | number, flagName: string, options?: Sudo): Promise<void>;
+    show(projectId: string | number, flagName: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, FeatureFlagSchema>>;
+}

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

@@ -0,0 +1,17 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, Camelize } from '../infrastructure';
+export interface FreezePeriodSchema extends Record<string, unknown> {
+    id: number;
+    freeze_start: string;
+    freeze_end: string;
+    cron_timezone: string;
+    created_at: string;
+    updated_at: string;
+}
+export declare class FreezePeriods<C extends boolean = false> extends BaseResource<C> {
+    all(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, FreezePeriodSchema>[]>;
+    show(projectId: string | number, freezePeriodId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, FreezePeriodSchema>>;
+    create(projectId: number | string, freezeStart: string, freezeEnd: string, options?: Camelize<Pick<FreezePeriodSchema, 'cron_timezone'>> & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, FreezePeriodSchema>>;
+    edit(projectId: number | string, freezePeriodId: number, options?: Camelize<Omit<FreezePeriodSchema, 'id' | 'created_at' | 'updated_at'>> & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, FreezePeriodSchema>>;
+    delete(projectId: number | string, freezePeriodId: number, options?: BaseRequestOptions): Promise<void>;
+}

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

@@ -0,0 +1,143 @@
+import { BaseResource } from '@gitbeaker/requester-utils';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface GeoNodeSchema extends Record<string, unknown> {
+    id: number;
+    name: string;
+    url: string;
+    internal_url: string;
+    primary: boolean;
+    enabled: boolean;
+    current: boolean;
+    files_max_capacity: number;
+    repos_max_capacity: number;
+    verification_max_capacity: number;
+    selective_sync_type: string;
+    selective_sync_shards?: string[];
+    selective_sync_namespace_ids?: number[];
+    minimum_reverification_interval: number;
+    container_repositories_max_capacity: number;
+    sync_object_storage: boolean;
+    clone_protocol: string;
+    web_edit_url: string;
+    web_geo_projects_url: string;
+    _links: {
+        self: string;
+        status: string;
+        repair: string;
+    };
+}
+export interface GeoNodeFailureSchema extends Record<string, unknown> {
+    project_id: number;
+    last_repository_synced_at: string;
+    last_repository_successful_sync_at: string;
+    last_wiki_synced_at: string;
+    last_wiki_successful_sync_at: string;
+    repository_retry_count?: number;
+    wiki_retry_count: number;
+    last_repository_sync_failure?: string;
+    last_wiki_sync_failure: string;
+    last_repository_verification_failure: string;
+    last_wiki_verification_failure: string;
+    repository_verification_checksum_sha: string;
+    wiki_verification_checksum_sha: string;
+    repository_checksum_mismatch: boolean;
+    wiki_checksum_mismatch: boolean;
+}
+export interface GeoNodeStatusSchema extends Record<string, unknown> {
+    geo_node_id: number;
+    healthy: boolean;
+    health: string;
+    health_status: string;
+    missing_oauth_application: boolean;
+    attachments_count: number;
+    attachments_synced_count?: number;
+    attachments_failed_count?: number;
+    attachments_synced_missing_on_primary_count: number;
+    attachments_synced_in_percentage: string;
+    db_replication_lag_seconds?: number;
+    lfs_objects_count: number;
+    lfs_objects_synced_count?: number;
+    lfs_objects_failed_count?: number;
+    lfs_objects_synced_missing_on_primary_count: number;
+    lfs_objects_synced_in_percentage: string;
+    job_artifacts_count: number;
+    job_artifacts_synced_count?: number;
+    job_artifacts_failed_count?: number;
+    job_artifacts_synced_missing_on_primary_count: number;
+    job_artifacts_synced_in_percentage: string;
+    container_repositories_count: number;
+    container_repositories_synced_count?: number;
+    container_repositories_failed_count?: number;
+    container_repositories_synced_in_percentage: string;
+    design_repositories_count: number;
+    design_repositories_synced_count?: number;
+    design_repositories_failed_count?: number;
+    design_repositories_synced_in_percentage: string;
+    projects_count: number;
+    repositories_count: number;
+    repositories_failed_count?: number;
+    repositories_synced_count?: number;
+    repositories_synced_in_percentage: string;
+    wikis_count: number;
+    wikis_failed_count?: number;
+    wikis_synced_count?: number;
+    wikis_synced_in_percentage: string;
+    replication_slots_count: number;
+    replication_slots_used_count: number;
+    replication_slots_used_in_percentage: string;
+    replication_slots_max_retained_wal_bytes: number;
+    repositories_checked_count: number;
+    repositories_checked_failed_count: number;
+    repositories_checked_in_percentage: string;
+    repositories_checksummed_count: number;
+    repositories_checksum_failed_count: number;
+    repositories_checksummed_in_percentage: string;
+    wikis_checksummed_count: number;
+    wikis_checksum_failed_count: number;
+    wikis_checksummed_in_percentage: string;
+    repositories_verified_count: number;
+    repositories_verification_failed_count: number;
+    repositories_verified_in_percentage: string;
+    repositories_checksum_mismatch_count: number;
+    wikis_verified_count: number;
+    wikis_verification_failed_count: number;
+    wikis_verified_in_percentage: string;
+    wikis_checksum_mismatch_count: number;
+    repositories_retrying_verification_count: number;
+    wikis_retrying_verification_count: number;
+    last_event_id: number;
+    last_event_timestamp: number;
+    cursor_last_event_id?: number;
+    cursor_last_event_timestamp: number;
+    last_successful_status_check_timestamp: number;
+    version: string;
+    revision: string;
+    package_files_count: number;
+    package_files_checksummed_count: number;
+    package_files_checksum_failed_count: number;
+    package_files_registry_count: number;
+    package_files_synced_count: number;
+    package_files_failed_count: number;
+    snippet_repositories_count: number;
+    snippet_repositories_checksummed_count: number;
+    snippet_repositories_checksum_failed_count: number;
+    snippet_repositories_registry_count: number;
+    snippet_repositories_synced_count: number;
+    snippet_repositories_failed_count: number;
+    group_wiki_repositories_checksummed_count: number;
+    group_wiki_repositories_checksum_failed_count: number;
+    group_wiki_repositories_registry_count: number;
+    group_wiki_repositories_synced_count: number;
+    group_wiki_repositories_failed_count: number;
+}
+export declare class GeoNodes<C extends boolean = false> extends BaseResource<C> {
+    all(options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, GeoNodeSchema>[]>;
+    create(geonodeId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, GeoNodeSchema>>;
+    edit(geonodeId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, GeoNodeSchema>>;
+    failures(options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, GeoNodeFailureSchema>[]>;
+    repair(geonodeId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, GeoNodeSchema>>;
+    remove(geonodeId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, GeoNodeSchema>>;
+    show(geonodeId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, GeoNodeSchema>>;
+    status(geonodeId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, GeoNodeStatusSchema>>;
+    statuses(options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, GeoNodeStatusSchema>[]>;
+}

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

@@ -0,0 +1,5 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceTemplates } from '../templates';
+export declare class GitLabCIYMLTemplates<C extends boolean = false> extends ResourceTemplates<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

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

@@ -0,0 +1,5 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { ResourceTemplates } from '../templates';
+export declare class GitignoreTemplates<C extends boolean = false> extends ResourceTemplates<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

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

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

package/dist/types/resources/GroupAccessRequests.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 GroupAccessRequests<C extends boolean = false> extends ResourceAccessRequests<C> {
+    all(groupId: string | number): Promise<CamelizedRecord<C, AccessRequestSchema>[]>;
+    request(groupId: string | number): Promise<CamelizedRecord<C, AccessRequestSchema>>;
+    approve(groupId: string | number, userId: number, options?: {
+        accessLevel?: AccessLevel;
+    } & Sudo): Promise<CamelizedRecord<C, AccessRequestSchema>>;
+    deny(groupId: string | number, userId: number): Promise<void>;
+}
+export declare class GroupAccessRequests<C extends boolean = false> extends ResourceAccessRequests<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

package/dist/types/resources/GroupBadges.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 GroupBadgeSchema extends BadgeSchema {
+    kind: 'group';
+}
+export interface GroupBadges<C extends boolean = false> extends ResourceBadges<C> {
+    add(groupId: string | number, options?: BaseRequestOptions): Promise<CamelizedRecord<C, GroupBadgeSchema>>;
+    all(groupId: string | number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, GroupBadgeSchema>[]>;
+    edit(groupId: string | number, badgeId: number, options?: BaseRequestOptions): Promise<CamelizedRecord<C, GroupBadgeSchema>>;
+    preview(groupId: string | number, linkUrl: string, imageUrl: string, options?: Sudo): Promise<CamelizedRecord<C, Omit<GroupBadgeSchema, 'id' | 'name' | 'kind'>>>;
+    remove(groupId: string | number, badgeId: number, options?: Sudo): Promise<void>;
+    show(groupId: string | number, badgeId: number, options?: Sudo): Promise<CamelizedRecord<C, GroupBadgeSchema>>;
+}
+export declare class GroupBadges<C extends boolean = false> extends ResourceBadges<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

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

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

package/dist/types/resources/GroupDeployTokens.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 GroupDeployTokens<C extends boolean = false> extends ResourceDeployTokens<C> {
+    add(groupId: string | number, tokenName: string, tokenScopes: DeployTokenScope[], options?: BaseRequestOptions): Promise<CamelizedRecord<C, DeployTokenSchema>>;
+    all(options?: {
+        groupId?: string | number;
+    } & PaginatedRequestOptions): Promise<CamelizedRecord<C, DeployTokenSchema>[]>;
+    remove(groupId: string | number, tokenId: number, options?: Sudo): Promise<void>;
+}
+export declare class GroupDeployTokens<C extends boolean = false> extends ResourceDeployTokens<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

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

@@ -0,0 +1,23 @@
+import { BaseResourceOptions } from '@gitbeaker/requester-utils';
+import { GroupSchema } from './Groups';
+import { ResourceIssueBoards } from '../templates';
+import { IssueBoardSchema, IssueBoardListSchema } from '../templates/types';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface GroupIssueBoardSchema extends IssueBoardSchema {
+    group: Pick<GroupSchema, 'id' | 'name' | 'web_url'>;
+}
+export interface GroupIssueBoards<C extends boolean = false> extends ResourceIssueBoards<C> {
+    all(groupId: string | number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, IssueBoardSchema>[]>;
+    create(groupId: string | number, name: string, options?: Sudo): Promise<CamelizedRecord<C, GroupIssueBoardSchema>>;
+    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, GroupIssueBoardSchema>>;
+    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, GroupIssueBoardSchema>>;
+    showList(groupId: string | number, boardId: number, listId: number, options?: Sudo): Promise<CamelizedRecord<C, IssueBoardListSchema>>;
+}
+export declare class GroupIssueBoards<C extends boolean = false> extends ResourceIssueBoards<C> {
+    constructor(options: BaseResourceOptions<C>);
+}

package/dist/types/resources/GroupLabels.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 GroupLabels<C extends boolean = false> extends ResourceLabels<C> {
+    all(groupId: string | number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, LabelSchema>[]>;
+    create(groupId: string | number, labelName: string, color: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, LabelSchema>>;
+    edit(groupId: string | number, labelId: number | string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, LabelSchema>>;
+    remove(groupId: string | number, labelId: number | string, options?: Sudo): Promise<void>;
+    subscribe(groupId: string | number, labelId: number | string, options?: Sudo): Promise<CamelizedRecord<C, LabelSchema>>;
+    unsubscribe(groupId: string | number, labelId: number | string, options?: Sudo): Promise<CamelizedRecord<C, LabelSchema>>;
+}
+export declare class GroupLabels<C extends boolean = false> extends ResourceLabels<C> {
+    constructor(options: BaseResourceOptions<C>);
+}