@gitbeaker/core - npm Package Compare versions

Comparing version 28.4.1 to 29.0.0--canary.1104.301157685.0

CHANGELOG.md

@@ -1,40 +0,1 @@
-# v28.4.0 (Tue May 04 2021)
-
-:tada: This release contains work from a new contributor! :tada:
-
-Thank you, null[@divido](https://github.com/divido), for all your work!
-
-#### 🐛 Bug Fix
-
-- Change Issues.unsubscribe to a POST operation instead of DELETE [#1726](https://github.com/jdalrymple/gitbeaker/pull/1726) ([@divido](https://github.com/divido) [@jdalrymple](https://github.com/jdalrymple))
-
-#### 🔩 Dependency Updates
-
-- chore(deps-dev): bump @types/node from 14.14.41 to 15.0.1 [#1719](https://github.com/jdalrymple/gitbeaker/pull/1719) ([@dependabot-preview[bot]](https://github.com/dependabot-preview[bot]))
-
-#### Authors: 3
-
-- [@dependabot-preview[bot]](https://github.com/dependabot-preview[bot])
-- [@divido](https://github.com/divido)
-- Justin Dalrymple ([@jdalrymple](https://github.com/jdalrymple))
-
----
-
-# v28.1.0 (Sun Mar 14 2021)
-
-#### 🐛 Bug Fix
-
-- Package updates to fix build pipeline \[skip ci\] ([@jdalrymple](https://github.com/jdalrymple))
-
-#### 🔩 Dependency Updates
-
-- chore(deps): bump form-data from 3.0.0 to 4.0.0 [#1558](https://github.com/jdalrymple/gitbeaker/pull/1558) ([@dependabot-preview[bot]](https://github.com/dependabot-preview[bot]))
-
-#### Authors: 2
-
-- [@dependabot-preview[bot]](https://github.com/dependabot-preview[bot])
-- Justin Dalrymple ([@jdalrymple](https://github.com/jdalrymple))
-
----
-
 # vnull (Sun Jan 03 2021)
@@ -41,0 +2,0 @@

dist/types/index.d.ts

@@ -12,3 +12,2 @@ import * as APIServices from './services';
     GroupMilestones: typeof APIServices.GroupMilestones;
-    GroupProjects: typeof APIServices.GroupProjects;
     GroupRunners: typeof APIServices.GroupRunners;
@@ -22,3 +21,3 @@ GroupVariables: typeof APIServices.GroupVariables;
     EpicDiscussions: typeof APIServices.EpicDiscussions;
-}, "Groups" | "GroupAccessRequests" | "GroupBadges" | "GroupCustomAttributes" | "GroupIssueBoards" | "GroupMembers" | "GroupMilestones" | "GroupProjects" | "GroupRunners" | "GroupVariables" | "GroupLabels" | "GroupDeployTokens" | "Epics" | "EpicIssues" | "EpicNotes" | "EpicDiscussions">;
+}, "Groups" | "GroupAccessRequests" | "GroupBadges" | "GroupCustomAttributes" | "GroupIssueBoards" | "GroupMembers" | "GroupMilestones" | "GroupRunners" | "GroupVariables" | "GroupLabels" | "GroupDeployTokens" | "Epics" | "EpicIssues" | "EpicNotes" | "EpicDiscussions">;
 export declare const UsersBundle: import("./infrastructure").BundleType<{
@@ -29,5 +28,5 @@ Users: typeof APIServices.Users;
     UserImpersonationTokens: typeof APIServices.UserImpersonationTokens;
-    UserKeys: typeof APIServices.UserKeys;
+    UserSSHKeys: typeof APIServices.UserSSHKeys;
     UserGPGKeys: typeof APIServices.UserGPGKeys;
-}, "Users" | "UserCustomAttributes" | "UserEmails" | "UserImpersonationTokens" | "UserKeys" | "UserGPGKeys">;
+}, "Users" | "UserCustomAttributes" | "UserEmails" | "UserImpersonationTokens" | "UserSSHKeys" | "UserGPGKeys">;
 export declare const ProjectsBundle: import("./infrastructure").BundleType<{
@@ -87,3 +86,3 @@ Branches: typeof APIServices.Branches;
 }, "Branches" | "Commits" | "CommitDiscussions" | "ContainerRegistry" | "DeployKeys" | "Deployments" | "Environments" | "FreezePeriods" | "Issues" | "IssuesStatistics" | "IssueAwardEmojis" | "IssueNotes" | "IssueDiscussions" | "Jobs" | "Labels" | "MergeRequests" | "MergeRequestApprovals" | "MergeRequestAwardEmojis" | "MergeRequestDiscussions" | "MergeRequestNotes" | "Packages" | "Pipelines" | "PipelineSchedules" | "PipelineScheduleVariables" | "Projects" | "ProjectAccessRequests" | "ProjectBadges" | "ProjectCustomAttributes" | "ProjectImportExport" | "ProjectIssueBoards" | "ProjectHooks" | "ProjectMembers" | "ProjectMilestones" | "ProjectSnippets" | "ProjectSnippetNotes" | "ProjectSnippetDiscussions" | "ProjectSnippetAwardEmojis" | "ProtectedBranches" | "ProtectedTags" | "ProjectVariables" | "ProjectDeployTokens" | "PushRules" | "Releases" | "ReleaseLinks" | "Repositories" | "RepositoryFiles" | "Runners" | "Services" | "Tags" | "Todos" | "Triggers" | "VulnerabilityFindings">;
-export declare const Gitlab: import("./infrastructure").BundleType<typeof APIServices, "Groups" | "GroupAccessRequests" | "GroupBadges" | "GroupCustomAttributes" | "GroupIssueBoards" | "GroupMembers" | "GroupMilestones" | "GroupProjects" | "GroupRunners" | "GroupVariables" | "GroupLabels" | "GroupDeployTokens" | "Epics" | "EpicIssues" | "EpicNotes" | "EpicDiscussions" | "Users" | "UserCustomAttributes" | "UserEmails" | "UserImpersonationTokens" | "UserKeys" | "UserGPGKeys" | "Branches" | "Commits" | "CommitDiscussions" | "ContainerRegistry" | "DeployKeys" | "Deployments" | "Environments" | "FreezePeriods" | "Issues" | "IssuesStatistics" | "IssueAwardEmojis" | "IssueNotes" | "IssueDiscussions" | "Jobs" | "Labels" | "MergeRequests" | "MergeRequestApprovals" | "MergeRequestAwardEmojis" | "MergeRequestDiscussions" | "MergeRequestNotes" | "Packages" | "Pipelines" | "PipelineSchedules" | "PipelineScheduleVariables" | "Projects" | "ProjectAccessRequests" | "ProjectBadges" | "ProjectCustomAttributes" | "ProjectImportExport" | "ProjectIssueBoards" | "ProjectHooks" | "ProjectMembers" | "ProjectMilestones" | "ProjectSnippets" | "ProjectSnippetNotes" | "ProjectSnippetDiscussions" | "ProjectSnippetAwardEmojis" | "ProtectedBranches" | "ProtectedTags" | "ProjectVariables" | "ProjectDeployTokens" | "PushRules" | "Releases" | "ReleaseLinks" | "Repositories" | "RepositoryFiles" | "Runners" | "Services" | "Tags" | "Todos" | "Triggers" | "VulnerabilityFindings" | "ApplicationSettings" | "BroadcastMessages" | "Events" | "FeatureFlags" | "GeoNodes" | "GitignoreTemplates" | "GitLabCIYMLTemplates" | "Keys" | "License" | "LicenceTemplates" | "Lint" | "Namespaces" | "NotificationSettings" | "Markdown" | "PagesDomains" | "Search" | "SidekiqMetrics" | "Snippets" | "SystemHooks" | "Version" | "Wikis">;
+export declare const Gitlab: import("./infrastructure").BundleType<typeof APIServices, "Groups" | "GroupAccessRequests" | "GroupBadges" | "GroupCustomAttributes" | "GroupIssueBoards" | "GroupMembers" | "GroupMilestones" | "GroupRunners" | "GroupVariables" | "GroupLabels" | "GroupDeployTokens" | "Epics" | "EpicIssues" | "EpicNotes" | "EpicDiscussions" | "Users" | "UserCustomAttributes" | "UserEmails" | "UserImpersonationTokens" | "UserSSHKeys" | "UserGPGKeys" | "Branches" | "Commits" | "CommitDiscussions" | "ContainerRegistry" | "DeployKeys" | "Deployments" | "Environments" | "FreezePeriods" | "Issues" | "IssuesStatistics" | "IssueAwardEmojis" | "IssueNotes" | "IssueDiscussions" | "Jobs" | "Labels" | "MergeRequests" | "MergeRequestApprovals" | "MergeRequestAwardEmojis" | "MergeRequestDiscussions" | "MergeRequestNotes" | "Packages" | "Pipelines" | "PipelineSchedules" | "PipelineScheduleVariables" | "Projects" | "ProjectAccessRequests" | "ProjectBadges" | "ProjectCustomAttributes" | "ProjectImportExport" | "ProjectIssueBoards" | "ProjectHooks" | "ProjectMembers" | "ProjectMilestones" | "ProjectSnippets" | "ProjectSnippetNotes" | "ProjectSnippetDiscussions" | "ProjectSnippetAwardEmojis" | "ProtectedBranches" | "ProtectedTags" | "ProjectVariables" | "ProjectDeployTokens" | "PushRules" | "Releases" | "ReleaseLinks" | "Repositories" | "RepositoryFiles" | "Runners" | "Services" | "Tags" | "Todos" | "Triggers" | "VulnerabilityFindings" | "ApplicationSettings" | "BroadcastMessages" | "Events" | "FeatureFlags" | "GeoNodes" | "GitignoreTemplates" | "GitLabCIYMLTemplates" | "Keys" | "License" | "LicenseTemplates" | "Lint" | "Namespaces" | "NotificationSettings" | "Markdown" | "PagesDomains" | "Search" | "SidekiqMetrics" | "Snippets" | "SystemHooks" | "Version" | "Wikis">;
 export declare type UsersBundle = InstanceType<typeof UsersBundle>;
@@ -90,0 +89,0 @@ export declare type GroupsBundle = InstanceType<typeof GroupsBundle>;

dist/types/infrastructure/RequestHelper.d.ts

 /// <reference types="node" />
 import { BaseService } from '@gitbeaker/requester-utils';
-export declare type True = true;
-export declare type False = false;
-export interface PaginationInformation {
-    total: number;
-    next: number | null;
-    current: number;
-    previous: number | null;
-    perPage: number;
-    totalPages: number;
-}
-export interface Sudo {
+import { Camelize } from './Utils';
+export declare type IsForm = {
+    isForm?: boolean;
+};
+export declare type Sudo = {
     sudo?: string | number;
-}
-export interface IsForm {
-    isForm?: boolean;
-}
-export interface ShowExpanded {
-    showExpanded?: boolean;
-}
-export declare type BaseRequestOptions = Sudo & Record<string, any>;
-export interface PaginatedRequestOptions extends BaseRequestOptions {
-    pagination?: 'keyset' | 'offset';
+};
+export declare type ShowExpanded<T extends boolean = boolean> = {
+    showExpanded?: T;
+};
+export declare type BaseRequestOptions = Sudo & Record<string, unknown>;
+export declare type BasePaginationRequestOptions<P extends 'keyset' | 'offset' = 'keyset' | 'offset'> = BaseRequestOptions & {
+    pagination?: P;
     perPage?: number;
-}
-export interface OffsetPaginatedRequestOptions extends PaginatedRequestOptions {
-    pagination: 'offset';
+};
+export declare type OffsetPaginationRequestOptions = {
     page?: number;
     maxPages?: number;
-}
+};
+export declare type PaginatedRequestOptions<P extends 'keyset' | 'offset' = 'keyset' | 'offset'> = P extends 'keyset' ? BasePaginationRequestOptions<P> : BasePaginationRequestOptions<P> & OffsetPaginationRequestOptions;
 export interface ExpandedResponse<T = Record<string, unknown>> {
@@ -39,22 +30,20 @@ data: T;
     data: T;
-    paginationInfo: PaginationInformation;
+    paginationInfo: {
+        total: number;
+        next: number | null;
+        current: number;
+        previous: number | null;
+        perPage: number;
+        totalPages: number;
+    };
 }
-export declare function get<T = Record<string, unknown>>(service: BaseService, endpoint: string, options?: BaseRequestOptions): Promise<T | T[]>;
-export declare function get<T = Record<string, unknown>>(service: BaseService, endpoint: string, options?: PaginatedRequestOptions): Promise<ExpandedResponse<T> | PaginationResponse<T>>;
-export declare function get<T = Record<string, unknown>>(service: BaseService, endpoint: string, options?: OffsetPaginatedRequestOptions & {
-    showExpanded: true;
-}): Promise<ExpandedResponse<T> | PaginationResponse<T>>;
-declare function post<T = Record<string, unknown>>(service: BaseService, endpoint: string, options?: IsForm & BaseRequestOptions): Promise<T>;
-declare function post<T = Record<string, unknown>>(service: BaseService, endpoint: string, options?: IsForm & BaseRequestOptions & {
-    showExpanded: true;
-}): Promise<ExpandedResponse<T>>;
-declare function put<T = Record<string, unknown>>(service: BaseService, endpoint: string, options?: BaseRequestOptions): Promise<T>;
-declare function put<T = Record<string, unknown>>(service: BaseService, endpoint: string, { showExpanded }: BaseRequestOptions & {
-    showExpanded: true;
-}): Promise<ExpandedResponse<T>>;
-declare function del<T = Record<string, unknown>>(service: BaseService, endpoint: string, options?: BaseRequestOptions): Promise<T>;
-declare function del<T = Record<string, unknown>>(service: BaseService, endpoint: string, { showExpanded }: BaseRequestOptions & {
-    showExpanded: true;
-}): Promise<ExpandedResponse<T>>;
-declare function stream(service: BaseService, endpoint: string, options?: BaseRequestOptions): NodeJS.ReadableStream;
+export declare type CamelizedRecord<C, T> = C extends true ? Camelize<T> : T;
+export declare type ExtendedRecordReturn<C extends boolean, E extends boolean, T extends Record<string, unknown> | void> = T extends void ? void : E extends false ? CamelizedRecord<C, T> : ExpandedResponse<CamelizedRecord<C, T>>;
+declare type ExtendedArrayReturn<C extends boolean, E extends boolean, T, P extends 'keyset' | 'offset'> = E extends false ? CamelizedRecord<C, T>[] : P extends 'keyset' ? CamelizedRecord<C, T>[] : PaginationResponse<CamelizedRecord<C, T>[]>;
+declare type ExtendedReturn<C extends boolean, E extends boolean, P extends 'keyset' | 'offset', T extends Record<string, unknown> | Record<string, unknown>[]> = T extends Record<string, unknown> ? ExtendedRecordReturn<C, E, T> : T extends (infer R)[] ? ExtendedArrayReturn<C, E, R, P> : never;
+export declare function get<T extends Record<string, unknown> | Record<string, unknown>[] = Record<string, unknown>>(): <C extends boolean, P extends "keyset" | "offset" = "offset", E extends boolean = false>(service: BaseService<C>, endpoint: string, options?: (PaginatedRequestOptions<P> & ShowExpanded<E> & Record<string, any>) | undefined) => Promise<ExtendedReturn<C, E, P, T>>;
+export declare function post<T extends Record<string, unknown> | void = Record<string, unknown>>(): <C extends boolean, E extends boolean = false>(service: BaseService<C>, endpoint: string, { isForm, sudo, showExpanded, ...options }?: IsForm & Sudo & Record<string, unknown> & ShowExpanded<E>) => Promise<ExtendedRecordReturn<C, E, T>>;
+export declare function put<T extends Record<string, unknown> = Record<string, unknown>>(): <C extends boolean, E extends boolean = false>(service: BaseService<C>, endpoint: string, { isForm, sudo, showExpanded, ...options }?: IsForm & Sudo & Record<string, unknown> & ShowExpanded<E>) => Promise<ExtendedRecordReturn<C, E, T>>;
+export declare function del<T extends Record<string, unknown> | void = void>(): <C extends boolean, E extends boolean = false>(service: BaseService<C>, endpoint: string, { sudo, showExpanded, ...query }?: Sudo & Record<string, unknown> & ShowExpanded<E>) => Promise<ExtendedRecordReturn<C, E, T>>;
+declare function stream<C extends boolean>(service: BaseService<C>, endpoint: string, options?: BaseRequestOptions): NodeJS.ReadableStream;
 export declare const RequestHelper: {
@@ -61,0 +50,0 @@ post: typeof post;

dist/types/infrastructure/Utils.d.ts

 import FormData from 'form-data';
+export declare type CamelizeString<T extends PropertyKey> = T extends string ? string extends T ? string : T extends `${infer F}_${infer R}` ? `${F}${Capitalize<CamelizeString<R>>}` : T : T;
+export declare type Camelize<T> = {
+    [K in keyof T as CamelizeString<K>]: T[K];
+};
 interface Constructor {
@@ -3,0 +7,0 @@ new (...args: any): any;

dist/types/services/ApplicationSettings.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { Sudo, BaseRequestOptions } from '../infrastructure';
-export declare class ApplicationSettings extends BaseService {
-    all(options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    edit(options?: BaseRequestOptions): Promise<Record<string, unknown>>;
+export interface SettingsSchema extends Record<string, unknown> {
+    default_projects_limit: number;
+    signup_enabled: boolean;
+    id: number;
+    default_branch_protection: number;
+    restricted_visibility_levels?: string[];
+    password_authentication_enabled_for_web: boolean;
+    after_sign_out_path?: string;
+    max_attachment_size: number;
+    max_import_size: number;
+    user_oauth_applications: boolean;
+    updated_at: string;
+    session_expire_delay: number;
+    home_page_url?: string;
+    default_snippet_visibility: string;
+    outbound_local_requests_whitelist?: string[];
+    domain_allowlist?: string[];
+    domain_denylist_enabled: boolean;
+    domain_denylist?: string[];
+    created_at: string;
+    default_ci_config_path?: string;
+    default_project_visibility: string;
+    default_group_visibility: string;
+    gravatar_enabled: boolean;
+    sign_in_text?: string;
+    container_expiration_policies_enable_historic_entries: boolean;
+    container_registry_token_expire_delay: number;
+    repository_storages_weighted: {
+        [name: string]: number;
+    };
+    plantuml_enabled: boolean;
+    plantuml_url?: string;
+    kroki_enabled: boolean;
+    kroki_url?: string;
+    terminal_max_session_time: number;
+    polling_interval_multiplier: number;
+    rsa_key_restriction: number;
+    dsa_key_restriction: number;
+    ecdsa_key_restriction: number;
+    ed25519_key_restriction: number;
+    first_day_of_week: number;
+    enforce_terms: boolean;
+    terms: string;
+    performance_bar_allowed_group_id: number;
+    user_show_add_ssh_key_message: boolean;
+    local_markdown_version: number;
+    allow_local_requests_from_hooks_and_services: boolean;
+    allow_local_requests_from_web_hooks_and_services: boolean;
+    allow_local_requests_from_system_hooks: boolean;
+    asset_proxy_enabled: boolean;
+    asset_proxy_url: string;
+    asset_proxy_whitelist?: string[];
+    asset_proxy_allowlist?: string[];
+    npm_package_requests_forwarding: boolean;
+    snippet_size_limit: number;
+    issues_create_limit: number;
+    raw_blob_request_limit: number;
+    wiki_page_max_content_bytes: number;
+    require_admin_approval_after_user_signup: boolean;
+    personal_access_token_prefix: string;
+    rate_limiting_response_text?: string;
+    keep_latest_artifact: boolean;
 }
+export declare class ApplicationSettings<C extends boolean = false> extends BaseService<C> {
+    all(options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, SettingsSchema>>;
+    edit(options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, SettingsSchema>>;
+}

dist/types/services/Branches.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
-import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class Branches extends BaseService {
-    all(projectId: string | number, options?: {
-        search?: string;
-    } & PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(projectId: string | number, branchName: string, ref: string, options?: Sudo): Promise<Record<string, unknown>>;
-    protect(projectId: string | number, branchName: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, branchName: string, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, branchName: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    unprotect(projectId: string | number, branchName: string, options?: Sudo): Promise<Record<string, unknown>>;
+import { CommitSchema } from './Commits';
+import { PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface BranchSchema extends Record<string, unknown> {
+    name: string;
+    merged: boolean;
+    protected: boolean;
+    default: boolean;
+    developers_can_push: boolean;
+    developers_can_merge: boolean;
+    can_push: boolean;
+    web_url: string;
+    commit: Omit<CommitSchema, 'web_url' | 'created_at'>;
 }
+export declare class Branches<C extends boolean = false> extends BaseService<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, BranchSchema>[]>;
+    create(projectId: string | number, branchName: string, ref: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, BranchSchema>>;
+    remove(projectId: string | number, branchName: string, options?: Sudo): Promise<void>;
+    show(projectId: string | number, branchName: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, BranchSchema>>;
+}

dist/types/services/BroadcastMessages.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
-import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class BroadcastMessages extends BaseService {
-    all(options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(broadcastMessageId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(broadcastMessageId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(broadcastMessageId: number, options?: BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo, Camelize } from '../infrastructure';
+export interface BroadcastMessageSchema extends Record<string, unknown> {
+    message: string;
+    starts_at: string;
+    ends_at: string;
+    color: string;
+    font: string;
+    id: number;
+    active: boolean;
+    target_path: string;
+    broadcast_type: string;
+    dismissable: boolean;
 }
+export declare class BroadcastMessages<C extends boolean = false> extends BaseService<C> {
+    all(options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, BroadcastMessageSchema>[]>;
+    create(options?: Camelize<Omit<BroadcastMessageSchema, 'id'>> & Sudo): Promise<import("../infrastructure").CamelizedRecord<C, BroadcastMessageSchema>>;
+    edit(broadcastMessageId: number, options?: Camelize<Omit<BroadcastMessageSchema, 'id'>> & Sudo): Promise<import("../infrastructure").CamelizedRecord<C, BroadcastMessageSchema>>;
+    remove(broadcastMessageId: number, options?: Sudo): Promise<void>;
+    show(broadcastMessageId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, BroadcastMessageSchema>>;
+}

dist/types/services/CommitDiscussions.d.ts

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

dist/types/services/Commits.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { MergeRequestSchema } from './MergeRequests';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export interface CommitSchemaDefault {
+export interface CommitAction {
+    /** The action to perform */
+    action: 'create' | 'delete' | 'move' | 'update';
+    /** Full path to the file. Ex. lib/class.rb */
+    filePath: string;
+    /** Original full path to the file being moved.Ex.lib / class1.rb */
+    previousPath?: string;
+    /** File content, required for all except delete. Optional for move */
+    content?: string;
+    /** text or base64. text is default. */
+    encoding?: string;
+    /** Last known file commit id. Will be only considered in update, move and delete actions. */
+    lastCommitId?: string;
+}
+export interface CommitSchema extends Record<string, unknown> {
     id: string;
@@ -16,33 +32,19 @@ short_id: string;
     committed_date?: Date;
+    web_url: string;
 }
-export interface CommitSchemaCamelized {
-    id: string;
-    shortId: string;
-    createdAt: Date;
-    parentIds?: string[];
-    title: string;
-    message: string;
-    authorName: string;
-    authorEmail: string;
-    authoredDate?: Date;
-    committerName?: string;
-    committerEmail?: string;
-    committedDate?: Date;
+export interface CommitExtendedSchema extends CommitSchema {
+    last_pipeline: {
+        id: number;
+        ref: string;
+        sha: string;
+        status: string;
+    };
+    stats: {
+        additions: number;
+        deletions: number;
+        total: number;
+    };
+    status: string;
 }
-export declare type CommitSchema = CommitSchemaDefault | CommitSchemaCamelized;
-export interface CommitAction {
-    /** The action to perform */
-    action: 'create' | 'delete' | 'move' | 'update';
-    /** Full path to the file. Ex. lib/class.rb */
-    filePath: string;
-    /** Original full path to the file being moved.Ex.lib / class1.rb */
-    previousPath?: string;
-    /** File content, required for all except delete. Optional for move */
-    content?: string;
-    /** text or base64. text is default. */
-    encoding?: string;
-    /** Last known file commit id. Will be only considered in update, move and delete actions. */
-    lastCommitId?: string;
-}
-export interface GPGSignature {
+export interface GPGSignatureSchema extends Record<string, unknown> {
     signature_type: 'PGP';
@@ -54,6 +56,6 @@ verification_status: 'verified' | 'unverified';
     gpg_key_user_email: string;
-    gpg_key_subkey_id: number | null;
+    gpg_key_subkey_id?: number;
     commit_source: string;
 }
-export interface X509Signature {
+export interface X509SignatureSchema extends Record<string, unknown> {
     signature_type: 'X509';
@@ -77,20 +79,55 @@ verification_status: 'verified' | 'unverified';
 }
-export interface MissingSignature {
+export interface MissingSignatureSchema extends Record<string, unknown> {
     message: string;
 }
-export declare type CommitSignature = GPGSignature | X509Signature | MissingSignature;
-export declare class Commits extends BaseService {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    cherryPick(projectId: string | number, sha: string, branch: string, options?: Sudo): Promise<Record<string, unknown>>;
-    comments(projectId: string | number, sha: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(projectId: string | number, branch: string, message: string, actions?: CommitAction[], options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    createComment(projectId: string | number, sha: string, note: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    diff(projectId: string | number, sha: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    editStatus(projectId: string | number, sha: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    references(projectId: string | number, sha: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    revert(projectId: string | number, sha: string, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, sha: string, options?: BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    status(projectId: string | number, sha: string, options?: BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    mergeRequests(projectId: string | number, sha: string, options?: BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    signature(projectId: string | number, sha: string, options?: BaseRequestOptions): Promise<CommitSignature>;
+export declare type CommitSignatureSchema = GPGSignatureSchema | X509SignatureSchema | MissingSignatureSchema;
+export interface CommentSchema extends Record<string, unknown> {
+    note: string;
+    line_type: 'new' | 'old';
+    path: string;
+    line: number;
+    author: Omit<UserSchema, 'created_at'>;
 }
+export interface CommitDiffSchema extends Record<string, unknown> {
+    diff: string;
+    new_path: string;
+    old_path: string;
+    a_mode?: string;
+    b_mode: string;
+    new_file: boolean;
+    renamed_file: boolean;
+    deleted_file: boolean;
+}
+export interface CommitStatusSchema extends Record<string, unknown> {
+    status: string;
+    created_at: string;
+    started_at?: string;
+    name: string;
+    allow_failure: boolean;
+    author: Omit<UserSchema, 'created_at'>;
+    description?: string;
+    sha: string;
+    target_url: string;
+    finished_at?: string;
+    id: number;
+    ref: string;
+}
+export interface CommitReferenceSchema extends Record<string, unknown> {
+    type: 'branch' | 'tag' | 'all';
+    name: string;
+}
+export declare class Commits<C extends boolean = false> extends BaseService<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, CommitSchema>[]>;
+    cherryPick(projectId: string | number, sha: string, branch: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, CommitSchema>>;
+    comments(projectId: string | number, sha: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, CommentSchema>[]>;
+    create(projectId: string | number, branch: string, message: string, actions?: CommitAction[], options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, CommitExtendedSchema>>;
+    createComment(projectId: string | number, sha: string, note: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, CommentSchema>>;
+    diff(projectId: string | number, sha: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, CommitDiffSchema>>;
+    editStatus(projectId: string | number, sha: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, CommitStatusSchema>>;
+    references(projectId: string | number, sha: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, CommitReferenceSchema>[]>;
+    revert(projectId: string | number, sha: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, CommitSchema>>;
+    show(projectId: string | number, sha: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, CommitExtendedSchema>>;
+    statuses(projectId: string | number, sha: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, CommitStatusSchema>[]>;
+    mergeRequests(projectId: string | number, sha: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>>;
+    signature(projectId: string | number, sha: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, GPGSignatureSchema> | import("../infrastructure").CamelizedRecord<C, X509SignatureSchema> | import("../infrastructure").CamelizedRecord<C, MissingSignatureSchema>>;
+}

dist/types/services/ContainerRegistry.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class ContainerRegistry extends BaseService {
-    repositories(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    tags(projectId: string | number, repositoryId: number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    removeRepository(projectId: string | number, repositoryId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    removeTag(projectId: string | number, repositoryId: number, tagName: string, options?: Sudo): Promise<Record<string, unknown>>;
+export interface TagSchema extends Record<string, unknown> {
+    name: string;
+    path: string;
+    location: string;
+    revision: string;
+    short_revision: string;
+    digest: string;
+    created_at: string;
+    total_size: number;
+}
+export interface RepositorySchema extends Record<string, unknown> {
+    id: number;
+    name: string;
+    path: string;
+    project_id: number;
+    location: string;
+    created_at: string;
+    cleanup_policy_started_at: string;
+    tags_count?: number;
+    tags?: Pick<TagSchema, 'name' | 'path' | 'location'>[];
+}
+export declare class ContainerRegistry<C extends boolean = false> extends BaseService<C> {
+    projectRepositories(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Omit<RepositorySchema, "tags" | "tags_count">>[]>;
+    groupRepositories(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Omit<RepositorySchema, "tags" | "tags_count">>[]>;
+    showRepository(projectId: string | number, repositoryId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, RepositorySchema>>;
+    tags(projectId: string | number, repositoryId: number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Pick<TagSchema, "name" | "path" | "location">>[]>;
+    removeRepository(projectId: string | number, repositoryId: number, options?: Sudo): Promise<void>;
+    removeTag(projectId: string | number, repositoryId: number, tagName: string, options?: Sudo): Promise<void>;
     removeTags(projectId: string | number, repositoryId: number, nameRegexDelete: string, options?: Sudo & {
@@ -12,4 +35,4 @@ nameRegexKeep: string;
         olderThan: string;
-    }): Promise<Record<string, unknown>>;
-    showTag(projectId: string | number, repositoryId: number, tagName: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    }): Promise<void>;
+    showTag(projectId: string | number, repositoryId: number, tagName: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TagSchema>>;
 }

dist/types/services/DeployKeys.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { Sudo, BaseRequestOptions, PaginatedRequestOptions } from '../infrastructure';
-export declare class DeployKeys extends BaseService {
-    add(projectId: string | number, options?: Sudo): Promise<Record<string, unknown>>;
+export interface DeployKey extends Record<string, unknown> {
+    id: number;
+    title: string;
+    key: string;
+    can_push?: boolean;
+    created_at: string;
+}
+export declare class DeployKeys<C extends boolean = false> extends BaseService<C> {
+    add(projectId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, DeployKey>>;
     all({ projectId, ...options }?: {
         projectId?: string | number;
-    } & PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    edit(projectId: string | number, keyId: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    enable(projectId: string | number, keyId: string, options?: Sudo): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, keyId: string, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, keyId: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Omit<DeployKey, "can_push">>[]>;
+    edit(projectId: string | number, keyId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, DeployKey>>;
+    enable(projectId: string | number, keyId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Omit<DeployKey, "can_push">>>;
+    remove(projectId: string | number, keyId: number, options?: Sudo): Promise<void>;
+    show(projectId: string | number, keyId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, DeployKey>>;
 }

dist/types/services/Deployments.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { PaginatedRequestOptions, Sudo } from '../infrastructure';
-import { CommitSchemaDefault, CommitSchemaCamelized } from './Commits';
-import { PipelineSchemaDefault, PipelineSchemaCamelized } from './Pipelines';
-import { UserSchemaDefault, UserSchemaCamelized } from './Users';
-import { RunnerSchemaDefault, RunnerSchemaCamelized } from './Runners';
+import { CommitSchema } from './Commits';
+import { PipelineSchema } from './Pipelines';
+import { UserSchema } from './Users';
+import { RunnerSchema } from './Runners';
+import { EnvironmentSchema } from './Environments';
+import { MergeRequestSchema } from './MergeRequests';
 export declare type DeploymentStatus = 'created' | 'running' | 'success' | 'failed' | 'canceled';
-export interface DeploymentSchemaDefault {
+export interface DeployableSchema {
     id: number;
-    iid: number;
     ref: string;
-    sha: string;
-    user: UserSchemaDefault;
-}
-export interface DeploymentSchemaCamelized {
-    id: number;
-    iid: number;
-    ref: string;
-    sha: string;
-    user: UserSchemaCamelized;
-}
-export interface DeployableDefault {
-    id: number;
-    ref: string;
     name: string;
-    runner?: RunnerSchemaDefault;
+    runner?: RunnerSchema;
     stage?: string;
@@ -31,30 +19,27 @@ started_at?: Date;
     tag: boolean;
-    commit?: CommitSchemaDefault;
+    commit?: CommitSchema;
     coverage?: string;
     created_at?: Date;
     finished_at?: Date;
-    user?: UserSchemaDefault;
-    pipeline?: PipelineSchemaDefault;
+    user?: UserSchema;
+    pipeline?: PipelineSchema;
 }
-export interface DeployableCamelized {
+export declare type DeploymentSchema = {
     id: number;
+    iid: number;
     ref: string;
-    name: string;
-    runner?: RunnerSchemaCamelized;
-    stage?: string;
-    startedAt?: Date;
-    status?: DeploymentStatus;
-    tag: boolean;
-    commit?: CommitSchemaCamelized;
-    coverage?: string;
-    createdAt?: Date;
-    finishedAt?: Date;
-    user?: UserSchemaCamelized;
-    pipeline?: PipelineSchemaCamelized;
+    sha: string;
+    user: UserSchema;
+    created_at: string;
+    updated_at: string;
+    status: DeploymentStatus;
+    deployable: DeployableSchema;
+    environment: EnvironmentSchema;
+};
+export declare class Deployments<C extends boolean = false> extends BaseService<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, DeploymentSchema>[]>;
+    create(projectId: string | number, environment: string, sha: string, ref: string, tag: string, status: DeploymentStatus, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, DeploymentSchema>>;
+    edit(projectId: string | number, deploymentId: number, status: DeploymentStatus, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, DeploymentSchema>>;
+    show(projectId: string | number, deploymentId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, DeploymentSchema>>;
+    mergeRequests(projectId: string | number, deploymentId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>[]>;
 }
-export declare type Deployable = DeployableDefault | DeployableCamelized;
-export declare class Deployments extends BaseService {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    show(projectId: string | number, deploymentId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    mergeRequests(projectId: string | number, deploymentId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-}

dist/types/services/Environments.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-import { DeploymentSchemaDefault, DeploymentSchemaCamelized, DeployableDefault, DeployableCamelized } from './Deployments';
-import { ProjectSchemaDefault, ProjectSchemaCamelized } from './Projects';
-export interface EnvironmentSchemaDefault {
+import { DeploymentSchema, DeployableSchema } from './Deployments';
+import { ProjectSchema } from './Projects';
+export interface EnvironmentSchema extends Record<string, unknown> {
     id: number;
@@ -10,30 +10,14 @@ name: string;
     external_url?: string;
-    project?: ProjectSchemaDefault;
+    project?: ProjectSchema;
     state?: string;
+    last_deployment?: DeploymentSchema;
+    deployable?: DeployableSchema;
 }
-export interface EnvironmentSchemaCamelized {
-    id: number;
-    name: string;
-    slug?: string;
-    externalUrl?: string;
-    project?: ProjectSchemaCamelized;
-    state?: string;
+export declare class Environments<C extends boolean = false> extends BaseService<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Omit<EnvironmentSchema, "last_deployment" | "deployable">>[]>;
+    show(projectId: string | number, environmentId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, EnvironmentSchema>>;
+    create(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Omit<EnvironmentSchema, "last_deployment" | "deployable">>>;
+    edit(projectId: string | number, environmentId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Omit<EnvironmentSchema, "last_deployment" | "deployable">>>;
+    remove(projectId: string | number, environmentId: number, options?: Sudo): Promise<void>;
+    stop(projectId: string | number, environmentId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Omit<EnvironmentSchema, "last_deployment" | "deployable">>>;
 }
-export declare type EnvironmentSchema = EnvironmentSchemaDefault | EnvironmentSchemaCamelized;
-export interface EnvironmentDetailSchemaDefault extends EnvironmentSchemaDefault {
-    last_deployment?: DeploymentSchemaDefault;
-    deployable?: DeployableDefault;
-}
-export interface EnvironmentDetailSchemaCamelized extends EnvironmentSchemaCamelized {
-    lastDeployment?: DeploymentSchemaCamelized;
-    deployable?: DeployableCamelized;
-}
-export declare type EnvironmentDetailSchema = EnvironmentDetailSchemaDefault | EnvironmentDetailSchemaCamelized;
-export declare class Environments extends BaseService {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<EnvironmentSchema[]>;
-    show(projectId: string | number, environmentId: number, options?: Sudo): Promise<EnvironmentDetailSchema>;
-    create(projectId: string | number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(projectId: string | number, environmentId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, environmentId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    stop(projectId: string | number, environmentId: number, options?: Sudo): Promise<Record<string, unknown>>;
-}

dist/types/services/EpicDiscussions.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceDiscussions } from '../templates';
-import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export interface EpicDiscussions extends ResourceDiscussions {
-    addNote(groupId: string | number, epicId: string | number, discussionId: string | number, noteId: number, content: string, options?: BaseRequestOptions): any;
-    all(groupId: string | number, epicId: string | number, options?: PaginatedRequestOptions): any;
-    create(groupId: string | number, epicId: string | number, content: string, options?: BaseRequestOptions): any;
-    editNote(groupId: string | number, epicId: string | number, discussionId: string | number, noteId: number, content: string, options?: BaseRequestOptions): any;
-    removeNote(groupId: string | number, epicId: string | number, discussionId: string | number, noteId: number, options?: Sudo): any;
-    show(groupId: string | number, epicId: string | number, discussionId: string | number, options?: Sudo): any;
+import { ResourceDiscussions, DiscussionSchema } from '../templates';
+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, content: 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, content: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, DiscussionSchema>>;
+    editNote(groupId: string | number, epicId: number, discussionId: number, noteId: number, content: string, options?: BaseRequestOptions): 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 extends ResourceDiscussions {
-    constructor(options: BaseServiceOptions);
+export declare class EpicDiscussions<C extends boolean = false> extends ResourceDiscussions<C> {
+    constructor(options: BaseServiceOptions<C>);
 }

dist/types/services/EpicIssues.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { IssueSchema } from './Issues';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class EpicIssues extends BaseService {
-    all(groupId: string | number, epicId: number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    assign(groupId: string | number, epicId: number, issueId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    edit(groupId: string | number, epicId: number, issueId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(groupId: string | number, epicId: number, issueId: number, options?: Sudo): Promise<Record<string, unknown>>;
+export interface EpicIssueSchema extends Omit<IssueSchema, 'references' | 'task_completion_status'> {
+    epic_issue_id: number;
 }
+export declare class EpicIssues<C extends boolean = false> extends BaseService<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>;
+}

dist/types/services/EpicNotes.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceNotes } from '../templates';
-import { PaginatedRequestOptions, BaseRequestOptions, Sudo } from '../infrastructure';
-export interface EpicNotes extends ResourceNotes {
-    all(groupId: string | number, epicId: string | number, options?: PaginatedRequestOptions): any;
-    create(groupId: string | number, epicId: string | number, body: string, options?: BaseRequestOptions): any;
-    edit(groupId: string | number, epicId: string | number, noteId: number, body: string, options?: BaseRequestOptions): any;
-    remove(groupId: string | number, epicId: string | number, noteId: number, options?: Sudo): any;
-    show(groupId: string | number, epicId: string | number, noteId: number, options?: Sudo): any;
+import { ResourceNotes, NoteSchema } from '../templates';
+import { PaginatedRequestOptions, BaseRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface EpicNoteSchema extends NoteSchema {
+    file_name: string;
+    expires_at: string;
 }
-export declare class EpicNotes extends ResourceNotes {
-    constructor(options: BaseServiceOptions);
+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: BaseServiceOptions<C>);
+}

dist/types/services/Epics.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class Epics extends BaseService {
-    all(groupId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(groupId: string | number, title: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(groupId: string | number, epicId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(groupId: string | number, epicId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(groupId: string | number, epicId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+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 BaseService<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>>;
+}

dist/types/services/Events.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
 import { PaginatedRequestOptions } from '../infrastructure';
@@ -6,5 +7,24 @@ export interface EventOptions {
     targetType?: 'issue' | 'milestone' | 'merge_request' | 'note' | 'project' | 'snippet' | 'user';
+    before?: string;
+    after?: string;
+    scope?: string;
+    sort?: 'asc' | 'desc';
 }
-export declare class Events extends BaseService {
-    all(options?: PaginatedRequestOptions & EventOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+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 BaseService<C> {
+    all({ projectId, ...options }?: {
+        projectId?: string | number;
+    } & PaginatedRequestOptions & EventOptions): Promise<import("../infrastructure").CamelizedRecord<C, EventSchema>[]>;
+}

dist/types/services/FeatureFlags.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
-import { BaseRequestOptions, PaginatedRequestOptions } from '../infrastructure';
-export declare class FeatureFlags extends BaseService {
-    all(options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    set(name: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
+export interface ScopeSchema {
+    id: number;
+    environment_scope: string;
 }
+export interface StrategySchema {
+    id: number;
+    name: string;
+    parameters: {
+        user_ids: string;
+    };
+    scopes?: ScopeSchema[];
+}
+export interface FeatureFlagSchema extends Record<string, unknown> {
+    name: string;
+    description: string;
+    active: boolean;
+    version: string;
+    created_at: string;
+    updated_at: string;
+    scopes?: string[];
+    strategies?: StrategySchema[];
+}
+export declare class FeatureFlags<C extends boolean = false> extends BaseService<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>>;
+}

dist/types/services/FreezePeriods.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
-import { BaseRequestOptions } from '../infrastructure';
-export interface CreateFreezePeriodOptions {
-    cronTimezone?: string;
+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 interface EditFreezePeriodOptions {
-    cronTimezone?: string;
-    freezeStart?: string;
-    freezeEnd?: string;
+export declare class FreezePeriods<C extends boolean = false> extends BaseService<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>;
 }
-export declare class FreezePeriods extends BaseService {
-    all(projectId: string | number, options?: BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    show(projectId: string | number, freezePeriodId: number, options?: BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(projectId: number | string, freezeStart: string, freezeEnd: string, options?: CreateFreezePeriodOptions & BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(projectId: number | string, freezePeriodId: number, options?: EditFreezePeriodOptions & BaseRequestOptions): Promise<Record<string, unknown>>;
-    delete(projectId: number | string, freezePeriodId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-}

dist/types/services/GeoNodes.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class GeoNodes extends BaseService {
-    all(options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(geonodeId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(geonodeId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    failures(options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    repair(geonodeId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(geonodeId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    status(geonodeId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    statuses(options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+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 BaseService<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>[]>;
+}

dist/types/services/GitignoreTemplates.d.ts

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

dist/types/services/GitLabCIYMLTemplates.d.ts

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

dist/types/services/GroupAccessRequests.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceAccessRequests } from '../templates';
-export declare class GroupAccessRequests extends ResourceAccessRequests {
-    constructor(options: BaseServiceOptions);
+import { ResourceAccessRequests, AccessRequestSchema, AccessLevel } from '../templates';
+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: BaseServiceOptions<C>);
+}

dist/types/services/GroupBadges.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceBadges } from '../templates';
-import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export interface GroupBadges extends ResourceBadges {
-    add(groupId: string | number, options?: BaseRequestOptions): any;
-    all(groupId: string | number, options?: PaginatedRequestOptions): any;
-    edit(groupId: string | number, badgeId: number, options?: BaseRequestOptions): any;
-    preview(groupId: string | number, linkUrl: string, imageUrl: string, options?: Sudo): any;
-    remove(groupId: string | number, badgeId: number, options?: Sudo): any;
-    show(groupId: string | number, badgeId: number, options?: Sudo): any;
+import { ResourceBadges, BadgeSchema } from '../templates';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface GroupBadgeSchema extends BadgeSchema {
+    kind: 'group';
 }
-export declare class GroupBadges extends ResourceBadges {
-    constructor(options: BaseServiceOptions);
+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: BaseServiceOptions<C>);
+}

dist/types/services/GroupCustomAttributes.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceCustomAttributes } from '../templates';
-import { PaginatedRequestOptions, Sudo } from '../infrastructure';
-export interface GroupCustomAttributes extends ResourceCustomAttributes {
-    all(groupId: string | number, options?: PaginatedRequestOptions): any;
-    set(groupId: string | number, customAttributeId: number, value: string, options?: Sudo): any;
-    remove(groupId: string | number, customAttributeId: number, options?: Sudo): any;
-    show(groupId: string | number, customAttributeId: number, options?: Sudo): any;
+import { ResourceCustomAttributes, CustomAttributeSchema } from '../templates';
+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 extends ResourceCustomAttributes {
-    constructor(options: BaseServiceOptions);
+export declare class GroupCustomAttributes<C extends boolean = false> extends ResourceCustomAttributes<C> {
+    constructor(options: BaseServiceOptions<C>);
 }

dist/types/services/GroupDeployTokens.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceDeployTokens } from '../templates';
-export declare class GroupDeployTokens extends ResourceDeployTokens {
-    constructor(options?: BaseServiceOptions);
+import { ResourceDeployTokens, DeployTokenScope, DeployTokenSchema } from '../templates';
+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({ groupId, ...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: BaseServiceOptions<C>);
+}

dist/types/services/GroupIssueBoards.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceIssueBoards } from '../templates';
-import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export interface GroupIssueBoards extends ResourceIssueBoards {
-    all(groupId: string | number, options?: PaginatedRequestOptions): any;
-    create(groupId: string | number, name: string, options?: Sudo): any;
-    createList(groupId: string | number, boardId: number, labelId: number, options?: Sudo): any;
-    edit(groupId: string | number, boardId: number, options?: BaseRequestOptions): any;
-    editList(groupId: string | number, boardId: number, listId: number, position: number, options?: Sudo): any;
-    lists(groupId: string | number, boardId: number, options?: Sudo): any;
-    remove(groupId: string | number, boardId: number, options?: Sudo): any;
-    removeList(groupId: string | number, boardId: number, listId: number, options?: Sudo): any;
-    show(groupId: string | number, boardId: number, options?: Sudo): any;
-    showList(groupId: string | number, boardId: number, listId: number, options?: Sudo): any;
+import { GroupSchema } from './Groups';
+import { ResourceIssueBoards, IssueBoardSchema, IssueBoardListSchema } from '../templates';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface GroupIssueBoardSchema extends IssueBoardSchema {
+    group: Pick<GroupSchema, 'id' | 'name' | 'web_url'>;
 }
-export declare class GroupIssueBoards extends ResourceIssueBoards {
-    constructor(options?: BaseServiceOptions);
+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: BaseServiceOptions<C>);
+}

dist/types/services/GroupLabels.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-import { ResourceLabels } from '../templates';
-export interface GroupLabels extends ResourceLabels {
-    all(groupId: string | number, options?: PaginatedRequestOptions): any;
-    create(groupId: string | number, labelName: string, color: string, options?: BaseRequestOptions): any;
-    edit(groupId: string | number, labelName: string, options?: BaseRequestOptions): any;
-    remove(groupId: string | number, labelName: string, options?: Sudo): any;
-    subscribe(groupId: string | number, labelId: number, options?: Sudo): any;
-    unsubscribe(groupId: string | number, labelId: number, options?: Sudo): any;
+import { BaseRequestOptions, PaginatedRequestOptions, CamelizedRecord, Sudo } from '../infrastructure';
+import { ResourceLabels, LabelSchema } from '../templates';
+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 extends ResourceLabels {
-    constructor(options?: BaseServiceOptions);
+export declare class GroupLabels<C extends boolean = false> extends ResourceLabels<C> {
+    constructor(options: BaseServiceOptions<C>);
 }

dist/types/services/GroupMembers.d.ts

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

dist/types/services/GroupMilestones.d.ts

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

dist/types/services/GroupRunners.d.ts

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

dist/types/services/Groups.d.ts

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

dist/types/services/GroupVariables.d.ts

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

dist/types/services/index.d.ts

@@ -8,3 +8,2 @@ export { Groups } from './Groups';
 export { GroupMilestones } from './GroupMilestones';
-export { GroupProjects } from './GroupProjects';
 export { GroupRunners } from './GroupRunners';
@@ -22,3 +21,3 @@ export { GroupVariables } from './GroupVariables';
 export { UserImpersonationTokens } from './UserImpersonationTokens';
-export { UserKeys } from './UserKeys';
+export { UserSSHKeys } from './UserSSHKeys';
 export { UserGPGKeys } from './UserGPGKeys';
@@ -49,3 +48,3 @@ export { Branches } from './Branches';
 export { PipelineScheduleVariables } from './PipelineScheduleVariables';
-export { Projects } from './Projects';
+export * from './Projects';
 export { ProjectAccessRequests } from './ProjectAccessRequests';
@@ -87,3 +86,3 @@ export { ProjectBadges } from './ProjectBadges';
 export { License } from './License';
-export { LicenceTemplates } from './LicenceTemplates';
+export { LicenseTemplates } from './LicenseTemplates';
 export { Lint } from './Lint';
@@ -90,0 +89,0 @@ export { Namespaces } from './Namespaces';

dist/types/services/IssueAwardEmojis.d.ts

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

dist/types/services/IssueDiscussions.d.ts

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

dist/types/services/IssueNotes.d.ts

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

dist/types/services/Issues.d.ts

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

dist/types/services/IssuesStatistics.d.ts

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

dist/types/services/Jobs.d.ts

 /// <reference types="node" />
 import { BaseService } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-import { CommitSchemaDefault, CommitSchemaCamelized } from './Commits';
-import { RunnerSchemaDefault, RunnerSchemaCamelized } from './Runners';
-import { UserSchemaDefault, UserSchemaCamelized } from './Users';
-import { PipelineBase } from './Pipelines';
+import { CommitSchema } from './Commits';
+import { RunnerSchema } from './Runners';
+import { UserSchema } from './Users';
+import { PipelineSchema } from './Pipelines';
 export declare type JobScope = 'created' | 'pending' | 'running' | 'failed' | 'success' | 'canceled' | 'skipped' | 'manual';
-export interface ArtifactSchemaDefault {
+export interface ArtifactSchema extends Record<string, unknown> {
     file_type: string;
@@ -15,10 +15,3 @@ size: number;
 }
-export interface ArtifactSchemaCamelized {
-    fileType: string;
-    size: number;
-    filename: string;
-    fileFormat?: string;
-}
-export declare type ArtifactSchema = ArtifactSchemaDefault | ArtifactSchemaCamelized;
-export interface JobSchemaDefault {
+export interface JobSchema extends Record<string, unknown> {
     id: number;
@@ -36,54 +29,33 @@ status: string;
     duration?: number;
-    user: UserSchemaDefault;
-    commit: CommitSchemaDefault;
-    pipeline: PipelineBase;
+    user: UserSchema;
+    commit: CommitSchema;
+    pipeline: PipelineSchema;
     web_url: string;
-    artifacts: ArtifactSchemaDefault[];
-    runner: RunnerSchemaDefault;
+    artifacts: ArtifactSchema[];
+    runner: RunnerSchema;
     artifacts_expire_at?: Date;
+    tag_list?: string[];
 }
-export interface JobSchemaCamelized {
-    id: number;
-    status: string;
-    stage: string;
-    name: string;
-    ref: string;
-    tag: boolean;
-    coverage?: string;
-    allowFailure: boolean;
-    createdAt: Date;
-    startedAt?: Date;
-    finishedAt?: Date;
-    duration?: number;
-    user: UserSchemaCamelized;
-    commit: CommitSchemaCamelized;
-    pipeline: PipelineBase;
-    webUrl: string;
-    artifacts: ArtifactSchemaCamelized[];
-    runner: RunnerSchemaCamelized;
-    artifactsExpireAt?: Date;
-}
-export declare type JobSchema = JobSchemaDefault | JobSchemaCamelized;
-export declare class Jobs extends BaseService {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    cancel(projectId: string | number, jobId: number, options?: Sudo): Promise<Record<string, unknown>>;
+export declare class Jobs<C extends boolean = false> extends BaseService<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>[]>;
+    cancel(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>>;
     downloadSingleArtifactFile(projectId: string | number, jobId: number, artifactPath: string, { stream, ...options }?: {
         stream?: boolean;
-    } & BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]> | NodeJS.ReadableStream;
+    } & BaseRequestOptions): NodeJS.ReadableStream | Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
     downloadSingleArtifactFileFromRef(projectId: string | number, ref: string, artifactPath: string, jobName: string, { stream, ...options }?: {
         stream?: boolean;
-    } & BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]> | NodeJS.ReadableStream;
+    } & BaseRequestOptions): NodeJS.ReadableStream | Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
     downloadLatestArtifactFile(projectId: string | number, ref: string, jobName: string, { stream, ...options }?: {
         stream?: boolean;
-    } & BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]> | NodeJS.ReadableStream;
-    downloadTraceFile(projectId: string | number, jobId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    erase(projectId: string | number, jobId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    eraseArtifacts(projectId: string | number, jobId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    keepArtifacts(projectId: string | number, jobId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    play(projectId: string | number, jobId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    retry(projectId: string | number, jobId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, jobId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    } & BaseRequestOptions): NodeJS.ReadableStream | Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    downloadTraceFile(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    erase(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>>;
+    eraseArtifacts(projectId: string | number, jobId: number, options?: Sudo): Promise<void>;
+    keepArtifacts(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    play(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>>;
+    retry(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>>;
+    show(projectId: string | number, jobId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>>;
     showPipelineJobs(projectId: string | number, pipelineId: number, options?: {
         scope?: JobScope;
-    } & Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    } & Sudo): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>>;
 }

dist/types/services/Keys.d.ts

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

dist/types/services/Labels.d.ts

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

dist/types/services/License.d.ts

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

dist/types/services/Lint.d.ts

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

dist/types/services/Markdown.d.ts

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

dist/types/services/MergeRequestApprovals.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, Sudo } from '../infrastructure';
+export interface MergeRequestApprovalSchema extends Record<string, unknown> {
+    approvals_before_merge: number;
+    reset_approvals_on_push: boolean;
+    disable_overriding_approvers_per_merge_request: boolean;
+    merge_requests_author_approval: boolean;
+    merge_requests_disable_committers_approval: boolean;
+    require_password_to_approve: boolean;
+}
 export declare type ApprovalRulesRequestOptions = {
@@ -8,31 +16,31 @@ userIds?: number[];
 };
-export declare class MergeRequestApprovals extends BaseService {
+export declare class MergeRequestApprovals<C extends boolean = false> extends BaseService<C> {
     addApprovalRule(projectId: string | number, name: string, approvalsRequired: number, { mergerequestIid, ...options }: {
         mergerequestIid?: number;
-    } & ApprovalRulesRequestOptions & BaseRequestOptions): Promise<Record<string, unknown>>;
+    } & ApprovalRulesRequestOptions & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
     approvalRules(projectId: string | number, { mergerequestIid, ...options }?: {
         mergerequestIid?: number;
-    } & BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
     approvals(projectId: string | number, { mergerequestIid, ...options }?: {
         mergerequestIid?: number;
-    } & BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
     approvalState(projectId: string | number, mergerequestIid: number, options?: {
         sha?: string;
-    } & BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
     approve(projectId: string | number, mergerequestIid: number, options?: {
         sha?: string;
-    } & BaseRequestOptions): Promise<Record<string, unknown>>;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
     approvers(projectId: string | number, approverIds: number[], approverGroupIds: (string | number)[], { mergerequestIid, ...options }?: {
         mergerequestIid?: number;
-    } & BaseRequestOptions): Promise<Record<string, unknown>>;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
     editApprovalRule(projectId: string | number, approvalRuleId: number, name: string, approvalsRequired: number, { mergerequestIid, ...options }?: {
         mergerequestIid?: number;
-    } & ApprovalRulesRequestOptions & BaseRequestOptions): Promise<Record<string, unknown>>;
+    } & ApprovalRulesRequestOptions & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
     editApprovals(projectId: string | number, { mergerequestIid, ...options }?: {
         mergerequestIid?: number;
-    } & BaseRequestOptions): Promise<Record<string, unknown>>;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
     removeApprovalRule(projectId: string | number, approvalRuleId: number, { mergerequestIid, ...options }?: {
         mergerequestIid?: number;
-    } & BaseRequestOptions): Promise<Record<string, unknown>>;
-    unapprove(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown>>;
+    } & BaseRequestOptions): Promise<void>;
+    unapprove(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
 }

dist/types/services/MergeRequestAwardEmojis.d.ts

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

dist/types/services/MergeRequestDiscussions.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceDiscussions } from '../templates';
-import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export interface MergeRequestDiscussions extends ResourceDiscussions {
-    addNote(projectId: string | number, mergerequestId: string | number, discussionId: string | number, noteId: number, content: string, options?: BaseRequestOptions): any;
-    all(projectId: string | number, mergerequestId: string | number, options?: PaginatedRequestOptions): any;
-    create(projectId: string | number, mergerequestId: string | number, content: string, options?: BaseRequestOptions): any;
-    editNote(projectId: string | number, mergerequestId: string | number, discussionId: string | number, noteId: number, content: string, options?: BaseRequestOptions): any;
-    removeNote(projectId: string | number, mergerequestId: string | number, discussionId: string | number, noteId: number, options?: Sudo): any;
-    show(projectId: string | number, mergerequestId: string | number, discussionId: string | number, options?: Sudo): any;
+import { ResourceDiscussions, DiscussionSchema } from '../templates';
+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, content: 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, content: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, DiscussionSchema>>;
+    editNote(projectId: string | number, mergerequestId: string | number, discussionId: number, noteId: number, content: string, options?: BaseRequestOptions): 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 extends ResourceDiscussions {
-    constructor(options?: BaseServiceOptions);
+export declare class MergeRequestDiscussions<C extends boolean = false> extends ResourceDiscussions<C> {
+    constructor(options: BaseServiceOptions<C>);
 }

dist/types/services/MergeRequestNotes.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceNotes } from '../templates';
-import { PaginatedRequestOptions, BaseRequestOptions, Sudo } from '../infrastructure';
-export interface MergeRequestNotes extends ResourceNotes {
-    all(projectId: string | number, mergerequestIid: string | number, options?: PaginatedRequestOptions): any;
-    create(projectId: string | number, mergerequestIid: string | number, body: string, options?: BaseRequestOptions): any;
-    edit(projectId: string | number, mergerequestIid: string | number, noteId: number, body: string, options?: BaseRequestOptions): any;
-    remove(projectId: string | number, mergerequestIid: string | number, noteId: number, options?: Sudo): any;
-    show(projectId: string | number, mergerequestIid: string | number, noteId: number, options?: Sudo): any;
+import { ResourceNotes, NoteSchema } from '../templates';
+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 declare class MergeRequestNotes extends ResourceNotes {
-    constructor(options?: BaseServiceOptions);
+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: BaseServiceOptions<C>);
+}

dist/types/services/MergeRequests.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { IssueSchema } from './Issues';
+import { CommitSchema, CommitDiffSchema } from './Commits';
+import { MilestoneSchema } from '../templates';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
@@ -64,29 +68,109 @@ export interface AcceptMergeRequestOptions {
 }
-export declare class MergeRequests extends BaseService {
-    accept(projectId: string | number, mergerequestIid: number, options?: AcceptMergeRequestOptions & BaseRequestOptions): Promise<Record<string, unknown>>;
-    addSpentTime(projectId: string | number, mergerequestIid: number, duration: string, options?: Sudo): Promise<Record<string, unknown>>;
-    addTimeEstimate(projectId: string | number, mergerequestIid: number, duration: string, options?: Sudo): Promise<Record<string, unknown>>;
-    all({ projectId, groupId, ...options }?: ({
+export interface ReferenceSchema {
+    short: string;
+    relative: string;
+    full: string;
+}
+export interface TaskCompletionStatusSchema {
+    count: number;
+    completed_count: number;
+}
+export interface PipelineSchema extends Record<string, unknown> {
+    id: number;
+    sha: string;
+    ref: string;
+    status: string;
+}
+export interface TimeStatsSchema extends Record<string, unknown> {
+    time_estimate: number;
+    total_time_spent: number;
+    human_time_estimate: string;
+    human_total_time_spent: string;
+}
+export interface 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 BaseService<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<Record<string, unknown> | Record<string, unknown>[]>;
-    cancelOnPipelineSucess(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown>>;
-    changes(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    closesIssues(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    commits(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(projectId: string | number, sourceBranch: string, targetBranch: string, title: string, options?: CreateMergeRequestOptions & BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(projectId: string | number, mergerequestIid: number, options?: UpdateMergeRequestOptions & BaseRequestOptions): Promise<Record<string, unknown>>;
-    participants(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    pipelines(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    rebase(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown>>;
-    resetSpentTime(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown>>;
-    resetTimeEstimate(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, mergerequestIid: number, options?: ShowMergeRequestOptions & BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    subscribe(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown>>;
-    timeStats(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    version(projectId: string | number, mergerequestIid: number, versionId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    versions(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    unsubscribe(projectId: string | number, mergerequestIid: number, options?: Sudo): Promise<Record<string, unknown>>;
+    } & 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, PipelineSchema>[]>;
+    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>>;
 }

dist/types/services/Namespaces.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class Namespaces extends BaseService {
-    all(options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+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 BaseService<C> {
+    all(options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, NamespaceSchema>[]>;
     show(namespaceId: string | number, options?: {
         search?: string;
-    } & Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    } & Sudo): Promise<import("../infrastructure").CamelizedRecord<C, NamespaceSchema>>;
 }

dist/types/services/NotificationSettings.d.ts

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

dist/types/services/Packages.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { PipelineSchema } from './Pipelines';
 import { PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class Packages extends BaseService {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    remove(projectId: string | number, packageId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, packageId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    showFiles(projectId: string | number, packageId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+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 BaseService<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PackageSchema>[]>;
+    remove(projectId: string | number, packageId: 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>[]>;
+}

dist/types/services/PagesDomains.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class PagesDomains extends BaseService {
+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 BaseService<C> {
     all({ projectId, ...options }?: {
         projectId?: string | number;
-    } & PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(projectId: string | number, domain: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(projectId: string | number, domain: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    show(projectId: string | number, domain: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    remove(projectId: string | number, domain: string, options?: Sudo): Promise<Record<string, unknown>>;
+    } & 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>;
 }

dist/types/services/Pipelines.d.ts

 import { BaseService } 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 PipelineBase {
+export interface PipelineSchema extends Record<string, unknown> {
     id: number;
+    status: PipelineStatus;
+    ref: string;
     sha: string;
-    ref: string;
-    status: PipelineStatus;
-}
-export interface PipelineSchemaDefault extends PipelineBase {
-    created_at: Date;
-    updated_at: Date;
     web_url: string;
+    created_at: string;
+    updated_at: string;
+    user: Pick<UserSchema, 'name' | 'avatar_url'>;
 }
-export interface PipelineSchemaCamelized extends PipelineBase {
-    createdAt: Date;
-    updatedAt: Date;
-    webUrl: string;
+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 declare type PipelineSchema = PipelineSchemaDefault | PipelineSchemaCamelized;
-export declare class Pipelines extends BaseService {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(projectId: string | number, ref: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    delete(projectId: string | number, pipelineId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, pipelineId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    retry(projectId: string | number, pipelineId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    cancel(projectId: string | number, pipelineId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    allVariables(projectId: string | number, pipelineId: number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+export interface PipelineVariableSchema extends Record<string, unknown> {
+    key: string;
+    variable_type?: string;
+    value: string;
 }
+export declare class Pipelines<C extends boolean = false> extends BaseService<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>[]>;
+}

dist/types/services/PipelineSchedules.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { PipelineSchema, PipelineVariableSchema } from './Pipelines';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class PipelineSchedules extends BaseService {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(projectId: string | number, description: string, ref: string, cron: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(projectId: string | number, scheduleId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, scheduleId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, scheduleId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    takeOwnership(projectId: string | number, scheduleId: number, options?: Sudo): Promise<Record<string, unknown>>;
+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 BaseService<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>>;
+}

dist/types/services/PipelineScheduleVariables.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { PipelineVariableSchema } from './Pipelines';
 import { BaseRequestOptions, PaginatedRequestOptions } from '../infrastructure';
-export declare class PipelineScheduleVariables extends BaseService {
-    all(projectId: string | number, pipelineScheduleId: number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(projectId: string | number, pipelineScheduleId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(projectId: string | number, pipelineScheduleId: number, keyId: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    show(projectId: string | number, pipelineScheduleId: number, keyId: string, options?: BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    remove(projectId: string | number, pipelineScheduleId: number, keyId: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
+export declare class PipelineScheduleVariables<C extends boolean = false> extends BaseService<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>>;
 }

dist/types/services/ProjectAccessRequests.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceAccessRequests } from '../templates';
-export declare class ProjectAccessRequests extends ResourceAccessRequests {
-    constructor(options?: BaseServiceOptions);
+import { ResourceAccessRequests, AccessRequestSchema, AccessLevel } from '../templates';
+import { Sudo, CamelizedRecord } from '../infrastructure';
+export interface GroupAccessRequests<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: BaseServiceOptions<C>);
+}

dist/types/services/ProjectBadges.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceBadges } from '../templates';
-import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export interface ProjectBadges extends ResourceBadges {
-    add(projectId: string | number, options?: BaseRequestOptions): any;
-    all(projectId: string | number, options?: PaginatedRequestOptions): any;
-    edit(projectId: string | number, badgeId: number, options?: BaseRequestOptions): any;
-    preview(projectId: string | number, linkUrl: string, imageUrl: string, options?: Sudo): any;
-    remove(projectId: string | number, badgeId: number, options?: Sudo): any;
-    show(projectId: string | number, badgeId: number, options?: Sudo): any;
+import { ResourceBadges, BadgeSchema } from '../templates';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface ProjectBadgeSchema extends BadgeSchema {
+    kind: 'project';
 }
-export declare class ProjectBadges extends ResourceBadges {
-    constructor(options?: BaseServiceOptions);
+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: BaseServiceOptions<C>);
+}

dist/types/services/ProjectCustomAttributes.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceCustomAttributes } from '../templates';
-import { PaginatedRequestOptions, Sudo } from '../infrastructure';
-export interface ProjectCustomAttributes extends ResourceCustomAttributes {
-    all(projectId: string | number, options?: PaginatedRequestOptions): any;
-    set(projectId: string | number, customAttributeId: number, value: string, options?: Sudo): any;
-    remove(projectId: string | number, customAttributeId: number, options?: Sudo): any;
-    show(projectId: string | number, customAttributeId: number, options?: Sudo): any;
+import { ResourceCustomAttributes, CustomAttributeSchema } from '../templates';
+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 extends ResourceCustomAttributes {
-    constructor(options?: BaseServiceOptions);
+export declare class ProjectCustomAttributes<C extends boolean> extends ResourceCustomAttributes<C> {
+    constructor(options: BaseServiceOptions<C>);
 }

dist/types/services/ProjectDeployTokens.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceDeployTokens } from '../templates';
-export declare class ProjectDeployTokens extends ResourceDeployTokens {
-    constructor(options?: BaseServiceOptions);
+import { ResourceDeployTokens, DeployTokenScope, DeployTokenSchema } from '../templates';
+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({ projectId, ...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: BaseServiceOptions<C>);
+}

dist/types/services/ProjectHooks.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class ProjectHooks extends BaseService {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    show(projectId: string | number, hookId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    add(projectId: string | number, url: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(projectId: string | number, hookId: number, url: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, hookId: number, options?: Sudo): Promise<Record<string, unknown>>;
+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 BaseService<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>;
+}

dist/types/services/ProjectImportExport.d.ts

 import { BaseService } 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 {
@@ -11,10 +45,12 @@ filename?: string;
 };
-export declare class ProjectImportExport extends BaseService {
-    download(projectId: string | number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    exportStatus(projectId: string | number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+export declare class ProjectImportExport<C extends boolean = false> extends BaseService<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<Record<string, unknown>>;
-    importStatus(projectId: string | number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    schedule(projectId: string | number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
+    } & 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;
+    }>>;
 }

dist/types/services/ProjectIssueBoards.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceIssueBoards } from '../templates';
-import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export interface ProjectIssueBoards extends ResourceIssueBoards {
-    all(projectId: string | number, options?: PaginatedRequestOptions): any;
-    create(projectId: string | number, name: string, options?: Sudo): any;
-    createList(projectId: string | number, boardId: number, labelId: number, options?: Sudo): any;
-    edit(projectId: string | number, boardId: number, options?: BaseRequestOptions): any;
-    editList(projectId: string | number, boardId: number, listId: number, position: number, options?: Sudo): any;
-    lists(projectId: string | number, boardId: number, options?: Sudo): any;
-    remove(projectId: string | number, boardId: number, options?: Sudo): any;
-    removeList(projectId: string | number, boardId: number, listId: number, options?: Sudo): any;
-    show(projectId: string | number, boardId: number, options?: Sudo): any;
-    showList(projectId: string | number, boardId: number, listId: number, options?: Sudo): any;
+import { ProjectSchema } from './Projects';
+import { ResourceIssueBoards, IssueBoardSchema, IssueBoardListSchema } from '../templates';
+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 declare class ProjectIssueBoards extends ResourceIssueBoards {
-    constructor(options?: BaseServiceOptions);
+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: BaseServiceOptions<C>);
+}

dist/types/services/ProjectMembers.d.ts

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

dist/types/services/ProjectMilestones.d.ts

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

dist/types/services/Projects.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { LicenseTemplateSchema } from './LicenseTemplates';
+import { UploadMetadata } from './ProjectImportExport';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-import { EventOptions } from './Events';
-import { UploadMetadata } from './ProjectImportExport';
-export interface NamespaceInfoSchemaDefault {
+import { AccessLevel } from '../templates';
+export interface ProjectSchema extends Record<string, unknown> {
     id: number;
+    description?: string;
+    default_branch: string;
+    ssh_url_to_repo: string;
+    http_url_to_repo: string;
+    web_url: string;
+    readme_url: string;
+    tag_list?: string[];
     name: string;
+    name_with_namespace: string;
     path: string;
-    kind: string;
-    full_path: string;
+    path_with_namespace: string;
+    created_at: string;
+    last_activity_at: string;
+    forks_count: number;
+    avatar_url: string;
+    star_count: number;
 }
-export interface NamespaceInfoSchemaCamelize {
+export interface NamespaceInfoSchema extends Record<string, unknown> {
     id: number;
@@ -17,30 +31,104 @@ name: string;
     kind: string;
-    fullPath: string;
+    full_path: string;
+    avatar_url: string;
+    web_url: string;
 }
-export interface ProjectSchemaDefault {
-    id: number;
-    name: string;
-    name_with_namespace: string;
-    path: string;
-    path_with_namespace: string;
-    namespace: NamespaceInfoSchemaDefault;
-    ssh_url_to_repo: string;
-    http_url_to_repo: string;
-    archived: boolean;
+export interface AccessSchema {
+    access_level: AccessLevel;
+    notification_level: number;
 }
-export interface ProjectSchemaCamelized {
-    id: number;
-    name: string;
-    nameWithNamespace: string;
-    path: string;
-    pathWithNamespace: string;
-    namespace: NamespaceInfoSchemaCamelize;
-    sshUrlToRepo: string;
-    httpUrlToRepo: string;
+export interface SharedWithGroupSchema {
+    group_id: number;
+    group_name: string;
+    group_full_path: string;
+    group_access_level: number;
+}
+export interface ProjectExtendedSchema extends ProjectSchema {
+    visibility: string;
+    owner: Pick<UserSchema, 'id' | 'name' | 'created_at'>;
+    issues_enabled: boolean;
+    open_issues_count: number;
+    merge_requests_enabled: boolean;
+    jobs_enabled: boolean;
+    wiki_enabled: boolean;
+    snippets_enabled: boolean;
+    can_create_merge_request_in: boolean;
+    resolve_outdated_diff_discussions: boolean;
+    container_registry_enabled: boolean;
+    container_expiration_policy: {
+        cadence: string;
+        enabled: boolean;
+        keep_n?: number;
+        older_than?: string;
+        name_regex_delete?: string;
+        name_regex_keep?: string;
+        next_run_at: string;
+    };
+    creator_id: number;
+    namespace: NamespaceInfoSchema;
+    import_status: string;
+    import_error?: string;
+    permissions: {
+        project_access: AccessSchema;
+        group_access: AccessSchema;
+    };
     archived: boolean;
+    license_url: string;
+    license: Pick<LicenseTemplateSchema, 'key' | 'name' | 'nickname' | 'html_url' | 'source_url'>;
+    shared_runners_enabled: boolean;
+    runners_token: string;
+    ci_default_git_depth: number;
+    ci_forward_deployment_enabled: boolean;
+    public_jobs: boolean;
+    shared_with_groups?: SharedWithGroupSchema[];
+    repository_storage: string;
+    only_allow_merge_if_pipeline_succeeds: boolean;
+    allow_merge_on_skipped_pipeline: boolean;
+    restrict_user_defined_variables: boolean;
+    only_allow_merge_if_all_discussions_are_resolved: boolean;
+    remove_source_branch_after_merge: boolean;
+    printing_merge_requests_link_enabled: boolean;
+    request_access_enabled: boolean;
+    merge_method: string;
+    auto_devops_enabled: boolean;
+    auto_devops_deploy_strategy: string;
+    approvals_before_merge: number;
+    mirror: boolean;
+    mirror_user_id: number;
+    mirror_trigger_builds: boolean;
+    only_mirror_protected_branches: boolean;
+    mirror_overwrites_diverged_branches: boolean;
+    external_authorization_classification_label?: string;
+    packages_enabled: boolean;
+    service_desk_enabled: boolean;
+    service_desk_address?: string;
+    autoclose_referenced_issues: boolean;
+    suggestion_commit_message?: string;
+    marked_for_deletion_at: string;
+    marked_for_deletion_on: string;
+    compliance_frameworks?: string[];
+    statistics: {
+        commit_count: number;
+        storage_size: number;
+        repository_size: number;
+        wiki_size: number;
+        lfs_objects_size: number;
+        job_artifacts_size: number;
+        packages_size: number;
+        snippets_size: number;
+    };
+    container_registry_image_prefix: string;
+    _links: {
+        self: string;
+        issues: string;
+        merge_requests: string;
+        repo_branches: string;
+        labels: string;
+        events: string;
+        members: string;
+    };
 }
-export declare type ProjectSchema = ProjectSchemaDefault | ProjectSchemaCamelized;
-export declare class Projects extends BaseService {
-    all(options?: PaginatedRequestOptions): Promise<ProjectSchema[]>;
-    archive(projectId: string | number, options?: Sudo): Promise<Record<string, unknown>>;
+export declare class Projects<C extends boolean = false> extends BaseService<C> {
+    all(options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectSchema>[]>;
+    archive(projectId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ProjectExtendedSchema>>;
     create({ userId, ...options }: ({
@@ -52,25 +140,25 @@ name: string;
         userId?: number;
-    } & BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(projectId: string | number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    events(projectId: string | number, options?: BaseRequestOptions & EventOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectExtendedSchema>>;
+    edit(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectExtendedSchema>>;
     fork(projectId: string | number, { forkedFromId, ...options }?: {
         forkedFromId?: number;
-    } & BaseRequestOptions): Promise<Record<string, unknown>>;
-    forks(projectId: string | number, options?: BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    languages(projectId: string | number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    mirrorPull(projectId: string | number, options?: Sudo): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, options?: Sudo): Promise<Record<string, unknown>>;
-    removeFork(projectId: string | number, options?: Sudo): Promise<Record<string, unknown>>;
-    search(projectName: string, options?: BaseRequestOptions): Promise<ProjectSchema[]>;
-    share(projectId: string | number, groupId: string | number, groupAccess: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    show(projectId: string | number, options?: BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    star(projectId: string | number, options?: Sudo): Promise<Record<string, unknown>>;
-    statuses(projectId: string | number, sha: string, state: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    transfer(projectId: string | number, namespaceId: string | number): Promise<Record<string, unknown>>;
-    unarchive(projectId: string | number, options?: Sudo): Promise<Record<string, unknown>>;
-    unshare(projectId: string | number, groupId: string | number, options?: Sudo): Promise<Record<string, unknown>>;
-    unstar(projectId: string | number, options?: Sudo): Promise<Record<string, unknown>>;
-    upload(projectId: any, content: any, { metadata, ...options }?: {
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectExtendedSchema>>;
+    forks(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectExtendedSchema>[]>;
+    languages(projectId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, {
+        [name: string]: number;
+    }>>;
+    mirrorPull(projectId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    remove(projectId: string | number, options?: Sudo): Promise<void>;
+    removeFork(projectId: string | number, options?: Sudo): Promise<void>;
+    search(projectName: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectSchema>[]>;
+    share(projectId: string | number, groupId: string | number, groupAccess: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    show(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectExtendedSchema>>;
+    star(projectId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ProjectExtendedSchema>>;
+    transfer(projectId: string | number, namespaceId: string | number): Promise<import("../infrastructure").CamelizedRecord<C, ProjectExtendedSchema>>;
+    unarchive(projectId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ProjectExtendedSchema>>;
+    unshare(projectId: string | number, groupId: string | number, options?: Sudo): Promise<void>;
+    unstar(projectId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ProjectExtendedSchema>>;
+    upload(projectId: string | number, content: string, { metadata, ...options }?: {
         metadata?: UploadMetadata;
-    } & BaseRequestOptions): Promise<Record<string, unknown>>;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
 }

dist/types/services/ProjectSnippetAwardEmojis.d.ts

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

dist/types/services/ProjectSnippetDiscussions.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceDiscussions } from '../templates';
-import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export interface ProjectSnippetDiscussions extends ResourceDiscussions {
-    addNote(projectId: string | number, snippetId: string | number, discussionId: string | number, noteId: number, content: string, options?: BaseRequestOptions): any;
-    all(projectId: string | number, snippetId: string | number, options?: PaginatedRequestOptions): any;
-    create(projectId: string | number, snippetId: string | number, content: string, options?: BaseRequestOptions): any;
-    editNote(projectId: string | number, snippetId: string | number, discussionId: string | number, noteId: number, content: string, options?: BaseRequestOptions): any;
-    removeNote(projectId: string | number, snippetId: string | number, discussionId: string | number, noteId: number, options?: Sudo): any;
-    show(projectId: string | number, snippetId: string | number, discussionId: string | number, options?: Sudo): any;
+import { ResourceDiscussions, DiscussionSchema } from '../templates';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface ProjectSnippetDiscussions<C extends boolean = false> extends ResourceDiscussions<C> {
+    addNote(projectId: string | number, snippetId: string | number, discussionId: number, noteId: number, content: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, DiscussionSchema>>;
+    all(projectId: string | number, issueId: string | number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, DiscussionSchema>[]>;
+    create(projectId: string | number, snippetId: string | number, content: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, DiscussionSchema>>;
+    editNote(projectId: string | number, snippetId: string | number, discussionId: number, noteId: number, content: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, DiscussionSchema>>;
+    removeNote(projectId: string | number, snippetId: string | number, discussionId: number, noteId: number, options?: Sudo): any;
+    show(projectId: string | number, snippetId: string | number, discussionId: number, options?: Sudo): Promise<CamelizedRecord<C, DiscussionSchema>>;
 }
-export declare class ProjectSnippetDiscussions extends ResourceDiscussions {
-    constructor(options?: BaseServiceOptions);
+export declare class ProjectSnippetDiscussions<C extends boolean = false> extends ResourceDiscussions<C> {
+    constructor(options: BaseServiceOptions<C>);
 }

dist/types/services/ProjectSnippetNotes.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceNotes } from '../templates';
-import { PaginatedRequestOptions, BaseRequestOptions, Sudo } from '../infrastructure';
-export interface ProjectSnippetNotes extends ResourceNotes {
-    all(projectId: string | number, snippetId: string | number, options?: PaginatedRequestOptions): any;
-    create(projectId: string | number, snippetId: string | number, body: string, options?: BaseRequestOptions): any;
-    edit(projectId: string | number, snippetId: string | number, noteId: number, body: string, options?: BaseRequestOptions): any;
+import { ResourceNotes, NoteSchema } from '../templates';
+import { PaginatedRequestOptions, BaseRequestOptions, Sudo, CamelizedRecord } from '../infrastructure';
+export interface SnippetNoteSchema extends NoteSchema {
+    file_name: string;
+    expires_at: string;
+}
+export interface ProjectSnippetNotes<C extends boolean = false> extends ResourceNotes<C> {
+    all(projectId: string | number, snippetId: string | number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, SnippetNoteSchema>[]>;
+    create(projectId: string | number, snippetId: string | number, body: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, SnippetNoteSchema>>;
+    edit(projectId: string | number, snippetId: string | number, noteId: number, body: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, SnippetNoteSchema>>;
     remove(projectId: string | number, snippetId: string | number, noteId: number, options?: Sudo): any;
-    show(projectId: string | number, snippetId: string | number, noteId: number, options?: Sudo): any;
+    show(projectId: string | number, snippetId: string | number, noteId: number, options?: Sudo): Promise<CamelizedRecord<C, SnippetNoteSchema>>;
 }
-export declare class ProjectSnippetNotes extends ResourceNotes {
-    constructor(options?: BaseServiceOptions);
+export declare class ProjectSnippetNotes<C extends boolean = false> extends ResourceNotes<C> {
+    constructor(options: BaseServiceOptions<C>);
 }

dist/types/services/ProjectSnippets.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
 import { SnippetVisibility } from './Snippets';
-export declare class ProjectSnippets extends BaseService {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    content(projectId: string | number, snippetId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(projectId: string | number, title: string, fileName: string, code: string, visibility: SnippetVisibility, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(projectId: string | number, snippetId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, snippetId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, snippetId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    userAgentDetails(projectId: string | number, snippetId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+import { UserSchema } from './Users';
+export interface ProjectSnippetSchema extends Record<string, unknown> {
+    id: number;
+    title: string;
+    file_name: string;
+    description: string;
+    author: Pick<UserSchema, 'id' | 'username' | 'name' | 'state' | 'created_at'>;
+    updated_at: string;
+    created_at: string;
+    project_id: number;
+    web_url: string;
+    raw_url: string;
 }
+export declare class ProjectSnippets<C extends boolean = false> extends BaseService<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectSnippetSchema>[]>;
+    content(projectId: string | number, snippetId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    create(projectId: string | number, title: string, fileName: string, code: string, visibility: SnippetVisibility, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectSnippetSchema>>;
+    edit(projectId: string | number, snippetId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProjectSnippetSchema>>;
+    remove(projectId: string | number, snippetId: number, options?: Sudo): Promise<void>;
+    show(projectId: string | number, snippetId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ProjectSnippetSchema>>;
+    userAgentDetails(projectId: string | number, snippetId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, {
+        user_agent: string;
+        ip_address: string;
+        akismet_submitted: boolean;
+    }>>;
+}

dist/types/services/ProjectVariables.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
 import { ResourceVariables, ResourceVariableSchema } from '../templates';
-import { PaginatedRequestOptions, BaseRequestOptions } from '../infrastructure';
-export interface ProjectVariables extends ResourceVariables {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<ResourceVariableSchema[]>;
-    create(projectId: string | number, options?: BaseRequestOptions): any;
-    edit(projectId: string | number, keyId: string, options?: BaseRequestOptions): any;
-    show(projectId: string | number, keyId: string, options?: PaginatedRequestOptions): Promise<ResourceVariableSchema>;
-    remove(projectId: string | number, keyId: string, options?: PaginatedRequestOptions): any;
+import { BaseRequestOptions, PaginatedRequestOptions, CamelizedRecord } from '../infrastructure';
+export interface ProjectVariables<C extends boolean = false> extends ResourceVariables<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, ResourceVariableSchema>[]>;
+    create(projectId: string | number, options?: BaseRequestOptions): Promise<CamelizedRecord<C, ResourceVariableSchema>>;
+    edit(projectId: string | number, keyId: string, options?: BaseRequestOptions): Promise<CamelizedRecord<C, ResourceVariableSchema>>;
+    show(projectId: string | number, keyId: string, options?: PaginatedRequestOptions): Promise<CamelizedRecord<C, ResourceVariableSchema>>;
+    remove(projectId: string | number, keyId: string, options?: PaginatedRequestOptions): Promise<void>;
 }
-export declare class ProjectVariables extends ResourceVariables {
-    constructor(options?: BaseServiceOptions);
+export declare class ProjectVariables<C extends boolean = false> extends ResourceVariables<C> {
+    constructor(options: BaseServiceOptions<C>);
 }

dist/types/services/ProtectedBranches.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class ProtectedBranches extends BaseService {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    protect(projectId: string | number, branchName: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    show(projectId: string | number, branchName: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    unprotect(projectId: string | number, branchName: string, options?: Sudo): Promise<Record<string, unknown>>;
+export interface ProtectedBranchAccessLevelSchema {
+    access_level: 0 | 30 | 40 | 60;
+    access_level_description: string;
+    user_id?: number;
+    group_id?: number;
 }
+export interface ProtectedBranchSchema extends Record<string, unknown> {
+    id: number;
+    name: string;
+    push_access_levels?: ProtectedBranchAccessLevelSchema[];
+    merge_access_levels?: ProtectedBranchAccessLevelSchema[];
+    allow_force_push: boolean;
+    code_owner_approval_required: boolean;
+}
+export declare class ProtectedBranches<C extends boolean = false> extends BaseService<C> {
+    all(projectId: string | number, options?: {
+        search?: string;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProtectedBranchSchema>[]>;
+    protect(projectId: string | number, branchName: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProtectedBranchSchema>>;
+    show(projectId: string | number, branchName: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ProtectedBranchSchema>>;
+    unprotect(projectId: string | number, branchName: string, options?: Sudo): Promise<void>;
+}

dist/types/services/ProtectedTags.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class ProtectedTags extends BaseService {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    protect(projectId: string | number, tagName: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    show(projectId: string | number, tagName: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    unprotect(projectId: string | number, tagName: string, options?: Sudo): Promise<Record<string, unknown>>;
+export interface ProtectedTagAccessLevelSchema {
+    access_level: 0 | 30 | 40 | 60;
+    access_level_description: string;
 }
+export interface ProtectedTagSchema extends Record<string, unknown> {
+    name: string;
+    create_access_levels?: ProtectedTagAccessLevelSchema[];
+}
+export declare class ProtectedTags<C extends boolean = false> extends BaseService<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProtectedTagSchema>[]>;
+    protect(projectId: string | number, tagName: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ProtectedTagSchema>>;
+    show(projectId: string | number, tagName: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ProtectedTagSchema>>;
+    unprotect(projectId: string | number, tagName: string, options?: Sudo): Promise<void>;
+}

dist/types/services/PushRules.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, Sudo } from '../infrastructure';
-export declare class PushRules extends BaseService {
-    create(projectId: string | number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(projectId: string | number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+export interface PushRulesSchema extends Record<string, unknown> {
+    id: number;
+    project_id: number;
+    commit_message_regex: string;
+    commit_message_negative_regex: string;
+    branch_name_regex: string;
+    deny_delete_tag: boolean;
+    created_at: string;
+    member_check: boolean;
+    prevent_secrets: boolean;
+    author_email_regex: string;
+    file_name_regex: string;
+    max_file_size: number;
+    commit_committer_check?: boolean;
+    reject_unsigned_commits?: boolean;
 }
+export declare class PushRules<C extends boolean = false> extends BaseService<C> {
+    create(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PushRulesSchema>>;
+    edit(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, PushRulesSchema>>;
+    remove(projectId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, PushRulesSchema>>;
+    show(projectId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, PushRulesSchema>>;
+}

dist/types/services/ReleaseLinks.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class ReleaseLinks extends BaseService {
-    all(projectId: string | number, tagName: string, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(projectId: string | number, tagName: string, name: string, url: string, options?: Sudo): Promise<Record<string, unknown>>;
-    edit(projectId: string | number, tagName: string, linkId: number, options?: Sudo & ({
-        name: string;
-    } | {
-        url: string;
-    })): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, tagName: string, linkId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, tagName: string, linkId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+export interface ReleaseLinkSchema extends Record<string, unknown> {
+    id: number;
+    name: string;
+    url: string;
+    external: boolean;
+    link_type: string;
 }
+export declare class ReleaseLinks<C extends boolean = false> extends BaseService<C> {
+    all(projectId: string | number, tagName: string, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ReleaseLinkSchema>[]>;
+    create(projectId: string | number, tagName: string, name: string, url: string, options?: Sudo & {
+        filePath?: string;
+        linkType?: string;
+    }): Promise<import("../infrastructure").CamelizedRecord<C, ReleaseLinkSchema>>;
+    edit(projectId: string | number, tagName: string, linkId: number, options?: Sudo & {
+        name?: string;
+        url?: string;
+        filePath?: string;
+        linkType?: string;
+    }): Promise<import("../infrastructure").CamelizedRecord<C, ReleaseLinkSchema>>;
+    remove(projectId: string | number, tagName: string, linkId: number, options?: Sudo): Promise<void>;
+    show(projectId: string | number, tagName: string, linkId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ReleaseLinkSchema>>;
+}

dist/types/services/Releases.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { CommitSchema } from './Commits';
+import { MilestoneSchema } from '../templates';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class Releases extends BaseService {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(projectId: string | number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(projectId: string | number, tagName: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, tagName: string, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, tagName: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+export interface EvidenceSchema {
+    sha: string;
+    filepath: string;
+    collected_at: string;
 }
+export interface SourceSchema {
+    format: string;
+    url: string;
+}
+export interface LinkSchema {
+    id: number;
+    name: string;
+    url: string;
+    external: boolean;
+    link_type: string;
+}
+export interface ReleaseSchema extends Record<string, unknown> {
+    tag_name: string;
+    description: string;
+    name: string;
+    description_html: string;
+    created_at: string;
+    released_at: string;
+    user: Pick<UserSchema, 'name' | 'username' | 'id' | 'state' | 'avatar_url' | 'web_url'>;
+    commit: CommitSchema;
+    milestones?: MilestoneSchema[];
+    commit_path: string;
+    tag_path: string;
+    assets: {
+        count: number;
+        sources?: SourceSchema[];
+        links?: LinkSchema[];
+        evidence_file_path: string;
+    };
+    evidences?: EvidenceSchema[];
+}
+export declare class Releases<C extends boolean = false> extends BaseService<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ReleaseSchema>[]>;
+    create(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ReleaseSchema>>;
+    edit(projectId: string | number, tagName: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ReleaseSchema>>;
+    remove(projectId: string | number, tagName: string, options?: Sudo): Promise<void>;
+    show(projectId: string | number, tagName: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ReleaseSchema>>;
+}

dist/types/services/Repositories.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { CommitSchema, CommitDiffSchema } from './Commits';
 import { Sudo, BaseRequestOptions } from '../infrastructure';
 declare type ArchiveType = 'tar.gz' | 'tar.bz2' | 'tbz' | 'tbz2' | 'tb2' | 'bz2' | 'tar' | 'zip';
-export declare class Repositories extends BaseService {
-    compare(projectId: string | number, from: string, to: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    contributors(projectId: string | number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    mergeBase(projectId: string | number, refs: string[], options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+export interface RepositoryCompareSchema extends Record<string, unknown> {
+    commit: Pick<CommitSchema, 'id' | 'short_id' | 'title' | 'author_name' | 'author_email' | 'created_at'>;
+    commits?: Pick<CommitSchema, 'id' | 'short_id' | 'title' | 'author_name' | 'author_email' | 'created_at'>[];
+    diffs?: CommitDiffSchema[];
+    compare_timeout: boolean;
+    compare_same_ref: boolean;
+}
+export interface RepositoryContributorSchema extends Record<string, unknown> {
+    name: string;
+    email: string;
+    commits: number;
+    additions: number;
+    deletions: number;
+}
+export interface RepositoryTreeSchema extends Record<string, unknown> {
+    id: string;
+    name: string;
+    type: string;
+    path: string;
+    mode: string;
+}
+export declare class Repositories<C extends boolean = false> extends BaseService<C> {
+    compare(projectId: string | number, from: string, to: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, RepositoryCompareSchema>>;
+    contributors(projectId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, RepositoryContributorSchema>[]>;
+    mergeBase(projectId: string | number, refs: string[], options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, CommitSchema>>;
     showArchive(projectId: string | number, { fileType, ...options }?: {
         fileType?: ArchiveType;
-    } & Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    showBlob(projectId: string | number, sha: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    showBlobRaw(projectId: string | number, sha: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    tree(projectId: string | number, options?: BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    } & Sudo): Promise<void>;
+    showBlob(projectId: string | number, sha: string, options?: Sudo): Promise<Blob>;
+    showBlobRaw(projectId: string | number, sha: string, options?: Sudo): Promise<Blob>;
+    tree(projectId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, RepositoryTreeSchema>[]>;
 }
 export {};

dist/types/services/RepositoryFiles.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { CommitSchema } from './Commits';
 import { BaseRequestOptions, Sudo } from '../infrastructure';
-export interface RepositoryFileSchemaDefault {
+export interface RepositoryFileExtendedSchema extends Record<string, unknown> {
     file_name: string;
@@ -15,22 +16,17 @@ file_path: string;
 }
-export interface RepositoryFileSchemaCamelized {
-    fileName: string;
-    filePath: string;
-    size: number;
-    encoding: string;
-    content: string;
-    contentSha256: string;
-    ref: string;
-    blobId: string;
-    commitId: string;
-    lastCommitId: string;
+export interface RepositoryFileBlameSchema extends Record<string, unknown> {
+    commit: CommitSchema;
+    lines?: string[];
 }
-export declare type RepositoryFileSchema = RepositoryFileSchemaDefault | RepositoryFileSchemaCamelized;
-export declare class RepositoryFiles extends BaseService {
-    create(projectId: string | number, filePath: string, branch: string, content: string, commitMessage: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(projectId: string | number, filePath: string, branch: string, content: string, commitMessage: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, filePath: string, branch: string, commitMessage: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    show(projectId: string | number, filePath: string, ref: string, options?: Sudo): Promise<RepositoryFileSchema>;
-    showBlame(projectId: string | number, filePath: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    showRaw(projectId: string | number, filePath: string, ref: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+export interface RepositoryFileSchema extends Record<string, unknown> {
+    file_path: string;
+    branch: string;
 }
+export declare class RepositoryFiles<C extends boolean = false> extends BaseService<C> {
+    create(projectId: string | number, filePath: string, branch: string, content: string, commitMessage: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, RepositoryFileSchema>>;
+    edit(projectId: string | number, filePath: string, branch: string, content: string, commitMessage: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, RepositoryFileSchema>>;
+    remove(projectId: string | number, filePath: string, branch: string, commitMessage: string, options?: BaseRequestOptions): Promise<void>;
+    show(projectId: string | number, filePath: string, ref: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, RepositoryFileExtendedSchema>>;
+    showBlame(projectId: string | number, filePath: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, RepositoryFileBlameSchema>[]>;
+    showRaw(projectId: string | number, filePath: string, ref: string, options?: Sudo): Promise<Blob>;
+}

dist/types/services/Runners.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { ProjectSchema } from './Projects';
+import { JobSchema } from './Jobs';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export interface RunnerSchemaDefault {
+export interface RunnerSchema extends Record<string, unknown> {
     id: number;
@@ -11,26 +13,27 @@ description: string;
     online: boolean;
-    status: string;
+    status: 'running' | 'success' | 'failed' | 'canceled';
 }
-export interface RunnerSchemaCamelized {
-    id: number;
+export interface RunnerExtendedSchema extends RunnerSchema {
+    architecture?: string;
     description: string;
-    ipAddress: string;
-    active: boolean;
-    isShared: boolean;
-    name: string;
-    online: boolean;
-    status: string;
+    contacted_at: string;
+    platform?: string;
+    projects?: Pick<ProjectSchema, 'id' | 'name' | 'name_with_namespace' | 'path' | 'path_with_namespace'>;
+    revision?: string;
+    tag_list?: string[];
+    version?: string;
+    access_level: string;
+    maximum_timeout?: number;
 }
-export declare type RunnerSchema = RunnerSchemaDefault | RunnerSchemaCamelized;
-export declare class Runners extends BaseService {
+export declare class Runners<C extends boolean = false> extends BaseService<C> {
     all({ projectId, ...options }?: {
         projectId?: string | number;
-    } & PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    allOwned(options?: BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    edit(runnerId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    enable(projectId: string | number, runnerId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    disable(projectId: string | number, runnerId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    jobs(runnerId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    remove(runnerId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(runnerId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, RunnerSchema>[]>;
+    allOwned(options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, RunnerSchema>[]>;
+    edit(runnerId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, RunnerExtendedSchema>>;
+    enable(projectId: string | number, runnerId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, RunnerSchema>>;
+    disable(projectId: string | number, runnerId: number, options?: Sudo): Promise<void>;
+    jobs(runnerId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, JobSchema>[]>;
+    remove(runnerId: number, options?: Sudo): Promise<void>;
+    show(runnerId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, RunnerExtendedSchema>>;
 }

dist/types/services/Search.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions } from '../infrastructure';
-export declare class Search extends BaseService {
+export interface SearchResultSchema extends Record<string, unknown> {
+    id: number;
+    description: string;
+    name: string;
+    name_with_namespace: string;
+    path: string;
+    path_with_namespace: string;
+    created_at: string;
+    default_branch: string;
+    tag_list?: string[];
+    ssh_url_to_repo: string;
+    http_url_to_repo: string;
+    web_url: string;
+    avatar_url?: string;
+    star_count: number;
+    forks_count: number;
+    last_activity_at: string;
+}
+export declare class Search<C extends boolean = false> extends BaseService<C> {
     all(scope: string, search: string, { projectId, groupId, ...options }?: {
         projectId?: string | number;
         groupId?: string | number;
-    } & BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    } & BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, SearchResultSchema>[]>;
 }

dist/types/services/Services.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
-import { BaseRequestOptions, Sudo } from '../infrastructure';
+import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
 export declare type SupportedService = 'asana' | 'assembla' | 'bamboo' | 'bugzilla' | 'buildkite' | 'campfire' | 'custom-issue-tracker' | 'drone-ci' | 'emails-on-push' | 'external-wiki' | 'flowdock' | 'hangouts_chat' | 'hipchat' | 'irker' | 'jira' | 'kubernetes' | 'slack-slash-commands' | 'slack' | 'packagist' | 'pipelines-email' | 'pivotaltracker' | 'prometheus' | 'pushover' | 'redmine' | 'microsoft-teams' | 'mattermost' | 'mattermost-slash-commands' | 'teamcity' | 'jenkins' | 'jenkins-deprecated' | 'mock-ci' | 'youtrack';
-export declare class Services extends BaseService {
-    edit(projectId: string | number, serviceName: SupportedService, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, serviceName: SupportedService, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, serviceName: SupportedService, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+export interface ServiceSchema extends Record<string, unknown> {
+    id: number;
+    title: string;
+    slug: string;
+    created_at: string;
+    updated_at: string;
+    active: boolean;
+    commit_events: boolean;
+    push_events: boolean;
+    issues_events: boolean;
+    confidential_issues_events: boolean;
+    merge_requests_events: boolean;
+    tag_push_events: boolean;
+    note_events: boolean;
+    confidential_note_events: boolean;
+    pipeline_events: boolean;
+    wiki_page_events: boolean;
+    job_events: boolean;
+    comment_on_event_enabled: boolean;
 }
+export declare class Services<C extends boolean = false> extends BaseService<C> {
+    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ServiceSchema>[]>;
+    edit(projectId: string | number, serviceName: SupportedService, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ServiceSchema>>;
+    remove(projectId: string | number, serviceName: SupportedService, options?: Sudo): Promise<void>;
+    show(projectId: string | number, serviceName: SupportedService, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ServiceSchema>>;
+}

dist/types/services/SidekiqMetrics.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
-export declare class SidekiqMetrics extends BaseService {
-    queueMetrics(): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    processMetrics(): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    jobStats(): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    compoundMetrics(): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+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 interface SidekickCompoundMetricsSchema extends SidekickJobStatsSchema, SidekickQueueMetricsSchema, SidekickProcessMetricsSchema {
+}
+export declare class SidekiqMetrics<C extends boolean = false> extends BaseService<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>>;
+}

dist/types/services/Snippets.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
 export declare type SnippetVisibility = 'private' | 'public' | 'internal';
-export declare class Snippets extends BaseService {
+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 FileSchema {
+    path: string;
+    raw_url: string;
+}
+export interface SnippetExtendedSchema extends SnippetSchema {
+    expires_at?: string;
+    ssh_url_to_repo: string;
+    http_url_to_repo: string;
+    files?: FileSchema[];
+}
+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 BaseService<C> {
     all({ public: p, ...options }?: {
         public?: boolean;
-    } & PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    content(snippetId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(title: string, fileName: string, content: string, visibility: SnippetVisibility, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(snippetId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(snippetId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(snippetId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    userAgentDetails(snippetId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    } & 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>>;
 }

dist/types/services/SystemHooks.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class SystemHooks extends BaseService {
-    add(url: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    all(options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    edit(hookId: number, url: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(hookId: number, options?: Sudo): Promise<Record<string, unknown>>;
+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 BaseService<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>;
+}

dist/types/services/Tags.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { CommitSchema } from './Commits';
+import { ReleaseSchema } from './Releases';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class Tags extends BaseService {
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(projectId: string | number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, tagName: string, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, tagName: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+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 BaseService<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>>;
+}

dist/types/services/Todos.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
+import { ProjectSchema } from './Projects';
+import { MilestoneSchema } from '../templates';
 import { PaginatedRequestOptions, Sudo } from '../infrastructure';
-interface CreateTodoOptions extends Sudo {
-    resourceName?: 'mergerequest' | 'issue';
+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 extends BaseService {
-    all(options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(projectId: string | number, resourceId: number, { resourceName, ...options }?: CreateTodoOptions): Promise<Record<string, unknown>>;
-    done({ todoId, ...options }: {
+export declare class Todos<C extends boolean = false> extends BaseService<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<Record<string, unknown>>;
+    } & Sudo): Promise<import("../infrastructure").CamelizedRecord<C, TodoSchema>> | Promise<void>;
 }
-export {};

dist/types/services/Triggers.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
+import { UserSchema } from './Users';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class Triggers extends BaseService {
-    add(projectId: string | number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    all(projectId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    edit(projectId: string | number, triggerId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
+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 BaseService<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<Record<string, unknown>>;
-    remove(projectId: string | number, triggerId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, triggerId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    }): 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>>;
 }

dist/types/services/UserCustomAttributes.d.ts

 import { BaseServiceOptions } from '@gitbeaker/requester-utils';
-import { ResourceCustomAttributes } from '../templates';
-import { PaginatedRequestOptions, Sudo } from '../infrastructure';
-export interface UserCustomAttributes extends ResourceCustomAttributes {
-    all(userId: string | number, options?: PaginatedRequestOptions): any;
-    set(userId: string | number, customAttributeId: number, value: string, options?: Sudo): any;
-    remove(userId: string | number, customAttributeId: number, options?: Sudo): any;
-    show(userId: string | number, customAttributeId: number, options?: Sudo): any;
+import { ResourceCustomAttributes, CustomAttributeSchema } from '../templates';
+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 extends ResourceCustomAttributes {
-    constructor(options?: BaseServiceOptions);
+export declare class UserCustomAttributes<C extends boolean = false> extends ResourceCustomAttributes<C> {
+    constructor(options: BaseServiceOptions<C>);
 }

dist/types/services/UserEmails.d.ts

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

dist/types/services/UserGPGKeys.d.ts

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

dist/types/services/UserImpersonationTokens.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { PaginatedRequestOptions, Sudo } from '../infrastructure';
 declare type ImpersonationTokenScope = 'api' | 'read_user';
-export declare class UserImpersonationTokens extends BaseService {
-    all(userId: number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    add(userId: number, name: string, scopes: ImpersonationTokenScope, expiresAt: string, options?: Sudo): Promise<Record<string, unknown>>;
-    show(userId: number, tokenId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    revoke(userId: number, tokenId: number, options?: Sudo): Promise<Record<string, unknown>>;
+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 BaseService<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>;
+}
 export {};

dist/types/services/Users.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-import { EventOptions } from './Events';
-export interface UserSchemaDefault {
+import { ProjectExtendedSchema } from './Projects';
+import { EventOptions, EventSchema } from './Events';
+export interface UserSchema extends Record<string, unknown> {
     id: number;
@@ -11,14 +12,5 @@ name: string;
     web_url: string;
+    created_at?: string;
 }
-export interface UserSchemaCamelized {
-    id: number;
-    name: string;
-    username: string;
-    state: string;
-    avatarUrl: string;
-    webUrl: string;
-}
-export declare type UserSchema = UserSchemaDefault | UserSchemaCamelized;
-export interface UserDetailSchemaDefault extends UserSchemaDefault {
-    created_at: Date;
+export interface UserExtendedSchema extends UserSchema {
     bio?: string;
@@ -30,30 +22,37 @@ location?: string;
     twitter: string;
-    website_url?: 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 UserDetailSchemaCamelized extends UserSchemaCamelized {
-    createdAt: Date;
-    bio?: string;
-    location?: string;
-    publicEmail: string;
-    skype: string;
-    linkedin: string;
-    twitter: string;
-    websiteUrl?: string;
-    organization?: string;
+export interface UserActivitySchema extends Record<string, unknown> {
+    username: string;
+    last_activity_on: string;
+    last_activity_at: string;
 }
-export declare type UserDetailSchema = UserDetailSchemaDefault | UserSchemaCamelized;
-export declare class Users extends BaseService {
-    all(options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    activities(options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    projects(userId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    block(userId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    create(options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    current(options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    edit(userId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    events(userId: number, options?: BaseRequestOptions & EventOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    search(emailOrUsername: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    show(userId: number, options?: BaseRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    remove(userId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    unblock(userId: number, options?: Sudo): Promise<Record<string, unknown>>;
+export declare class Users<C extends boolean = false> extends BaseService<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>>>;
 }

dist/types/services/Version.d.ts

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

dist/types/services/VulnerabilityFindings.d.ts

 import { BaseService } from '@gitbeaker/requester-utils';
 import { PaginatedRequestOptions } from '../infrastructure';
-export declare class VulnerabilityFindings extends BaseService {
+export interface IdentifierSchema {
+    external_type: string;
+    external_id: string;
+    name: string;
+    url: string;
+}
+export interface LinkSchema {
+    url: string;
+}
+export interface ItemSchema {
+    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?: IdentifierSchema[];
+    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?: LinkSchema[];
+    location: {
+        file: string;
+        dependency: {
+            package: {
+                name: string;
+            };
+            version: string;
+        };
+    };
+    details: {
+        [custom_field: string]: {
+            name: string;
+            type: string;
+            items?: ItemSchema[];
+        };
+    };
+    solution: string;
+    blob_path: string;
+}
+export declare class VulnerabilityFindings<C extends boolean = false> extends BaseService<C> {
     all(projectId: string | number, options?: {
-        id: string | number;
-        reportType: string[];
-        scope: string;
-        severity: string[];
-        confidence: string[];
-        pipelineId: string | number;
-    } & PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+        reportType?: string[];
+        scope?: string;
+        severity?: string[];
+        confidence?: string[];
+        pipelineId?: string | number;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, VulnerabilityFindingSchema>[]>;
 }

dist/types/services/Wikis.d.ts

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

dist/types/templates/index.d.ts

 export * from './ResourceAccessRequests';
 export * from './ResourceAwardEmojis';
+export * from './ResourceNoteAwardEmojis';
 export * from './ResourceBadges';
@@ -4,0 +5,0 @@ export * from './ResourceCustomAttributes';

dist/types/templates/ResourceAccessRequests.d.ts

 import { BaseService, BaseServiceOptions } from '@gitbeaker/requester-utils';
 import { Sudo } from '../infrastructure';
-export declare type AccessLevel = 10 | 20 | 30 | 40 | 50;
-export declare class ResourceAccessRequests extends BaseService {
-    constructor(resourceType: string, options: BaseServiceOptions);
-    all(resourceId: string | number): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    request(resourceId: string | number): Promise<Record<string, unknown>>;
+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 BaseService<C> {
+    constructor(resourceType: string, options: BaseServiceOptions<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<Record<string, unknown>>;
-    deny(resourceId: string | number, userId: number): Promise<Record<string, unknown>>;
+    } & Sudo): Promise<import("../infrastructure").CamelizedRecord<C, AccessRequestSchema>>;
+    deny(resourceId: string | number, userId: number): Promise<void>;
 }

dist/types/templates/ResourceAwardEmojis.d.ts

 import { BaseService, BaseServiceOptions } from '@gitbeaker/requester-utils';
+import { UserSchema } from '../services/Users';
 import { PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class ResourceAwardEmojis extends BaseService {
+export interface AwardEmojiSchema extends Record<string, unknown> {
+    id: number;
+    name: string;
+    user: UserSchema;
+    created_at: string;
+    updated_at: string;
+    awardable_id: number;
+    awardable_type: string;
+}
+export declare function url(projectId: number | string, resourceType: string, resourceId: number | string, awardId?: number | null, noteId?: number): string;
+export declare class ResourceAwardEmojis<C extends boolean = false> extends BaseService<C> {
     protected resourceType: string;
-    constructor(resourceType: string, options: BaseServiceOptions);
-    all(projectId: string | number, resourceId: string | number, noteId: number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    award(projectId: string | number, resourceId: string | number, noteId: number, name: string, options?: Sudo): Promise<Record<string, unknown>>;
-    remove(projectId: string | number, resourceId: string | number, noteId: number, awardId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(projectId: string | number, resourceId: string | number, noteId: number, awardId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    constructor(resourceType: string, options: BaseServiceOptions<C>);
+    all(projectId: string | number, resourceIId: number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, AwardEmojiSchema>[]>;
+    award(projectId: string | number, resourceIId: number, name: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, AwardEmojiSchema>>;
+    remove(projectId: string | number, resourceIId: number, awardId: number, options?: Sudo): Promise<void>;
+    show(projectId: string | number, resourceIId: number, awardId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, AwardEmojiSchema>>;
 }

dist/types/templates/ResourceBadges.d.ts

 import { BaseService, BaseServiceOptions } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class ResourceBadges extends BaseService {
-    constructor(resourceType: string, options: BaseServiceOptions);
-    add(resourceId: string | number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    all(resourceId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    edit(resourceId: string | number, badgeId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    preview(resourceId: string | number, linkUrl: string, imageUrl: string, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    remove(resourceId: string | number, badgeId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(resourceId: string | number, badgeId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+export interface BadgeSchema extends Record<string, unknown> {
+    name: string;
+    id: number;
+    link_url: string;
+    image_url: string;
+    rendered_link_url: string;
+    rendered_image_url: string;
+    kind: 'project' | 'group';
 }
+export declare class ResourceBadges<C extends boolean = false> extends BaseService<C> {
+    constructor(resourceType: string, options: BaseServiceOptions<C>);
+    add(resourceId: string | number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, BadgeSchema>>;
+    all(resourceId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, BadgeSchema>[]>;
+    edit(resourceId: string | number, badgeId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, BadgeSchema>>;
+    preview(resourceId: string | number, linkUrl: string, imageUrl: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, Omit<BadgeSchema, "id" | "name" | "kind">>>;
+    remove(resourceId: string | number, badgeId: number, options?: Sudo): Promise<void>;
+    show(resourceId: string | number, badgeId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, BadgeSchema>>;
+}

dist/types/templates/ResourceCustomAttributes.d.ts

 import { BaseService, BaseServiceOptions } from '@gitbeaker/requester-utils';
 import { PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class ResourceCustomAttributes extends BaseService {
-    constructor(resourceType: string, options: BaseServiceOptions);
-    all(resourceId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    set(resourceId: string | number, customAttributeId: number, value: string, options?: Sudo): Promise<Record<string, unknown>>;
-    remove(resourceId: string | number, customAttributeId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(resourceId: string | number, customAttributeId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+export interface CustomAttributeSchema extends Record<string, unknown> {
+    key: string;
+    value: string;
 }
+export declare class ResourceCustomAttributes<C extends boolean = false> extends BaseService<C> {
+    constructor(resourceType: string, options: BaseServiceOptions<C>);
+    all(resourceId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, CustomAttributeSchema>[]>;
+    set(resourceId: string | number, customAttributeId: number, value: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, CustomAttributeSchema>>;
+    remove(resourceId: string | number, customAttributeId: number, options?: Sudo): Promise<void>;
+    show(resourceId: string | number, customAttributeId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, CustomAttributeSchema>>;
+}

dist/types/templates/ResourceDeployTokens.d.ts

 import { BaseService, BaseServiceOptions } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-declare type DeployTokenScope = 'read_repository' | 'read_registry' | 'write_registry';
-export declare class ResourceDeployTokens extends BaseService {
-    constructor(resourceType: string, options: BaseServiceOptions);
-    add(resourceId: string | number, tokenName: string, tokenScopes: DeployTokenScope[], options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    all({ resourceId, ...options }: {
+export declare type DeployTokenScope = 'read_repository' | 'read_registry' | 'write_registry' | 'read_package_registry' | 'write_package_registry';
+export interface DeployTokenSchema extends Record<string, unknown> {
+    id: number;
+    name: string;
+    username: string;
+    expires_at: string;
+    scopes?: string[];
+}
+export declare class ResourceDeployTokens<C extends boolean = false> extends BaseService<C> {
+    constructor(resourceType: string, options: BaseServiceOptions<C>);
+    add(resourceId: string | number, tokenName: string, tokenScopes: DeployTokenScope[], options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, DeployTokenSchema>>;
+    all({ resourceId, projectId, groupId, ...options }?: {
         resourceId?: string | number;
-    } & PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    remove(resourceId: string | number, tokenId: number, options?: Sudo): Promise<Record<string, unknown>>;
+        projectId?: string | number;
+        groupId?: string | number;
+    } & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, DeployTokenSchema>[]>;
+    remove(resourceId: string | number, tokenId: number, options?: Sudo): Promise<void>;
 }
-export {};

dist/types/templates/ResourceDiscussions.d.ts

 import { BaseService, BaseServiceOptions } from '@gitbeaker/requester-utils';
+import { UserSchema } from '../services/Users';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class ResourceDiscussions extends BaseService {
+export interface PositionSchema {
+    base_sha: string;
+    start_sha: string;
+    head_sha: string;
+    old_path: string;
+    new_path: string;
+    position_type: string;
+    old_line: number;
+    new_line: number;
+}
+export interface NotesEntitySchema {
+    id: number;
+    type?: string;
+    body: string;
+    attachment?: string;
+    author: Omit<UserSchema, 'created_at'>;
+    created_at: string;
+    updated_at: string;
+    system: boolean;
+    noteable_id: number;
+    noteable_type: string;
+    noteable_iid?: number;
+    resolvable: boolean;
+    position?: PositionSchema;
+}
+export interface DiscussionSchema extends Record<string, unknown> {
+    id: string;
+    individual_note: boolean;
+    notes?: NotesEntitySchema[];
+}
+export declare class ResourceDiscussions<C extends boolean = false> extends BaseService<C> {
     protected resource2Type: string;
-    constructor(resourceType: string, resource2Type: string, options: BaseServiceOptions);
-    addNote(resourceId: string | number, resource2Id: string | number, discussionId: string | number, noteId: number, content: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    all(resourceId: string | number, resource2Id: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(resourceId: string | number, resource2Id: string | number, content: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    editNote(resourceId: string | number, resource2Id: string | number, discussionId: string | number, noteId: number, content: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    removeNote(resourceId: string | number, resource2Id: string | number, discussionId: string | number, noteId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(resourceId: string | number, resource2Id: string | number, discussionId: string | number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    constructor(resourceType: string, resource2Type: string, options: BaseServiceOptions<C>);
+    addNote(resourceId: string | number, resource2Id: string | number, discussionId: string | number, noteId: number, content: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    all(resourceId: string | number, resource2Id: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, DiscussionSchema>[]>;
+    create(resourceId: string | number, resource2Id: string | number, content: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, DiscussionSchema>>;
+    editNote(resourceId: string | number, resource2Id: string | number, discussionId: string | number, noteId: number, content: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, DiscussionSchema>>;
+    removeNote(resourceId: string | number, resource2Id: string | number, discussionId: string | number, noteId: number, options?: Sudo): Promise<void>;
+    show(resourceId: string | number, resource2Id: string | number, discussionId: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, DiscussionSchema>>;
 }

dist/types/templates/ResourceIssueBoards.d.ts

@@ -1,15 +0,31 @@
-import { BaseService } from '@gitbeaker/requester-utils';
+import { BaseService, BaseServiceOptions } from '@gitbeaker/requester-utils';
+import { MilestoneSchema } from './ResourceMilestones';
+import { LabelSchema } from './ResourceLabels';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class ResourceIssueBoards extends BaseService {
-    constructor(resourceType: string, options: any);
-    all(resourceId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(resourceId: string | number, name: string, options?: Sudo): Promise<Record<string, unknown>>;
-    createList(resourceId: string | number, boardId: number, labelId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    edit(resourceId: string | number, boardId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    editList(resourceId: string | number, boardId: number, listId: number, position: number, options?: Sudo): Promise<Record<string, unknown>>;
-    lists(resourceId: string | number, boardId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    remove(resourceId: string | number, boardId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    removeList(resourceId: string | number, boardId: number, listId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(resourceId: string | number, boardId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    showList(resourceId: string | number, boardId: number, listId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+export interface IssueBoardListSchema extends Record<string, unknown> {
+    id: number;
+    label: Pick<LabelSchema, 'name' | 'color' | 'description'>;
+    position: number;
+    max_issue_count: number;
+    max_issue_weight: number;
+    limit_metric?: string;
 }
+export interface IssueBoardSchema extends Record<string, unknown> {
+    id: number;
+    name: string;
+    milestone: Pick<MilestoneSchema, 'id' | 'title'>;
+    lists?: IssueBoardListSchema[];
+}
+export declare class ResourceIssueBoards<C extends boolean = false> extends BaseService<C> {
+    constructor(resourceType: string, options: BaseServiceOptions<C>);
+    all(resourceId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, IssueBoardSchema>[]>;
+    create(resourceId: string | number, name: string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, IssueBoardSchema>>;
+    createList(resourceId: string | number, boardId: number, labelId: number | string, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, IssueBoardListSchema>>;
+    edit(resourceId: string | number, boardId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, Record<string, unknown>>>;
+    editList(resourceId: string | number, boardId: number, listId: number, position: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, IssueBoardListSchema>>;
+    lists(resourceId: string | number, boardId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, IssueBoardListSchema>[]>;
+    remove(resourceId: string | number, boardId: number, options?: Sudo): Promise<void>;
+    removeList(resourceId: string | number, boardId: number, listId: number, options?: Sudo): Promise<void>;
+    show(resourceId: string | number, boardId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, IssueBoardSchema>>;
+    showList(resourceId: string | number, boardId: number, listId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, IssueBoardListSchema>>;
+}

dist/types/templates/ResourceLabels.d.ts

 import { BaseService, BaseServiceOptions } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo, ShowExpanded } from '../infrastructure';
-export declare class ResourceLabels extends BaseService {
-    constructor(resourceType: string, options: BaseServiceOptions & ShowExpanded);
-    all(resourceId: string | number, options?: PaginatedRequestOptions & ShowExpanded): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(resourceId: string | number, labelName: string, color: string, options?: BaseRequestOptions & ShowExpanded): Promise<Record<string, unknown>>;
-    edit(resourceId: string | number, labelName: string, options?: BaseRequestOptions & ShowExpanded): Promise<Record<string, unknown>>;
-    remove(resourceId: string | number, labelName: string, options?: Sudo & ShowExpanded): Promise<Record<string, unknown>>;
-    subscribe(resourceId: string | number, labelId: number, options?: Sudo & ShowExpanded): Promise<Record<string, unknown>>;
-    unsubscribe(resourceId: string | number, labelId: number, options?: Sudo & ShowExpanded): Promise<Record<string, unknown>>;
+export interface LabelSchema extends Record<string, unknown> {
+    id: number;
+    name: string;
+    color: string;
+    text_color: string;
+    description: string;
+    description_html: string;
+    open_issues_count: number;
+    closed_issues_count: number;
+    open_merge_requests_count: number;
+    subscribed: boolean;
+    priority: number;
+    is_project_label: boolean;
 }
+export declare class ResourceLabels<C extends boolean = false> extends BaseService<C> {
+    constructor(resourceType: string, options: BaseServiceOptions<C>);
+    all(resourceId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, LabelSchema>[]>;
+    create(resourceId: string | number, labelName: string, color: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, LabelSchema>>;
+    edit(resourceId: string | number, labelId: number | string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, LabelSchema>>;
+    remove(resourceId: string | number, labelId: number | string, options?: Sudo & ShowExpanded): Promise<void>;
+    subscribe(resourceId: string | number, labelId: number | string, options?: Sudo & ShowExpanded): Promise<import("../infrastructure").CamelizedRecord<C, LabelSchema> | import("../infrastructure").ExpandedResponse<import("../infrastructure").CamelizedRecord<C, LabelSchema>>>;
+    unsubscribe(resourceId: string | number, labelId: number | string, options?: Sudo & ShowExpanded): Promise<import("../infrastructure").CamelizedRecord<C, LabelSchema> | import("../infrastructure").ExpandedResponse<import("../infrastructure").CamelizedRecord<C, LabelSchema>>>;
+}

dist/types/templates/ResourceMembers.d.ts

 import { BaseService, BaseServiceOptions } from '@gitbeaker/requester-utils';
 import { BaseRequestOptions, PaginatedRequestOptions, Sudo } from '../infrastructure';
 import { AccessLevel } from './ResourceAccessRequests';
-interface IncludeInherited {
+export interface IncludeInherited {
     includeInherited?: boolean;
 }
-export declare class ResourceMembers extends BaseService {
-    constructor(resourceType: string, options: BaseServiceOptions);
-    add(resourceId: string | number, userId: number, accessLevel: AccessLevel, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    all(resourceId: string | number, { includeInherited, ...options }?: IncludeInherited & PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    edit(resourceId: string | number, userId: number, accessLevel: AccessLevel, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    show(resourceId: string | number, userId: number, { includeInherited, ...options }?: IncludeInherited & Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    remove(resourceId: string | number, userId: number, options?: Sudo): Promise<Record<string, unknown>>;
+export interface MembersSchema extends Record<string, unknown> {
+    id: number;
+    username: string;
+    name: string;
+    state: string;
+    avatar_url: string;
+    web_url: string;
+    expires_at: string;
+    access_level: AccessLevel;
+    email: string;
+    group_saml_identity: {
+        extern_uid: string;
+        provider: string;
+        saml_provider_id: number;
+    };
 }
-export {};
+export declare class ResourceMembers<C extends boolean = false> extends BaseService<C> {
+    constructor(resourceType: string, options: BaseServiceOptions<C>);
+    add(resourceId: string | number, userId: number, accessLevel: AccessLevel, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MembersSchema>>;
+    all(resourceId: string | number, { includeInherited, ...options }?: IncludeInherited & PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MembersSchema>[]>;
+    edit(resourceId: string | number, userId: number, accessLevel: AccessLevel, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MembersSchema>>;
+    show(resourceId: string | number, userId: number, { includeInherited, ...options }?: IncludeInherited & Sudo): Promise<import("../infrastructure").CamelizedRecord<C, MembersSchema>>;
+    remove(resourceId: string | number, userId: number, options?: Sudo): Promise<void>;
+}

dist/types/templates/ResourceMilestones.d.ts

 import { BaseService, BaseServiceOptions } from '@gitbeaker/requester-utils';
 import { PaginatedRequestOptions, BaseRequestOptions, Sudo } from '../infrastructure';
-export declare class ResourceMilestones extends BaseService {
-    constructor(resourceType: string, options: BaseServiceOptions);
-    all(resourceId: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(resourceId: string | number, title: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(resourceId: string | number, milestoneId: number, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    issues(resourceId: string | number, milestoneId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    mergeRequests(resourceId: string | number, milestoneId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    show(resourceId: string | number, milestoneId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+import type { IssueSchema } from '../services/Issues';
+import type { MergeRequestSchema } from '../services/MergeRequests';
+export interface MilestoneSchema extends Record<string, unknown> {
+    id: number;
+    iid: number;
+    project_id: number;
+    title: string;
+    description: string;
+    due_date?: string;
+    start_date: string;
+    state: string;
+    updated_at: string;
+    created_at: string;
+    expired: boolean;
+    web_url?: string;
 }
+export declare class ResourceMilestones<C extends boolean = false> extends BaseService<C> {
+    constructor(resourceType: string, options: BaseServiceOptions<C>);
+    all(resourceId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MilestoneSchema>[]>;
+    create(resourceId: string | number, title: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MilestoneSchema>>;
+    edit(resourceId: string | number, milestoneId: number, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, MilestoneSchema>>;
+    issues(resourceId: string | number, milestoneId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, IssueSchema>[]>;
+    mergeRequests(resourceId: string | number, milestoneId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, MergeRequestSchema>[]>;
+    show(resourceId: string | number, milestoneId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, MilestoneSchema>>;
+}

dist/types/templates/ResourceNotes.d.ts

 import { BaseService, BaseServiceOptions } from '@gitbeaker/requester-utils';
+import { UserSchema } from '../services/Users';
 import { PaginatedRequestOptions, BaseRequestOptions, Sudo } from '../infrastructure';
-export declare class ResourceNotes extends BaseService {
+export interface NoteSchema extends Record<string, unknown> {
+    id: number;
+    body: string;
+    author: UserSchema;
+    created_at: string;
+    updated_at: string;
+    confidential: boolean;
+}
+export declare class ResourceNotes<C extends boolean = false> extends BaseService<C> {
     protected resource2Type: string;
-    constructor(resourceType: string, resource2Type: string, options: BaseServiceOptions);
-    all(resourceId: string | number, resource2Id: string | number, options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    create(resourceId: string | number, resource2Id: string | number, body: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    edit(resourceId: string | number, resource2Id: string | number, noteId: number, body: string, options?: BaseRequestOptions): Promise<Record<string, unknown>>;
-    remove(resourceId: string | number, resource2Id: string | number, noteId: number, options?: Sudo): Promise<Record<string, unknown>>;
-    show(resourceId: string | number, resource2Id: string | number, noteId: number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    constructor(resourceType: string, resource2Type: string, options: BaseServiceOptions<C>);
+    all(resourceId: string | number, resource2Id: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, NoteSchema>[]>;
+    create(resourceId: string | number, resource2Id: string | number, body: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, NoteSchema>>;
+    edit(resourceId: string | number, resource2Id: string | number, noteId: number, body: string, options?: BaseRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, NoteSchema>>;
+    remove(resourceId: string | number, resource2Id: string | number, noteId: number, options?: Sudo): Promise<void>;
+    show(resourceId: string | number, resource2Id: string | number, noteId: number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, NoteSchema>>;
 }

dist/types/templates/ResourceTemplates.d.ts

 import { BaseService, BaseServiceOptions } from '@gitbeaker/requester-utils';
 import { PaginatedRequestOptions, Sudo } from '../infrastructure';
-export declare class ResourceTemplates extends BaseService {
-    constructor(resourceType: string, options: BaseServiceOptions);
-    all(options?: PaginatedRequestOptions): Promise<Record<string, unknown> | Record<string, unknown>[]>;
-    show(resourceId: string | number, options?: Sudo): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+export interface ResourceTemplateSchema extends Record<string, unknown> {
+    name: string;
+    content: string;
 }
+export declare class ResourceTemplates<C extends boolean = false> extends BaseService<C> {
+    constructor(resourceType: string, options: BaseServiceOptions<C>);
+    all(options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ResourceTemplateSchema>[]>;
+    show(key: string | number, options?: Sudo): Promise<import("../infrastructure").CamelizedRecord<C, ResourceTemplateSchema>>;
+}

dist/types/templates/ResourceVariables.d.ts

 import { BaseService, BaseServiceOptions } from '@gitbeaker/requester-utils';
 import { PaginatedRequestOptions } from '../infrastructure';
-export interface ResourceVariableSchemaDefault {
+export interface ResourceVariableSchema extends Record<string, unknown> {
     variable_type: 'env_var' | 'file';
@@ -11,20 +11,9 @@ value: string;
 }
-export interface ResourceVariableSchemaCamelizedNoKey {
-    variableType: 'env_var' | 'file';
-    value: string;
-    protected: boolean;
-    masked: boolean;
-    environmentScope?: string;
+export declare class ResourceVariables<C extends boolean> extends BaseService<C> {
+    constructor(resourceType: string, options: BaseServiceOptions<C>);
+    all(resourceId: string | number, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ResourceVariableSchema>[]>;
+    create(resourceId: string | number, options?: ResourceVariableSchema): Promise<import("../infrastructure").CamelizedRecord<C, ResourceVariableSchema>>;
+    edit(resourceId: string | number, keyId: string, options?: Omit<ResourceVariableSchema, 'key'>): Promise<import("../infrastructure").CamelizedRecord<C, ResourceVariableSchema>>;
+    show(resourceId: string | number, keyId: string, options?: PaginatedRequestOptions): Promise<import("../infrastructure").CamelizedRecord<C, ResourceVariableSchema>>;
+    remove(resourceId: string | number, keyId: string, options?: PaginatedRequestOptions): Promise<void>;
 }
-export interface ResourceVariableSchemaCamelized extends ResourceVariableSchemaCamelizedNoKey {
-    key: string;
-}
-export declare type ResourceVariableSchema = ResourceVariableSchemaDefault | ResourceVariableSchemaCamelized;
-export declare class ResourceVariables extends BaseService {
-    constructor(resourceType: string, options: BaseServiceOptions);
-    all(resourceId: string | number, options?: PaginatedRequestOptions): Promise<ResourceVariableSchema[] | ResourceVariableSchema[][]>;
-    create(resourceId: string | number, options?: ResourceVariableSchemaCamelized): Promise<ResourceVariableSchema>;
-    edit(resourceId: string | number, keyId: string, options?: ResourceVariableSchemaCamelizedNoKey): Promise<ResourceVariableSchema>;
-    show(resourceId: string | number, keyId: string, options?: PaginatedRequestOptions): Promise<ResourceVariableSchema | ResourceVariableSchema[]>;
-    remove(resourceId: string | number, keyId: string, options?: PaginatedRequestOptions): Promise<Record<string, unknown>>;
-}

package.json

 {
   "name": "@gitbeaker/core",
   "description": "Core API implementation of the GitLab API. Supports Promises, Async/Await.",
-  "version": "28.4.1",
+  "version": "29.0.0--canary.1104.301157685.0",
   "author": {
@@ -12,4 +12,4 @@ "name": "Justin Dalrymple"
   "dependencies": {
-    "@gitbeaker/requester-utils": "^28.4.1",
-    "form-data": "^4.0.0",
+    "@gitbeaker/requester-utils": "29.0.0--canary.1104.301157685.0",
+    "form-data": "^3.0.0",
     "li": "^1.3.0",
@@ -19,10 +19,10 @@ "xcase": "^2.0.1"
   "devDependencies": {
-    "@types/node": "^15.0.1",
+    "@types/node": "^14.11.2",
     "esm": "^3.2.25",
-    "fs-extra": "^9.1.0",
+    "fs-extra": "^9.0.1",
     "get-param-names": "github:jdalrymple/get-param-names#1-improve-functionality",
-    "rollup": "^2.41.2",
+    "rollup": "^2.47.0",
     "rollup-plugin-typescript2": "^0.30.0",
     "ts-node": "^9.1.1",
-    "typescript": "^4.2.3"
+    "typescript": "^4.2.4"
   },
@@ -57,3 +57,3 @@ "engines": {
   },
-  "gitHead": "98d90e10b3aa5a788b51a6acfd4ceef1122daf87"
+  "gitHead": "1204ff4fd4c0c27d272f1ae7443bad2ef669fb6a"
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

683360

increased by13.21%

Number of package files

122

increased by1.67%

Lines of code

10389

increased by18.42%

Worsened metrics

Number of low quality alerts

1

increased byInfinity%

Dependency changes

• + Added@gitbeaker/requester-utils@29.0.0--canary.1104.301157685.0(transitive)

• + Addedform-data@3.0.2(transitive)

• + Addedquery-string@6.14.1(transitive)

• - Removed@gitbeaker/requester-utils@28.4.1(transitive)

• - Removedform-data@4.0.1(transitive)

• - Removedquery-string@7.1.3(transitive)

• Updated@gitbeaker/requester-utils@29.0.0--canary.1104.301157685.0

• Updatedform-data@^3.0.0