@gitbeaker/requester-utils 43.8.0 → 44.0.0-pre.0

package/dist/index.d.mts

@@ -1,133 +1,138 @@
-import { Agent } from 'http';
-
+import { Agent } from "http";
+//#region src/RequesterUtils.d.ts
 type RateLimiterFn = () => Promise<number>;
 type RateLimiters = Record<string, RateLimiterFn | {
-    method: string;
-    limit: RateLimiterFn;
+  method: string;
+  limit: RateLimiterFn;
 }>;
 type RateLimitOptions = Record<string, number | {
-    method: string;
-    limit: number;
+  method: string;
+  limit: number;
 }>;
-type ResponseBodyTypes = Record<string, unknown> | Record<string, unknown>[] | ReadableStream | Blob | string | string[] | number | void | null;
-interface FormattedResponse<T extends ResponseBodyTypes = ResponseBodyTypes> {
-    body: T;
-    headers: Record<string, string>;
-    status: number;
+type RequesterFn = (resourceOptions: ResourceOptions) => RequesterType;
+type ResponseBodyType = Record<string, unknown>[] | string[] | Record<string, unknown> | ReadableStream | Blob | string | number | null;
+type ResponseType = ResponseBodyType | void;
+interface FormattedResponse<T extends ResponseType = ResponseType> {
+  body: T;
+  headers: Record<string, string>;
+  status: number;
 }
 interface Constructable<T = any> {
-    new (...args: any[]): T;
+  new (...args: any[]): T;
 }
 type ResourceOptions = {
-    headers: {
-        [header: string]: string;
-    };
-    authHeaders: {
-        [authHeader: string]: () => Promise<string>;
-    };
-    url: string;
-    rateLimits?: RateLimitOptions;
-    rateLimitDuration?: number;
-    agent?: Agent;
-};
-type DefaultRequestOptions = {
-    body?: FormData | Record<string, unknown>;
-    searchParams?: Record<string, unknown>;
-    sudo?: string | number;
-    method?: string;
-    asStream?: boolean;
-    signal?: AbortSignal;
+  headers: {
+    [header: string]: string;
+  };
+  authHeaders: {
+    [authHeader: string]: () => Promise<string>;
+  };
+  url: string;
+  rateLimits?: RateLimitOptions;
+  rateLimitDuration?: number;
+  agent?: Agent;
 };
-type RequestOptions = {
-    headers?: Record<string, string>;
-    timeout?: number;
-    method?: string;
-    searchParams?: string;
-    prefixUrl?: string;
-    body?: string | FormData;
-    asStream?: boolean;
-    signal?: AbortSignal;
-    rateLimiters?: Record<string, RateLimiterFn>;
-    agent?: Agent;
+type RequesterBodyType = Record<string, unknown> | Record<string, unknown>[] | FormData | Blob | ArrayBuffer;
+type RequesterSearchParams = Record<string, Record<string, string | number>[] | number[] | string[] | Record<string, string | number> | string | number | boolean>;
+type DefaultRequesterOptions = {
+  body?: RequesterBodyType;
+  searchParams?: RequesterSearchParams;
+  sudo?: string | number;
+  asStream?: boolean;
+  signal?: AbortSignal;
 };
 interface RequesterType {
-    get<T extends ResponseBodyTypes>(endpoint: string, options?: DefaultRequestOptions): Promise<FormattedResponse<T>>;
-    post<T extends ResponseBodyTypes>(endpoint: string, options?: DefaultRequestOptions): Promise<FormattedResponse<T>>;
-    put<T extends ResponseBodyTypes>(endpoint: string, options?: DefaultRequestOptions): Promise<FormattedResponse<T>>;
-    patch<T extends ResponseBodyTypes>(endpoint: string, options?: DefaultRequestOptions): Promise<FormattedResponse<T>>;
-    delete<T extends ResponseBodyTypes>(endpoint: string, options?: DefaultRequestOptions): Promise<FormattedResponse<T>>;
+  get<T extends ResponseType>(endpoint: string, options?: DefaultRequesterOptions): Promise<FormattedResponse<T>>;
+  post<T extends ResponseType>(endpoint: string, options?: DefaultRequesterOptions): Promise<FormattedResponse<T>>;
+  put<T extends ResponseType>(endpoint: string, options?: DefaultRequesterOptions): Promise<FormattedResponse<T>>;
+  patch<T extends ResponseType>(endpoint: string, options?: DefaultRequesterOptions): Promise<FormattedResponse<T>>;
+  delete<T extends ResponseType>(endpoint: string, options?: DefaultRequesterOptions): Promise<FormattedResponse<T>>;
 }
-type RequestHandlerFn<T extends ResponseBodyTypes = ResponseBodyTypes> = (endpoint: string, options?: Record<string, unknown>) => Promise<FormattedResponse<T>>;
-declare function generateRateLimiterFn(limit: number, interval: number): () => Promise<any>;
-declare function formatQuery(params?: Record<string, unknown>): string;
+type RequestOptions = {
+  headers?: Record<string, string>;
+  timeout?: number;
+  method?: string;
+  searchParams?: string;
+  prefixUrl?: string;
+  body?: BodyInit;
+  asStream?: boolean;
+  signal?: AbortSignal;
+  rateLimiters?: RateLimiters;
+  agent?: Agent;
+};
+type RequestHandlerFn<T extends ResponseType = ResponseType> = (endpoint: string, options?: RequestOptions) => Promise<FormattedResponse<T>>;
 type OptionsHandlerFn = (serviceOptions: ResourceOptions, requestOptions: RequestOptions) => Promise<RequestOptions>;
-declare function defaultOptionsHandler(resourceOptions: ResourceOptions, { body, searchParams, sudo, signal, asStream, method, }?: DefaultRequestOptions): Promise<RequestOptions>;
+type PresetConstructors<T> = { [K in keyof T]: T[K]; };
+declare function generateRateLimiterFn(limit: number, interval: number): () => Promise<number>;
+declare function formatQuery(params?: Record<string, unknown>): string;
+declare function defaultOptionsHandler(resourceOptions: ResourceOptions, { body, searchParams, sudo, signal, asStream, method }?: {
+  method?: string;
+} & DefaultRequesterOptions): Promise<RequestOptions>;
 declare function createRateLimiters(rateLimitOptions?: RateLimitOptions, rateLimitDuration?: number): RateLimiters;
 declare function createRequesterFn(optionsHandler: OptionsHandlerFn, requestHandler: RequestHandlerFn): (serviceOptions: ResourceOptions) => RequesterType;
-type PresetConstructors<T> = {
-    [K in keyof T]: T[K];
-};
-declare function presetResourceArguments<T extends Record<string, any>>(resources: T, customConfig?: Record<string, unknown>): PresetConstructors<T>;
+declare function presetResourceArguments<T extends Record<string, any>, Config extends Record<string, unknown>>(resources: T, customConfig?: Config): PresetConstructors<T>;
 declare function getMatchingRateLimiter(endpoint: string, rateLimiters?: RateLimiters, method?: string): RateLimiterFn;
-
+//#endregion
+//#region src/BaseResource.d.ts
 interface RootResourceOptions<C> {
-    requesterFn?: (resourceOptions: ResourceOptions) => RequesterType;
-    host?: string;
-    prefixUrl?: string;
-    camelize?: C;
-    queryTimeout?: number | null;
-    rateLimitDuration?: number;
-    sudo?: string | number;
-    profileToken?: string;
-    profileMode?: 'execution' | 'memory';
-    rateLimits?: RateLimitOptions;
-    agent?: Agent;
+  requesterFn?: RequesterFn;
+  host?: string;
+  prefixUrl?: string;
+  camelize?: C;
+  queryTimeout?: number;
+  rateLimitDuration?: number;
+  sudo?: string | number;
+  profileToken?: string;
+  profileMode?: 'execution' | 'memory';
+  rateLimits?: RateLimitOptions;
+  agent?: Agent;
 }
 type GitlabToken = string | (() => Promise<string>);
 interface BaseRequestOptionsWithOAuthToken<C> extends RootResourceOptions<C> {
-    oauthToken: GitlabToken;
+  oauthToken: GitlabToken;
 }
 interface BaseRequestOptionsWithAccessToken<C> extends RootResourceOptions<C> {
-    token: GitlabToken;
+  token: GitlabToken;
 }
 interface BaseRequestOptionsWithJobToken<C> extends RootResourceOptions<C> {
-    jobToken: GitlabToken;
+  jobToken: GitlabToken;
 }
 type BaseRequestOptionsWithoutToken<C> = RootResourceOptions<C>;
 type BaseResourceOptions<C> = BaseRequestOptionsWithoutToken<C> | BaseRequestOptionsWithOAuthToken<C> | BaseRequestOptionsWithAccessToken<C> | BaseRequestOptionsWithJobToken<C>;
 declare class BaseResource<C extends boolean = false> {
-    readonly url: string;
-    readonly requester: RequesterType;
-    readonly queryTimeout: number | null;
-    readonly headers: {
-        [header: string]: string;
-    };
-    readonly authHeaders: {
-        [authHeader: string]: () => Promise<string>;
-    };
-    readonly camelize: C | undefined;
-    constructor({ sudo, profileToken, camelize, requesterFn, agent, profileMode, host, prefixUrl, queryTimeout, rateLimitDuration, rateLimits, ...tokens }: BaseResourceOptions<C>);
+  readonly url: string;
+  readonly requester: RequesterType;
+  headers: {
+    [header: string]: string;
+  };
+  readonly authHeaders: {
+    [authHeader: string]: () => Promise<string>;
+  };
+  readonly camelize: C | undefined;
+  readonly queryTimeout?: number;
+  constructor({ sudo, profileToken, camelize, requesterFn, agent, profileMode, host, prefixUrl, queryTimeout, rateLimitDuration, rateLimits, ...tokens }?: BaseResourceOptions<C>);
 }
-
+//#endregion
+//#region src/GitbeakerError.d.ts
 declare class GitbeakerRequestError extends Error {
-    readonly cause?: {
-        description: string;
-        request: Request;
-        response: Response;
+  readonly cause?: {
+    description: string;
+    request: Request;
+    response: Response;
+  };
+  constructor(message: string, options?: {
+    cause?: {
+      description: string;
+      request: Request;
+      response: Response;
     };
-    constructor(message: string, options?: {
-        cause?: {
-            description: string;
-            request: Request;
-            response: Response;
-        };
-    });
+  });
 }
 declare class GitbeakerTimeoutError extends Error {
-    constructor(message: string, options?: ErrorOptions);
+  constructor(message: string, options?: ErrorOptions);
 }
 declare class GitbeakerRetryError extends Error {
-    constructor(message: string, options?: ErrorOptions);
+  constructor(message: string, options?: ErrorOptions);
 }
-
-export { type BaseRequestOptionsWithAccessToken, type BaseRequestOptionsWithJobToken, type BaseRequestOptionsWithOAuthToken, type BaseRequestOptionsWithoutToken, BaseResource, type BaseResourceOptions, type Constructable, type DefaultRequestOptions, type FormattedResponse, GitbeakerRequestError, GitbeakerRetryError, GitbeakerTimeoutError, type GitlabToken, type OptionsHandlerFn, type RateLimitOptions, type RateLimiterFn, type RateLimiters, type RequestHandlerFn, type RequestOptions, type RequesterType, type ResourceOptions, type ResponseBodyTypes, type RootResourceOptions, createRateLimiters, createRequesterFn, defaultOptionsHandler, formatQuery, generateRateLimiterFn, getMatchingRateLimiter, presetResourceArguments };
+//#endregion
+export { BaseRequestOptionsWithAccessToken, BaseRequestOptionsWithJobToken, BaseRequestOptionsWithOAuthToken, BaseRequestOptionsWithoutToken, BaseResource, BaseResourceOptions, Constructable, DefaultRequesterOptions, FormattedResponse, GitbeakerRequestError, GitbeakerRetryError, GitbeakerTimeoutError, GitlabToken, OptionsHandlerFn, RateLimitOptions, RateLimiterFn, RateLimiters, RequestHandlerFn, RequestOptions, RequesterBodyType, RequesterFn, RequesterSearchParams, RequesterType, ResourceOptions, ResponseBodyType, ResponseType, RootResourceOptions, createRateLimiters, createRequesterFn, defaultOptionsHandler, formatQuery, generateRateLimiterFn, getMatchingRateLimiter, presetResourceArguments };

package/dist/index.mjs

@@ -1,225 +1,204 @@
-import { stringify } from 'qs';
-import { decamelizeKeys } from 'xcase';
-import { RateLimiterQueue, RateLimiterMemory } from 'rate-limiter-flexible';
-import Picomatch from 'picomatch-browser';
-
-// src/RequesterUtils.ts
-var { isMatch: isGlobMatch } = Picomatch;
+import Picomatch from "picomatch";
+import { stringify } from "picoquery";
+import { RateLimiterMemory, RateLimiterQueue } from "rate-limiter-flexible";
+import { decamelizeKeys } from "xcase";
+//#region src/RequesterUtils.ts
+const { isMatch: isGlobMatch } = Picomatch;
 function generateRateLimiterFn(limit, interval) {
-  const limiter = new RateLimiterQueue(
-    new RateLimiterMemory({ points: limit, duration: interval })
-  );
-  return () => limiter.removeTokens(1);
+	const limiter = new RateLimiterQueue(new RateLimiterMemory({
+		points: limit,
+		duration: interval
+	}));
+	return () => limiter.removeTokens(1);
 }
 function formatQuery(params = {}) {
-  const decamelized = decamelizeKeys(params);
-  return stringify(decamelized, { arrayFormat: "brackets" });
+	return stringify(decamelizeKeys(params), {
+		nesting: true,
+		nestingSyntax: "index",
+		arrayRepeat: true,
+		arrayRepeatSyntax: "bracket"
+	});
 }
-async function defaultOptionsHandler(resourceOptions, {
-  body,
-  searchParams,
-  sudo,
-  signal,
-  asStream = false,
-  method = "GET"
-} = {}) {
-  const { headers: preconfiguredHeaders, authHeaders, url, agent } = resourceOptions;
-  const defaultOptions = {
-    method,
-    asStream,
-    signal,
-    prefixUrl: url,
-    agent
-  };
-  defaultOptions.headers = { ...preconfiguredHeaders };
-  if (sudo) defaultOptions.headers.sudo = `${sudo}`;
-  if (body) {
-    if (body instanceof FormData) {
-      defaultOptions.body = body;
-    } else {
-      defaultOptions.body = JSON.stringify(decamelizeKeys(body));
-      defaultOptions.headers["content-type"] = "application/json";
-    }
-  }
-  if (Object.keys(authHeaders).length > 0) {
-    const [authHeaderKey, authHeaderFn] = Object.entries(authHeaders)[0];
-    defaultOptions.headers[authHeaderKey] = await authHeaderFn();
-  }
-  const q = formatQuery(searchParams);
-  if (q) defaultOptions.searchParams = q;
-  return Promise.resolve(defaultOptions);
+async function defaultOptionsHandler(resourceOptions, { body, searchParams, sudo, signal, asStream = false, method = "GET" } = {}) {
+	const { headers: preconfiguredHeaders, authHeaders, url, agent } = resourceOptions;
+	const defaultOptions = {
+		method,
+		asStream,
+		signal,
+		prefixUrl: url,
+		agent
+	};
+	defaultOptions.headers = { ...preconfiguredHeaders };
+	if (sudo) defaultOptions.headers.sudo = `${sudo}`;
+	if (body instanceof FormData || body instanceof Blob || body instanceof ArrayBuffer || typeof body === "string") {
+		defaultOptions.body = body;
+		if (body instanceof Blob && body.type) defaultOptions.headers["Content-Type"] = body.type;
+	} else if (body != null) {
+		defaultOptions.body = JSON.stringify(decamelizeKeys(body));
+		defaultOptions.headers["Content-Type"] = "application/json";
+	}
+	if (Object.keys(authHeaders).length > 0) {
+		const [authHeaderKey, authHeaderFn] = Object.entries(authHeaders)[0];
+		defaultOptions.headers[authHeaderKey] = await authHeaderFn();
+	}
+	const q = formatQuery(searchParams);
+	if (q) defaultOptions.searchParams = q;
+	return Promise.resolve(defaultOptions);
 }
 function createRateLimiters(rateLimitOptions = {}, rateLimitDuration = 60) {
-  const rateLimiters = {};
-  Object.entries(rateLimitOptions).forEach(([key, config]) => {
-    if (typeof config === "number")
-      rateLimiters[key] = generateRateLimiterFn(config, rateLimitDuration);
-    else
-      rateLimiters[key] = {
-        method: config.method.toUpperCase(),
-        limit: generateRateLimiterFn(config.limit, rateLimitDuration)
-      };
-  });
-  return rateLimiters;
+	const rateLimiters = {};
+	Object.entries(rateLimitOptions).forEach(([key, config]) => {
+		if (typeof config === "number") rateLimiters[key] = generateRateLimiterFn(config, rateLimitDuration);
+		else rateLimiters[key] = {
+			method: config.method.toUpperCase(),
+			limit: generateRateLimiterFn(config.limit, rateLimitDuration)
+		};
+	});
+	return rateLimiters;
 }
 function createRequesterFn(optionsHandler, requestHandler) {
-  const methods = ["get", "post", "put", "patch", "delete"];
-  return (serviceOptions) => {
-    const requester = {};
-    const rateLimiters = createRateLimiters(
-      serviceOptions.rateLimits,
-      serviceOptions.rateLimitDuration
-    );
-    methods.forEach((m) => {
-      requester[m] = async (endpoint, options) => {
-        const defaultRequestOptions = await defaultOptionsHandler(serviceOptions, {
-          ...options,
-          method: m.toUpperCase()
-        });
-        const requestOptions = await optionsHandler(serviceOptions, defaultRequestOptions);
-        return requestHandler(endpoint, { ...requestOptions, rateLimiters });
-      };
-    });
-    return requester;
-  };
+	const methods = [
+		"get",
+		"post",
+		"put",
+		"patch",
+		"delete"
+	];
+	return (serviceOptions) => {
+		const requester = {};
+		const rateLimiters = createRateLimiters(serviceOptions.rateLimits, serviceOptions.rateLimitDuration);
+		methods.forEach((m) => {
+			requester[m] = async (endpoint, options) => {
+				return requestHandler(endpoint, {
+					...await optionsHandler(serviceOptions, await defaultOptionsHandler(serviceOptions, {
+						...options,
+						method: m.toUpperCase()
+					})),
+					rateLimiters
+				});
+			};
+		});
+		return requester;
+	};
 }
 function createPresetConstructor(Constructor, presetConfig) {
-  return class extends Constructor {
-    constructor(...args) {
-      const [config, ...rest] = args;
-      super({ ...presetConfig, ...config }, ...rest);
-    }
-  };
+	return class extends Constructor {
+		constructor(...args) {
+			const [config, ...rest] = args;
+			super({
+				...presetConfig,
+				...config
+			}, ...rest);
+		}
+	};
 }
 function presetResourceArguments(resources, customConfig = {}) {
-  const result = {};
-  Object.entries(resources).forEach(([key, Constructor]) => {
-    if (typeof Constructor === "function") {
-      result[key] = createPresetConstructor(
-        Constructor,
-        customConfig
-      );
-    } else {
-      result[key] = Constructor;
-    }
-  });
-  return result;
+	const result = {};
+	Object.entries(resources).forEach(([key, Constructor]) => {
+		if (typeof Constructor === "function") result[key] = createPresetConstructor(Constructor, customConfig);
+		else result[key] = Constructor;
+	});
+	return result;
 }
 function getMatchingRateLimiter(endpoint, rateLimiters = {}, method = "GET") {
-  const sortedEndpoints = Object.keys(rateLimiters).sort().reverse();
-  const match = sortedEndpoints.find((ep) => isGlobMatch(endpoint, ep));
-  const rateLimitConfig = match && rateLimiters[match];
-  if (typeof rateLimitConfig === "function") return rateLimitConfig;
-  if (rateLimitConfig && rateLimitConfig?.method?.toUpperCase() === method.toUpperCase()) {
-    return rateLimitConfig.limit;
-  }
-  return generateRateLimiterFn(3e3, 60);
+	const match = Object.keys(rateLimiters).sort().reverse().find((ep) => isGlobMatch(endpoint, ep));
+	const rateLimitConfig = match && rateLimiters[match];
+	if (typeof rateLimitConfig === "function") return rateLimitConfig;
+	if (rateLimitConfig && rateLimitConfig?.method?.toUpperCase() === method.toUpperCase()) return rateLimitConfig.limit;
+	return generateRateLimiterFn(3e3, 60);
 }
-
-// src/BaseResource.ts
+//#endregion
+//#region src/BaseResource.ts
 function getDynamicToken(tokenArgument) {
-  return tokenArgument instanceof Function ? tokenArgument() : Promise.resolve(tokenArgument);
+	return tokenArgument instanceof Function ? tokenArgument() : Promise.resolve(tokenArgument);
 }
-var DEFAULT_RATE_LIMITS = Object.freeze({
-  // Default rate limit
-  "**": 3e3,
-  // Import/Export
-  "projects/import": 6,
-  "projects/*/export": 6,
-  "projects/*/download": 1,
-  "groups/import": 6,
-  "groups/*/export": 6,
-  "groups/*/download": 1,
-  // Note creation
-  "projects/*/issues/*/notes": {
-    method: "post",
-    limit: 300
-  },
-  "projects/*/snippets/*/notes": {
-    method: "post",
-    limit: 300
-  },
-  "projects/*/merge_requests/*/notes": {
-    method: "post",
-    limit: 300
-  },
-  "groups/*/epics/*/notes": {
-    method: "post",
-    limit: 300
-  },
-  // Repositories - get file archive
-  "projects/*/repository/archive*": 5,
-  // Project Jobs
-  "projects/*/jobs": 600,
-  // Member deletion
-  "projects/*/members": 60,
-  "groups/*/members": 60
+const DEFAULT_RATE_LIMITS = Object.freeze({
+	"**": 3e3,
+	"projects/import": 6,
+	"projects/*/export": 6,
+	"projects/*/download": 1,
+	"groups/import": 6,
+	"groups/*/export": 6,
+	"groups/*/download": 1,
+	"projects/*/issues/*/notes": {
+		method: "post",
+		limit: 300
+	},
+	"projects/*/snippets/*/notes": {
+		method: "post",
+		limit: 300
+	},
+	"projects/*/merge_requests/*/notes": {
+		method: "post",
+		limit: 300
+	},
+	"groups/*/epics/*/notes": {
+		method: "post",
+		limit: 300
+	},
+	"projects/*/repository/archive*": 5,
+	"projects/*/jobs": 600,
+	"projects/*/members": 60,
+	"groups/*/members": 60
 });
 var BaseResource = class {
-  url;
-  requester;
-  queryTimeout;
-  headers;
-  authHeaders;
-  camelize;
-  constructor({
-    sudo,
-    profileToken,
-    camelize,
-    requesterFn,
-    agent,
-    profileMode = "execution",
-    host = "https://gitlab.com",
-    prefixUrl = "",
-    queryTimeout = 3e5,
-    rateLimitDuration = 60,
-    rateLimits = DEFAULT_RATE_LIMITS,
-    ...tokens
-  }) {
-    if (!requesterFn) throw new ReferenceError("requesterFn must be passed");
-    this.url = [host, "api", "v4", prefixUrl].join("/");
-    this.headers = {};
-    this.authHeaders = {};
-    this.camelize = camelize;
-    this.queryTimeout = queryTimeout;
-    if ("oauthToken" in tokens)
-      this.authHeaders.authorization = async () => {
-        const token = await getDynamicToken(tokens.oauthToken);
-        return `Bearer ${token}`;
-      };
-    else if ("jobToken" in tokens)
-      this.authHeaders["job-token"] = async () => getDynamicToken(tokens.jobToken);
-    else if ("token" in tokens)
-      this.authHeaders["private-token"] = async () => getDynamicToken(tokens.token);
-    if (profileToken) {
-      this.headers["X-Profile-Token"] = profileToken;
-      this.headers["X-Profile-Mode"] = profileMode;
-    }
-    if (sudo) this.headers.Sudo = `${sudo}`;
-    this.requester = requesterFn({ ...this, rateLimits, rateLimitDuration, agent });
-  }
+	url;
+	requester;
+	headers;
+	authHeaders;
+	camelize;
+	queryTimeout;
+	constructor({ sudo, profileToken, camelize, requesterFn, agent, profileMode = "execution", host = "https://gitlab.com", prefixUrl = "", queryTimeout = 3e5, rateLimitDuration = 60, rateLimits = DEFAULT_RATE_LIMITS, ...tokens } = {}) {
+		if (!requesterFn) throw new ReferenceError("Missing requesterFn: BaseResource requires a function to handle HTTP requests");
+		this.url = [
+			host,
+			"api",
+			"v4",
+			prefixUrl
+		].join("/");
+		this.headers = {};
+		this.authHeaders = {};
+		this.camelize = camelize;
+		this.queryTimeout = queryTimeout;
+		if ("oauthToken" in tokens) this.authHeaders.authorization = async () => {
+			return `Bearer ${await getDynamicToken(tokens.oauthToken)}`;
+		};
+		else if ("jobToken" in tokens) this.authHeaders["job-token"] = async () => getDynamicToken(tokens.jobToken);
+		else if ("token" in tokens) this.authHeaders["private-token"] = async () => getDynamicToken(tokens.token);
+		if (profileToken) {
+			this.headers["X-Profile-Token"] = profileToken;
+			this.headers["X-Profile-Mode"] = profileMode;
+		}
+		if (sudo) this.headers.Sudo = `${sudo}`;
+		this.requester = requesterFn({
+			...this,
+			rateLimits,
+			rateLimitDuration,
+			agent
+		});
+	}
 };
-
-// src/GitbeakerError.ts
+//#endregion
+//#region src/GitbeakerError.ts
 var GitbeakerRequestError = class extends Error {
-  cause;
-  constructor(message, options) {
-    super(message, options);
-    this.cause = options?.cause;
-    this.name = "GitbeakerRequestError";
-  }
+	cause;
+	constructor(message, options) {
+		super(message, options);
+		this.cause = options?.cause;
+		this.name = "GitbeakerRequestError";
+	}
 };
 var GitbeakerTimeoutError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "GitbeakerTimeoutError";
-  }
+	constructor(message, options) {
+		super(message, options);
+		this.name = "GitbeakerTimeoutError";
+	}
 };
 var GitbeakerRetryError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "GitbeakerRetryError";
-  }
+	constructor(message, options) {
+		super(message, options);
+		this.name = "GitbeakerRetryError";
+	}
 };
-
+//#endregion
 export { BaseResource, GitbeakerRequestError, GitbeakerRetryError, GitbeakerTimeoutError, createRateLimiters, createRequesterFn, defaultOptionsHandler, formatQuery, generateRateLimiterFn, getMatchingRateLimiter, presetResourceArguments };