@discordeno/rest 19.0.0-next.cd29c5f → 19.0.0-next.ce4eb2c

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (51) hide show
  1. package/README.md +15 -1
  2. package/dist/cjs/index.cjs +25 -0
  3. package/dist/cjs/invalidBucket.cjs +86 -0
  4. package/dist/cjs/manager.cjs +1480 -0
  5. package/dist/cjs/queue.cjs +164 -0
  6. package/dist/cjs/routes.cjs +556 -0
  7. package/dist/cjs/types.cjs +6 -0
  8. package/dist/cjs/typings/routes.cjs +6 -0
  9. package/dist/esm/index.js +8 -0
  10. package/dist/esm/invalidBucket.js +82 -0
  11. package/dist/esm/manager.js +1438 -0
  12. package/dist/esm/queue.js +154 -0
  13. package/dist/esm/routes.js +546 -0
  14. package/dist/esm/types.js +3 -0
  15. package/dist/esm/typings/routes.js +3 -0
  16. package/dist/types/index.d.ts.map +1 -0
  17. package/dist/{invalidBucket.d.ts → types/invalidBucket.d.ts} +5 -0
  18. package/dist/types/invalidBucket.d.ts.map +1 -0
  19. package/dist/types/manager.d.ts.map +1 -0
  20. package/dist/{queue.d.ts → types/queue.d.ts} +12 -1
  21. package/dist/types/queue.d.ts.map +1 -0
  22. package/dist/types/routes.d.ts.map +1 -0
  23. package/dist/{types.d.ts → types/types.d.ts} +497 -108
  24. package/dist/types/types.d.ts.map +1 -0
  25. package/dist/{typings → types/typings}/routes.d.ts +50 -5
  26. package/dist/types/typings/routes.d.ts.map +1 -0
  27. package/package.json +33 -29
  28. package/dist/index.d.ts.map +0 -1
  29. package/dist/index.js +0 -8
  30. package/dist/index.js.map +0 -1
  31. package/dist/invalidBucket.d.ts.map +0 -1
  32. package/dist/invalidBucket.js +0 -82
  33. package/dist/invalidBucket.js.map +0 -1
  34. package/dist/manager.d.ts.map +0 -1
  35. package/dist/manager.js +0 -1139
  36. package/dist/manager.js.map +0 -1
  37. package/dist/queue.d.ts.map +0 -1
  38. package/dist/queue.js +0 -153
  39. package/dist/queue.js.map +0 -1
  40. package/dist/routes.d.ts.map +0 -1
  41. package/dist/routes.js +0 -487
  42. package/dist/routes.js.map +0 -1
  43. package/dist/types.d.ts.map +0 -1
  44. package/dist/types.js +0 -3
  45. package/dist/types.js.map +0 -1
  46. package/dist/typings/routes.d.ts.map +0 -1
  47. package/dist/typings/routes.js +0 -3
  48. package/dist/typings/routes.js.map +0 -1
  49. /package/dist/{index.d.ts → types/index.d.ts} +0 -0
  50. /package/dist/{manager.d.ts → types/manager.d.ts} +0 -0
  51. /package/dist/{routes.d.ts → types/routes.d.ts} +0 -0
@@ -0,0 +1,1480 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", {
3
+ value: true
4
+ });
5
+ function _export(target, all) {
6
+ for(var name in all)Object.defineProperty(target, name, {
7
+ enumerable: true,
8
+ get: all[name]
9
+ });
10
+ }
11
+ _export(exports, {
12
+ AUDIT_LOG_REASON_HEADER: function() {
13
+ return AUDIT_LOG_REASON_HEADER;
14
+ },
15
+ DISCORD_API_URL: function() {
16
+ return DISCORD_API_URL;
17
+ },
18
+ DISCORD_API_VERSION: function() {
19
+ return DISCORD_API_VERSION;
20
+ },
21
+ RATE_LIMIT_BUCKET_HEADER: function() {
22
+ return RATE_LIMIT_BUCKET_HEADER;
23
+ },
24
+ RATE_LIMIT_GLOBAL_HEADER: function() {
25
+ return RATE_LIMIT_GLOBAL_HEADER;
26
+ },
27
+ RATE_LIMIT_LIMIT_HEADER: function() {
28
+ return RATE_LIMIT_LIMIT_HEADER;
29
+ },
30
+ RATE_LIMIT_REMAINING_HEADER: function() {
31
+ return RATE_LIMIT_REMAINING_HEADER;
32
+ },
33
+ RATE_LIMIT_RESET_AFTER_HEADER: function() {
34
+ return RATE_LIMIT_RESET_AFTER_HEADER;
35
+ },
36
+ RATE_LIMIT_SCOPE_HEADER: function() {
37
+ return RATE_LIMIT_SCOPE_HEADER;
38
+ },
39
+ createRestManager: function() {
40
+ return createRestManager;
41
+ }
42
+ });
43
+ const _nodebuffer = require("node:buffer");
44
+ const _types = require("@discordeno/types");
45
+ const _utils = require("@discordeno/utils");
46
+ const _invalidBucket = require("./invalidBucket.cjs");
47
+ const _queue = require("./queue.cjs");
48
+ const _routes = require("./routes.cjs");
49
+ // TODO: make dynamic based on package.json file
50
+ const version = '19.0.0-alpha.1';
51
+ const DISCORD_API_VERSION = 10;
52
+ const DISCORD_API_URL = 'https://discord.com/api';
53
+ const AUDIT_LOG_REASON_HEADER = 'x-audit-log-reason';
54
+ const RATE_LIMIT_REMAINING_HEADER = 'x-ratelimit-remaining';
55
+ const RATE_LIMIT_RESET_AFTER_HEADER = 'x-ratelimit-reset-after';
56
+ const RATE_LIMIT_GLOBAL_HEADER = 'x-ratelimit-global';
57
+ const RATE_LIMIT_BUCKET_HEADER = 'x-ratelimit-bucket';
58
+ const RATE_LIMIT_LIMIT_HEADER = 'x-ratelimit-limit';
59
+ const RATE_LIMIT_SCOPE_HEADER = 'x-ratelimit-scope';
60
+ function createRestManager(options) {
61
+ const applicationId = options.applicationId ? BigInt(options.applicationId) : (0, _utils.getBotIdFromToken)(options.token);
62
+ const baseUrl = options.proxy?.baseUrl ?? DISCORD_API_URL;
63
+ const rest = {
64
+ applicationId,
65
+ authorization: options.proxy?.authorization,
66
+ authorizationHeader: options.proxy?.authorizationHeader ?? 'authorization',
67
+ baseUrl,
68
+ deleteQueueDelay: 60000,
69
+ globallyRateLimited: false,
70
+ invalidBucket: (0, _invalidBucket.createInvalidRequestBucket)({
71
+ logger: options.logger
72
+ }),
73
+ isProxied: !baseUrl.startsWith(DISCORD_API_URL),
74
+ updateBearerTokenEndpoint: options.proxy?.updateBearerTokenEndpoint,
75
+ maxRetryCount: Infinity,
76
+ processingRateLimitedPaths: false,
77
+ queues: new Map(),
78
+ rateLimitedPaths: new Map(),
79
+ token: options.token,
80
+ version: options.version ?? DISCORD_API_VERSION,
81
+ logger: options.logger ?? _utils.logger,
82
+ routes: (0, _routes.createRoutes)(),
83
+ createBaseHeaders () {
84
+ return {
85
+ 'user-agent': `DiscordBot (https://github.com/discordeno/discordeno, v${version})`
86
+ };
87
+ },
88
+ checkRateLimits (url, identifier) {
89
+ const ratelimited = rest.rateLimitedPaths.get(`${identifier}${url}`);
90
+ const global = rest.rateLimitedPaths.get('global');
91
+ const now = Date.now();
92
+ if (ratelimited && now < ratelimited.resetTimestamp) {
93
+ return ratelimited.resetTimestamp - now;
94
+ }
95
+ if (global && now < global.resetTimestamp) {
96
+ return global.resetTimestamp - now;
97
+ }
98
+ return false;
99
+ },
100
+ async updateTokenQueues (oldToken, newToken) {
101
+ if (rest.isProxied) {
102
+ if (!rest.updateBearerTokenEndpoint) {
103
+ throw new Error("The 'proxy.updateBearerTokenEndpoint' option needs to be set when using a rest proxy and needed to call 'updateTokenQueues'");
104
+ }
105
+ const headers = {
106
+ 'content-type': 'application/json'
107
+ };
108
+ if (rest.authorization !== undefined) {
109
+ headers[rest.authorizationHeader] = rest.authorization;
110
+ }
111
+ await fetch(`${rest.baseUrl}/${rest.updateBearerTokenEndpoint}`, {
112
+ method: 'POST',
113
+ body: JSON.stringify({
114
+ oldToken,
115
+ newToken
116
+ }),
117
+ headers
118
+ });
119
+ return;
120
+ }
121
+ const newIdentifier = `Bearer ${newToken}`;
122
+ // Update all the queues
123
+ for (const [key, queue] of rest.queues.entries()){
124
+ if (!key.startsWith(`Bearer ${oldToken}`)) continue;
125
+ rest.queues.delete(key);
126
+ queue.identifier = newIdentifier;
127
+ const newKey = `${newIdentifier}${queue.url}`;
128
+ const newQueue = rest.queues.get(newKey);
129
+ // Merge the queues
130
+ if (newQueue) {
131
+ newQueue.waiting.unshift(...queue.waiting);
132
+ newQueue.pending.unshift(...queue.pending);
133
+ queue.waiting = [];
134
+ queue.pending = [];
135
+ queue.cleanup();
136
+ } else {
137
+ rest.queues.set(newKey, queue);
138
+ }
139
+ }
140
+ for (const [key, ratelimitPath] of rest.rateLimitedPaths.entries()){
141
+ if (!key.startsWith(`Bearer ${oldToken}`)) continue;
142
+ rest.rateLimitedPaths.set(`${newIdentifier}${ratelimitPath.url}`, ratelimitPath);
143
+ if (ratelimitPath.bucketId) {
144
+ rest.rateLimitedPaths.set(`${newIdentifier}${ratelimitPath.bucketId}`, ratelimitPath);
145
+ }
146
+ }
147
+ },
148
+ changeToDiscordFormat (obj) {
149
+ if (obj === null) return null;
150
+ if (typeof obj === 'object') {
151
+ if (Array.isArray(obj)) {
152
+ return obj.map((item)=>rest.changeToDiscordFormat(item));
153
+ }
154
+ const newObj = {};
155
+ for (const key of Object.keys(obj)){
156
+ // If the key is already in snake_case we have no reason for the rest of the code to run.
157
+ if (key.includes('_')) continue;
158
+ const value = obj[key];
159
+ // Some falsy values should be allowed like null or 0
160
+ if (value !== undefined) {
161
+ switch(key){
162
+ case 'permissions':
163
+ case 'allow':
164
+ case 'deny':
165
+ newObj[key] = typeof value === 'string' ? value : (0, _utils.calculateBits)(value);
166
+ continue;
167
+ case 'defaultMemberPermissions':
168
+ newObj.default_member_permissions = typeof value === 'string' ? value : (0, _utils.calculateBits)(value);
169
+ continue;
170
+ case 'nameLocalizations':
171
+ newObj.name_localizations = value;
172
+ continue;
173
+ case 'descriptionLocalizations':
174
+ newObj.description_localizations = value;
175
+ continue;
176
+ }
177
+ }
178
+ newObj[(0, _utils.camelToSnakeCase)(key)] = rest.changeToDiscordFormat(value);
179
+ }
180
+ return newObj;
181
+ }
182
+ if (typeof obj === 'bigint') return obj.toString();
183
+ return obj;
184
+ },
185
+ createRequestBody (method, options) {
186
+ const headers = this.createBaseHeaders();
187
+ if (options?.unauthorized !== true) headers.authorization = `Bot ${rest.token}`;
188
+ // IF A REASON IS PROVIDED ENCODE IT IN HEADERS
189
+ if (options?.reason !== undefined) {
190
+ headers[AUDIT_LOG_REASON_HEADER] = encodeURIComponent(options?.reason);
191
+ }
192
+ let body;
193
+ // TODO: check if we need to add specific check for GET method
194
+ // Since GET does not allow bodies
195
+ // Have to check for attachments first, since body then has to be send in a different way.
196
+ if (options?.files !== undefined) {
197
+ const form = new FormData();
198
+ for(let i = 0; i < options.files.length; ++i){
199
+ form.append(`file${i}`, options.files[i].blob, options.files[i].name);
200
+ }
201
+ // Have to use changeToDiscordFormat or else JSON.stringify may throw an error for the presence of BigInt(s) in the json
202
+ form.append('payload_json', JSON.stringify(rest.changeToDiscordFormat({
203
+ ...options.body,
204
+ files: undefined
205
+ })));
206
+ // No need to set the `content-type` header since `fetch` does that automatically for us when we use a `FormData` object.
207
+ body = form;
208
+ } else if (options?.body && options.headers && options.headers['content-type'] === 'application/x-www-form-urlencoded') {
209
+ // OAuth2 body handling
210
+ const formBody = [];
211
+ const discordBody = rest.changeToDiscordFormat(options.body);
212
+ for(const prop in discordBody){
213
+ formBody.push(`${encodeURIComponent(prop)}=${encodeURIComponent(discordBody[prop])}`);
214
+ }
215
+ body = formBody.join('&');
216
+ } else if (options?.body !== undefined) {
217
+ if (options.body instanceof FormData) {
218
+ body = options.body;
219
+ // No need to set the `content-type` header since `fetch` does that automatically for us when we use a `FormData` object.
220
+ } else {
221
+ body = JSON.stringify(rest.changeToDiscordFormat(options.body));
222
+ headers['content-type'] = `application/json`;
223
+ }
224
+ }
225
+ // SOMETIMES SPECIAL HEADERS (E.G. CUSTOM AUTHORIZATION) NEED TO BE USED
226
+ if (options?.headers) {
227
+ Object.assign(headers, options.headers);
228
+ }
229
+ return {
230
+ body,
231
+ headers,
232
+ method
233
+ };
234
+ },
235
+ processRateLimitedPaths () {
236
+ const now = Date.now();
237
+ for (const [key, value] of rest.rateLimitedPaths.entries()){
238
+ // rest.debug(
239
+ // `[REST - processRateLimitedPaths] Running for of loop. ${
240
+ // value.resetTimestamp - now
241
+ // }`
242
+ // )
243
+ // If the time has not reached cancel
244
+ if (value.resetTimestamp > now) continue;
245
+ // Rate limit is over, delete the rate limiter
246
+ rest.rateLimitedPaths.delete(key);
247
+ // If it was global, also mark the global value as false
248
+ if (key === 'global') rest.globallyRateLimited = false;
249
+ }
250
+ // ALL PATHS ARE CLEARED CAN CANCEL OUT!
251
+ if (rest.rateLimitedPaths.size === 0) {
252
+ rest.processingRateLimitedPaths = false;
253
+ } else {
254
+ rest.processingRateLimitedPaths = true;
255
+ // RECHECK IN 1 SECOND
256
+ setTimeout(()=>{
257
+ // rest.debug('[REST - processRateLimitedPaths] Running setTimeout.')
258
+ rest.processRateLimitedPaths();
259
+ }, 1000);
260
+ }
261
+ },
262
+ /** Processes the rate limit headers and determines if it needs to be rate limited and returns the bucket id if available */ processHeaders (url, headers, identifier) {
263
+ let rateLimited = false;
264
+ // GET ALL NECESSARY HEADERS
265
+ const remaining = headers.get(RATE_LIMIT_REMAINING_HEADER);
266
+ const retryAfter = headers.get(RATE_LIMIT_RESET_AFTER_HEADER);
267
+ const reset = Date.now() + Number(retryAfter) * 1000;
268
+ const global = headers.get(RATE_LIMIT_GLOBAL_HEADER);
269
+ // undefined override null needed for typings
270
+ const bucketId = headers.get(RATE_LIMIT_BUCKET_HEADER) ?? undefined;
271
+ const limit = headers.get(RATE_LIMIT_LIMIT_HEADER);
272
+ // If we didn't received the identifier, fallback to the bot token
273
+ identifier ??= `Bot ${rest.token}`;
274
+ rest.queues.get(`${identifier}${url}`)?.handleCompletedRequest({
275
+ remaining: remaining ? Number(remaining) : undefined,
276
+ interval: retryAfter ? Number(retryAfter) * 1000 : undefined,
277
+ max: limit ? Number(limit) : undefined
278
+ });
279
+ // IF THERE IS NO REMAINING RATE LIMIT, MARK IT AS RATE LIMITED
280
+ if (remaining === '0') {
281
+ rateLimited = true;
282
+ // SAVE THE URL AS LIMITED, IMPORTANT FOR NEW REQUESTS BY USER WITHOUT BUCKET
283
+ rest.rateLimitedPaths.set(`${identifier}${url}`, {
284
+ url,
285
+ resetTimestamp: reset,
286
+ bucketId
287
+ });
288
+ // SAVE THE BUCKET AS LIMITED SINCE DIFFERENT URLS MAY SHARE A BUCKET
289
+ if (bucketId) {
290
+ rest.rateLimitedPaths.set(`${identifier}${bucketId}`, {
291
+ url,
292
+ resetTimestamp: reset,
293
+ bucketId
294
+ });
295
+ }
296
+ }
297
+ // IF THERE IS NO REMAINING GLOBAL LIMIT, MARK IT RATE LIMITED GLOBALLY
298
+ if (global) {
299
+ const retryAfter = Number(headers.get('retry-after')) * 1000;
300
+ const globalReset = Date.now() + retryAfter;
301
+ // rest.debug(
302
+ // `[REST = Globally Rate Limited] URL: ${url} | Global Rest: ${globalReset}`
303
+ // )
304
+ rest.globallyRateLimited = true;
305
+ rateLimited = true;
306
+ setTimeout(()=>{
307
+ rest.globallyRateLimited = false;
308
+ }, retryAfter);
309
+ rest.rateLimitedPaths.set('global', {
310
+ url: 'global',
311
+ resetTimestamp: globalReset,
312
+ bucketId
313
+ });
314
+ if (bucketId) {
315
+ rest.rateLimitedPaths.set(identifier, {
316
+ url: 'global',
317
+ resetTimestamp: globalReset,
318
+ bucketId
319
+ });
320
+ }
321
+ }
322
+ if (rateLimited && !rest.processingRateLimitedPaths) {
323
+ rest.processRateLimitedPaths();
324
+ }
325
+ return rateLimited ? bucketId : undefined;
326
+ },
327
+ async sendRequest (options) {
328
+ const url = `${rest.baseUrl}/v${rest.version}${options.route}`;
329
+ const payload = rest.createRequestBody(options.method, options.requestBodyOptions);
330
+ const loggingHeaders = {
331
+ ...payload.headers
332
+ };
333
+ if (payload.headers.authorization) {
334
+ const authorizationScheme = payload.headers.authorization?.split(' ')[0];
335
+ loggingHeaders.authorization = `${authorizationScheme} tokenhere`;
336
+ }
337
+ rest.logger.debug(`sending request to ${url}`, 'with payload:', {
338
+ ...payload,
339
+ headers: loggingHeaders
340
+ });
341
+ const response = await fetch(url, payload).catch(async (error)=>{
342
+ rest.logger.error(error);
343
+ // Mark request and completed
344
+ rest.invalidBucket.handleCompletedRequest(999, false);
345
+ options.reject({
346
+ ok: false,
347
+ status: 999,
348
+ error: 'Possible network or request shape issue occurred. If this is rare, its a network glitch. If it occurs a lot something is wrong.'
349
+ });
350
+ throw error;
351
+ });
352
+ rest.logger.debug(`request fetched from ${url} with status ${response.status} & ${response.statusText}`);
353
+ // Mark request and completed
354
+ rest.invalidBucket.handleCompletedRequest(response.status, response.headers.get(RATE_LIMIT_SCOPE_HEADER) === 'shared');
355
+ // Set the bucket id if it was available on the headers
356
+ const bucketId = rest.processHeaders(rest.simplifyUrl(options.route, options.method), response.headers, payload.headers.authorization);
357
+ if (bucketId) options.bucketId = bucketId;
358
+ if (response.status < 200 || response.status >= 400) {
359
+ rest.logger.debug(`Request to ${url} failed.`);
360
+ if (response.status !== 429) {
361
+ options.reject({
362
+ ok: false,
363
+ status: response.status,
364
+ body: await response.text()
365
+ });
366
+ return;
367
+ }
368
+ rest.logger.debug(`Request to ${url} was ratelimited.`);
369
+ // Too many attempts, get rid of request from queue.
370
+ if (options.retryCount >= rest.maxRetryCount) {
371
+ rest.logger.debug(`Request to ${url} exceeded the maximum allowed retries.`, 'with payload:', payload);
372
+ // rest.debug(`[REST - RetriesMaxed] ${JSON.stringify(options)}`)
373
+ options.reject({
374
+ ok: false,
375
+ status: response.status,
376
+ error: 'The request was rate limited and it maxed out the retries limit.'
377
+ });
378
+ return;
379
+ }
380
+ options.retryCount += 1;
381
+ const resetAfter = response.headers.get(RATE_LIMIT_RESET_AFTER_HEADER);
382
+ if (resetAfter) await (0, _utils.delay)(Number(resetAfter) * 1000);
383
+ // process the response to prevent mem leak
384
+ await response.arrayBuffer();
385
+ return await options.retryRequest?.(options);
386
+ }
387
+ // Discord sometimes sends no response with no content.
388
+ options.resolve({
389
+ ok: true,
390
+ status: response.status,
391
+ body: response.status === 204 ? undefined : await response.text()
392
+ });
393
+ },
394
+ simplifyUrl (url, method) {
395
+ const parts = url.split('/');
396
+ const secondLastPart = parts[parts.length - 2];
397
+ if (secondLastPart === 'channels' || secondLastPart === 'guilds') {
398
+ return url;
399
+ }
400
+ if (secondLastPart === 'reactions' || parts[parts.length - 1] === '@me') {
401
+ parts.splice(-2);
402
+ parts.push('reactions');
403
+ } else {
404
+ parts.splice(-1);
405
+ parts.push('x');
406
+ }
407
+ if (parts[parts.length - 3] === 'reactions') {
408
+ parts.splice(-2);
409
+ }
410
+ if (method === 'DELETE' && secondLastPart === 'messages') {
411
+ return `D${parts.join('/')}`;
412
+ }
413
+ return parts.join('/');
414
+ },
415
+ async processRequest (request) {
416
+ const url = rest.simplifyUrl(request.route, request.method);
417
+ if (request.runThroughQueue === false) {
418
+ await rest.sendRequest(request);
419
+ return;
420
+ }
421
+ // If we the request has a token, use it
422
+ // Else fallback to prefix with the bot token
423
+ const queueIdentifier = request.requestBodyOptions?.headers?.authorization ?? `Bot ${rest.token}`;
424
+ const queue = rest.queues.get(`${queueIdentifier}${url}`);
425
+ if (queue !== undefined) {
426
+ queue.makeRequest(request);
427
+ } else {
428
+ // CREATES A NEW QUEUE
429
+ const bucketQueue = new _queue.Queue(rest, {
430
+ url,
431
+ deleteQueueDelay: rest.deleteQueueDelay,
432
+ identifier: queueIdentifier
433
+ });
434
+ // Save queue
435
+ rest.queues.set(`${queueIdentifier}${url}`, bucketQueue);
436
+ // Add request to queue
437
+ bucketQueue.makeRequest(request);
438
+ }
439
+ },
440
+ async makeRequest (method, route, options) {
441
+ if (rest.isProxied) {
442
+ if (rest.authorization !== undefined) {
443
+ options ??= {};
444
+ options.headers ??= {};
445
+ options.headers[rest.authorizationHeader] = rest.authorization;
446
+ }
447
+ const result = await fetch(`${rest.baseUrl}/v${rest.version}${route}`, rest.createRequestBody(method, options));
448
+ if (!result.ok) {
449
+ const err = await result.json().catch(()=>{});
450
+ // Legacy Handling to not break old code or when body is missing
451
+ if (!err?.body) throw new Error(`Error: ${err.message ?? result.statusText}`);
452
+ throw new Error(JSON.stringify(err));
453
+ }
454
+ return result.status !== 204 ? await result.json() : undefined;
455
+ }
456
+ // This error needs to be created here because of how stack traces get calculated
457
+ const error = new Error();
458
+ error.message = 'Failed to send request to discord.';
459
+ return await new Promise(async (resolve, reject)=>{
460
+ const payload = {
461
+ route,
462
+ method,
463
+ requestBodyOptions: options,
464
+ retryCount: 0,
465
+ retryRequest: async (payload)=>{
466
+ await rest.processRequest(payload);
467
+ },
468
+ resolve: (data)=>{
469
+ resolve(data.status !== 204 ? JSON.parse(data.body ?? '{}') : undefined);
470
+ },
471
+ reject: (reason)=>{
472
+ error.cause = reason;
473
+ reject(error);
474
+ },
475
+ runThroughQueue: options?.runThroughQueue
476
+ };
477
+ await rest.processRequest(payload);
478
+ });
479
+ },
480
+ async get (url, options) {
481
+ return (0, _utils.camelize)(await rest.makeRequest('GET', url, options));
482
+ },
483
+ async post (url, options) {
484
+ return (0, _utils.camelize)(await rest.makeRequest('POST', url, options));
485
+ },
486
+ async delete (url, options) {
487
+ (0, _utils.camelize)(await rest.makeRequest('DELETE', url, options));
488
+ },
489
+ async patch (url, options) {
490
+ return (0, _utils.camelize)(await rest.makeRequest('PATCH', url, options));
491
+ },
492
+ async put (url, options) {
493
+ return (0, _utils.camelize)(await rest.makeRequest('PUT', url, options));
494
+ },
495
+ async addReaction (channelId, messageId, reaction) {
496
+ reaction = (0, _utils.processReactionString)(reaction);
497
+ await rest.put(rest.routes.channels.reactions.bot(channelId, messageId, reaction));
498
+ },
499
+ async addReactions (channelId, messageId, reactions, ordered = false) {
500
+ if (!ordered) {
501
+ await Promise.all(reactions.map(async (reaction)=>{
502
+ await rest.addReaction(channelId, messageId, reaction);
503
+ }));
504
+ return;
505
+ }
506
+ for (const reaction of reactions){
507
+ await rest.addReaction(channelId, messageId, reaction);
508
+ }
509
+ },
510
+ async addRole (guildId, userId, roleId, reason) {
511
+ await rest.put(rest.routes.guilds.roles.member(guildId, userId, roleId), {
512
+ reason
513
+ });
514
+ },
515
+ async addThreadMember (channelId, userId) {
516
+ await rest.put(rest.routes.channels.threads.user(channelId, userId));
517
+ },
518
+ async addDmRecipient (channelId, userId, body) {
519
+ await rest.put(rest.routes.channels.dmRecipient(channelId, userId), {
520
+ body
521
+ });
522
+ },
523
+ async createAutomodRule (guildId, body, reason) {
524
+ return await rest.post(rest.routes.guilds.automod.rules(guildId), {
525
+ body,
526
+ reason
527
+ });
528
+ },
529
+ async createChannel (guildId, body, reason) {
530
+ return await rest.post(rest.routes.guilds.channels(guildId), {
531
+ body,
532
+ reason
533
+ });
534
+ },
535
+ async createEmoji (guildId, body, reason) {
536
+ return await rest.post(rest.routes.guilds.emojis(guildId), {
537
+ body,
538
+ reason
539
+ });
540
+ },
541
+ async createApplicationEmoji (body) {
542
+ return await rest.post(rest.routes.applicationEmojis(rest.applicationId), {
543
+ body
544
+ });
545
+ },
546
+ async createGlobalApplicationCommand (body, options) {
547
+ const restOptions = {
548
+ body
549
+ };
550
+ if (options?.bearerToken) {
551
+ restOptions.unauthorized = true;
552
+ restOptions.headers = {
553
+ authorization: `Bearer ${options.bearerToken}`
554
+ };
555
+ }
556
+ return await rest.post(rest.routes.interactions.commands.commands(rest.applicationId), restOptions);
557
+ },
558
+ async createGuild (body) {
559
+ return await rest.post(rest.routes.guilds.all(), {
560
+ body
561
+ });
562
+ },
563
+ async createGuildApplicationCommand (body, guildId, options) {
564
+ const restOptions = {
565
+ body
566
+ };
567
+ if (options?.bearerToken) {
568
+ restOptions.unauthorized = true;
569
+ restOptions.headers = {
570
+ authorization: `Bearer ${options.bearerToken}`
571
+ };
572
+ }
573
+ return await rest.post(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), restOptions);
574
+ },
575
+ async createGuildFromTemplate (templateCode, body) {
576
+ if (body.icon) {
577
+ body.icon = await (0, _utils.urlToBase64)(body.icon);
578
+ }
579
+ return await rest.post(rest.routes.guilds.templates.code(templateCode), {
580
+ body
581
+ });
582
+ },
583
+ async createGuildSticker (guildId, options, reason) {
584
+ const form = new FormData();
585
+ form.append('file', options.file.blob, options.file.name);
586
+ form.append('name', options.name);
587
+ form.append('description', options.description);
588
+ form.append('tags', options.tags);
589
+ return await rest.post(rest.routes.guilds.stickers(guildId), {
590
+ body: form,
591
+ reason
592
+ });
593
+ },
594
+ async createGuildTemplate (guildId, body) {
595
+ return await rest.post(rest.routes.guilds.templates.all(guildId), {
596
+ body
597
+ });
598
+ },
599
+ async createForumThread (channelId, body, reason) {
600
+ return await rest.post(rest.routes.channels.forum(channelId), {
601
+ body,
602
+ files: body.files,
603
+ reason
604
+ });
605
+ },
606
+ async createInvite (channelId, body = {}, reason) {
607
+ return await rest.post(rest.routes.channels.invites(channelId), {
608
+ body,
609
+ reason
610
+ });
611
+ },
612
+ async createRole (guildId, body, reason) {
613
+ return await rest.post(rest.routes.guilds.roles.all(guildId), {
614
+ body,
615
+ reason
616
+ });
617
+ },
618
+ async createScheduledEvent (guildId, body, reason) {
619
+ return await rest.post(rest.routes.guilds.events.events(guildId), {
620
+ body,
621
+ reason
622
+ });
623
+ },
624
+ async createStageInstance (body, reason) {
625
+ return await rest.post(rest.routes.channels.stages(), {
626
+ body,
627
+ reason
628
+ });
629
+ },
630
+ async createWebhook (channelId, options, reason) {
631
+ return await rest.post(rest.routes.channels.webhooks(channelId), {
632
+ body: {
633
+ name: options.name,
634
+ avatar: options.avatar ? await (0, _utils.urlToBase64)(options.avatar) : undefined
635
+ },
636
+ reason
637
+ });
638
+ },
639
+ async deleteAutomodRule (guildId, ruleId, reason) {
640
+ await rest.delete(rest.routes.guilds.automod.rule(guildId, ruleId), {
641
+ reason
642
+ });
643
+ },
644
+ async deleteChannel (channelId, reason) {
645
+ await rest.delete(rest.routes.channels.channel(channelId), {
646
+ reason
647
+ });
648
+ },
649
+ async deleteChannelPermissionOverride (channelId, overwriteId, reason) {
650
+ await rest.delete(rest.routes.channels.overwrite(channelId, overwriteId), {
651
+ reason
652
+ });
653
+ },
654
+ async deleteEmoji (guildId, id, reason) {
655
+ await rest.delete(rest.routes.guilds.emoji(guildId, id), {
656
+ reason
657
+ });
658
+ },
659
+ async deleteApplicationEmoji (id) {
660
+ await rest.delete(rest.routes.applicationEmoji(rest.applicationId, id));
661
+ },
662
+ async deleteFollowupMessage (token, messageId) {
663
+ await rest.delete(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), {
664
+ unauthorized: true
665
+ });
666
+ },
667
+ async deleteGlobalApplicationCommand (commandId) {
668
+ await rest.delete(rest.routes.interactions.commands.command(rest.applicationId, commandId));
669
+ },
670
+ async deleteGuild (guildId) {
671
+ await rest.delete(rest.routes.guilds.guild(guildId));
672
+ },
673
+ async deleteGuildApplicationCommand (commandId, guildId) {
674
+ await rest.delete(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId));
675
+ },
676
+ async deleteGuildSticker (guildId, stickerId, reason) {
677
+ await rest.delete(rest.routes.guilds.sticker(guildId, stickerId), {
678
+ reason
679
+ });
680
+ },
681
+ async deleteGuildTemplate (guildId, templateCode) {
682
+ await rest.delete(rest.routes.guilds.templates.guild(guildId, templateCode));
683
+ },
684
+ async deleteIntegration (guildId, integrationId, reason) {
685
+ await rest.delete(rest.routes.guilds.integration(guildId, integrationId), {
686
+ reason
687
+ });
688
+ },
689
+ async deleteInvite (inviteCode, reason) {
690
+ await rest.delete(rest.routes.guilds.invite(inviteCode), {
691
+ reason
692
+ });
693
+ },
694
+ async deleteMessage (channelId, messageId, reason) {
695
+ await rest.delete(rest.routes.channels.message(channelId, messageId), {
696
+ reason
697
+ });
698
+ },
699
+ async deleteMessages (channelId, messageIds, reason) {
700
+ await rest.post(rest.routes.channels.bulk(channelId), {
701
+ body: {
702
+ messages: messageIds.slice(0, 100).map((id)=>id.toString())
703
+ },
704
+ reason
705
+ });
706
+ },
707
+ async deleteOriginalInteractionResponse (token) {
708
+ await rest.delete(rest.routes.interactions.responses.original(rest.applicationId, token), {
709
+ unauthorized: true
710
+ });
711
+ },
712
+ async deleteOwnReaction (channelId, messageId, reaction) {
713
+ reaction = (0, _utils.processReactionString)(reaction);
714
+ await rest.delete(rest.routes.channels.reactions.bot(channelId, messageId, reaction));
715
+ },
716
+ async deleteReactionsAll (channelId, messageId) {
717
+ await rest.delete(rest.routes.channels.reactions.all(channelId, messageId));
718
+ },
719
+ async deleteReactionsEmoji (channelId, messageId, reaction) {
720
+ reaction = (0, _utils.processReactionString)(reaction);
721
+ await rest.delete(rest.routes.channels.reactions.emoji(channelId, messageId, reaction));
722
+ },
723
+ async deleteRole (guildId, roleId, reason) {
724
+ await rest.delete(rest.routes.guilds.roles.one(guildId, roleId), {
725
+ reason
726
+ });
727
+ },
728
+ async deleteScheduledEvent (guildId, eventId) {
729
+ await rest.delete(rest.routes.guilds.events.event(guildId, eventId));
730
+ },
731
+ async deleteStageInstance (channelId, reason) {
732
+ await rest.delete(rest.routes.channels.stage(channelId), {
733
+ reason
734
+ });
735
+ },
736
+ async deleteUserReaction (channelId, messageId, userId, reaction) {
737
+ reaction = (0, _utils.processReactionString)(reaction);
738
+ await rest.delete(rest.routes.channels.reactions.user(channelId, messageId, reaction, userId));
739
+ },
740
+ async deleteWebhook (webhookId, reason) {
741
+ await rest.delete(rest.routes.webhooks.id(webhookId), {
742
+ reason
743
+ });
744
+ },
745
+ async deleteWebhookMessage (webhookId, token, messageId, options) {
746
+ await rest.delete(rest.routes.webhooks.message(webhookId, token, messageId, options));
747
+ },
748
+ async deleteWebhookWithToken (webhookId, token) {
749
+ await rest.delete(rest.routes.webhooks.webhook(webhookId, token), {
750
+ unauthorized: true
751
+ });
752
+ },
753
+ async editApplicationCommandPermissions (guildId, commandId, bearerToken, permissions) {
754
+ return await rest.put(rest.routes.interactions.commands.permission(rest.applicationId, guildId, commandId), {
755
+ body: {
756
+ permissions
757
+ },
758
+ headers: {
759
+ authorization: `Bearer ${bearerToken}`
760
+ }
761
+ });
762
+ },
763
+ async editAutomodRule (guildId, ruleId, body, reason) {
764
+ return await rest.patch(rest.routes.guilds.automod.rule(guildId, ruleId), {
765
+ body,
766
+ reason
767
+ });
768
+ },
769
+ async editBotProfile (options) {
770
+ const avatar = options?.botAvatarURL ? await (0, _utils.urlToBase64)(options?.botAvatarURL) : options?.botAvatarURL;
771
+ const banner = options?.botBannerURL ? await (0, _utils.urlToBase64)(options?.botBannerURL) : options?.botBannerURL;
772
+ return await rest.patch(rest.routes.currentUser(), {
773
+ body: {
774
+ username: options.username?.trim(),
775
+ avatar,
776
+ banner
777
+ }
778
+ });
779
+ },
780
+ async editChannel (channelId, body, reason) {
781
+ return await rest.patch(rest.routes.channels.channel(channelId), {
782
+ body,
783
+ reason
784
+ });
785
+ },
786
+ async editChannelPermissionOverrides (channelId, body, reason) {
787
+ await rest.put(rest.routes.channels.overwrite(channelId, body.id), {
788
+ body,
789
+ reason
790
+ });
791
+ },
792
+ async editChannelPositions (guildId, body) {
793
+ await rest.patch(rest.routes.guilds.channels(guildId), {
794
+ body
795
+ });
796
+ },
797
+ async editEmoji (guildId, id, body, reason) {
798
+ return await rest.patch(rest.routes.guilds.emoji(guildId, id), {
799
+ body,
800
+ reason
801
+ });
802
+ },
803
+ async editApplicationEmoji (id, body) {
804
+ return await rest.patch(rest.routes.applicationEmoji(rest.applicationId, id), {
805
+ body
806
+ });
807
+ },
808
+ async editFollowupMessage (token, messageId, body) {
809
+ return await rest.patch(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), {
810
+ body,
811
+ files: body.files,
812
+ unauthorized: true
813
+ });
814
+ },
815
+ async editGlobalApplicationCommand (commandId, body) {
816
+ return await rest.patch(rest.routes.interactions.commands.command(rest.applicationId, commandId), {
817
+ body
818
+ });
819
+ },
820
+ async editGuild (guildId, body, reason) {
821
+ return await rest.patch(rest.routes.guilds.guild(guildId), {
822
+ body,
823
+ reason
824
+ });
825
+ },
826
+ async editGuildApplicationCommand (commandId, guildId, body) {
827
+ return await rest.patch(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId), {
828
+ body
829
+ });
830
+ },
831
+ async editGuildMfaLevel (guildId, mfaLevel, reason) {
832
+ await rest.post(rest.routes.guilds.mfa(guildId), {
833
+ body: {
834
+ level: mfaLevel
835
+ },
836
+ reason
837
+ });
838
+ },
839
+ async editGuildSticker (guildId, stickerId, body, reason) {
840
+ return await rest.patch(rest.routes.guilds.sticker(guildId, stickerId), {
841
+ body,
842
+ reason
843
+ });
844
+ },
845
+ async editGuildTemplate (guildId, templateCode, body) {
846
+ return await rest.patch(rest.routes.guilds.templates.guild(guildId, templateCode), {
847
+ body
848
+ });
849
+ },
850
+ async editMessage (channelId, messageId, body) {
851
+ return await rest.patch(rest.routes.channels.message(channelId, messageId), {
852
+ body,
853
+ files: body.files
854
+ });
855
+ },
856
+ async editOriginalInteractionResponse (token, body) {
857
+ return await rest.patch(rest.routes.interactions.responses.original(rest.applicationId, token), {
858
+ body,
859
+ files: body.files
860
+ });
861
+ },
862
+ async editOriginalWebhookMessage (webhookId, token, options) {
863
+ return await rest.patch(rest.routes.webhooks.original(webhookId, token, options), {
864
+ body: {
865
+ type: _types.InteractionResponseTypes.UpdateMessage,
866
+ data: options
867
+ },
868
+ files: options.files,
869
+ unauthorized: true
870
+ });
871
+ },
872
+ async editOwnVoiceState (guildId, options) {
873
+ await rest.patch(rest.routes.guilds.voice(guildId), {
874
+ body: {
875
+ ...options,
876
+ request_to_speak_timestamp: options.requestToSpeakTimestamp ? new Date(options.requestToSpeakTimestamp).toISOString() : options.requestToSpeakTimestamp
877
+ }
878
+ });
879
+ },
880
+ async editScheduledEvent (guildId, eventId, body, reason) {
881
+ return await rest.patch(rest.routes.guilds.events.event(guildId, eventId), {
882
+ body,
883
+ reason
884
+ });
885
+ },
886
+ async editRole (guildId, roleId, body, reason) {
887
+ return await rest.patch(rest.routes.guilds.roles.one(guildId, roleId), {
888
+ body,
889
+ reason
890
+ });
891
+ },
892
+ async editRolePositions (guildId, body, reason) {
893
+ return await rest.patch(rest.routes.guilds.roles.all(guildId), {
894
+ body,
895
+ reason
896
+ });
897
+ },
898
+ async editStageInstance (channelId, topic, reason) {
899
+ return await rest.patch(rest.routes.channels.stage(channelId), {
900
+ body: {
901
+ topic
902
+ },
903
+ reason
904
+ });
905
+ },
906
+ async editUserVoiceState (guildId, options) {
907
+ await rest.patch(rest.routes.guilds.voice(guildId, options.userId), {
908
+ body: options
909
+ });
910
+ },
911
+ async editWebhook (webhookId, body, reason) {
912
+ return await rest.patch(rest.routes.webhooks.id(webhookId), {
913
+ body,
914
+ reason
915
+ });
916
+ },
917
+ async editWebhookMessage (webhookId, token, messageId, options) {
918
+ return await rest.patch(rest.routes.webhooks.message(webhookId, token, messageId, options), {
919
+ body: options,
920
+ files: options.files,
921
+ unauthorized: true
922
+ });
923
+ },
924
+ async editWebhookWithToken (webhookId, token, body) {
925
+ return await rest.patch(rest.routes.webhooks.webhook(webhookId, token), {
926
+ body,
927
+ unauthorized: true
928
+ });
929
+ },
930
+ async editWelcomeScreen (guildId, body, reason) {
931
+ return await rest.patch(rest.routes.guilds.welcome(guildId), {
932
+ body,
933
+ reason
934
+ });
935
+ },
936
+ async editWidgetSettings (guildId, body, reason) {
937
+ return await rest.patch(rest.routes.guilds.widget(guildId), {
938
+ body,
939
+ reason
940
+ });
941
+ },
942
+ async executeWebhook (webhookId, token, options) {
943
+ return await rest.post(rest.routes.webhooks.webhook(webhookId, token, options), {
944
+ body: options,
945
+ unauthorized: true
946
+ });
947
+ },
948
+ async followAnnouncement (sourceChannelId, targetChannelId, reason) {
949
+ return await rest.post(rest.routes.channels.follow(sourceChannelId), {
950
+ body: {
951
+ webhook_channel_id: targetChannelId
952
+ },
953
+ reason
954
+ });
955
+ },
956
+ async getActiveThreads (guildId) {
957
+ return await rest.get(rest.routes.channels.threads.active(guildId));
958
+ },
959
+ async getApplicationCommandPermission (guildId, commandId, options) {
960
+ const restOptions = {};
961
+ if (options?.accessToken) {
962
+ restOptions.unauthorized = true;
963
+ restOptions.headers = {
964
+ authorization: `Bearer ${options.accessToken}`
965
+ };
966
+ }
967
+ return await rest.get(rest.routes.interactions.commands.permission(options?.applicationId ?? rest.applicationId, guildId, commandId), restOptions);
968
+ },
969
+ async getApplicationCommandPermissions (guildId, options) {
970
+ const restOptions = {};
971
+ if (options?.accessToken) {
972
+ restOptions.unauthorized = true;
973
+ restOptions.headers = {
974
+ authorization: `Bearer ${options.accessToken}`
975
+ };
976
+ }
977
+ return await rest.get(rest.routes.interactions.commands.permissions(options?.applicationId ?? rest.applicationId, guildId), restOptions);
978
+ },
979
+ async getApplicationInfo () {
980
+ return await rest.get(rest.routes.oauth2.application());
981
+ },
982
+ async editApplicationInfo (body) {
983
+ return await rest.patch(rest.routes.application(), {
984
+ body
985
+ });
986
+ },
987
+ async getCurrentAuthenticationInfo (token) {
988
+ return await rest.get(rest.routes.oauth2.currentAuthorization(), {
989
+ headers: {
990
+ authorization: `Bearer ${token}`
991
+ },
992
+ unauthorized: true
993
+ });
994
+ },
995
+ async exchangeToken (clientId, clientSecret, body) {
996
+ const basicCredentials = _nodebuffer.Buffer.from(`${clientId}:${clientSecret}`);
997
+ const restOptions = {
998
+ body,
999
+ headers: {
1000
+ 'content-type': 'application/x-www-form-urlencoded',
1001
+ authorization: `Basic ${basicCredentials.toString('base64')}`
1002
+ },
1003
+ runThroughQueue: false,
1004
+ unauthorized: true
1005
+ };
1006
+ if (body.grantType === 'client_credentials') {
1007
+ restOptions.body.scope = body.scope.join(' ');
1008
+ }
1009
+ return await rest.post(rest.routes.oauth2.tokenExchange(), restOptions);
1010
+ },
1011
+ async revokeToken (clientId, clientSecret, body) {
1012
+ const basicCredentials = _nodebuffer.Buffer.from(`${clientId}:${clientSecret}`);
1013
+ await rest.post(rest.routes.oauth2.tokenRevoke(), {
1014
+ body,
1015
+ headers: {
1016
+ 'content-type': 'application/x-www-form-urlencoded',
1017
+ authorization: `Basic ${basicCredentials.toString('base64')}`
1018
+ },
1019
+ unauthorized: true
1020
+ });
1021
+ },
1022
+ async getAuditLog (guildId, options) {
1023
+ return await rest.get(rest.routes.guilds.auditlogs(guildId, options));
1024
+ },
1025
+ async getAutomodRule (guildId, ruleId) {
1026
+ return await rest.get(rest.routes.guilds.automod.rule(guildId, ruleId));
1027
+ },
1028
+ async getAutomodRules (guildId) {
1029
+ return await rest.get(rest.routes.guilds.automod.rules(guildId));
1030
+ },
1031
+ async getAvailableVoiceRegions () {
1032
+ return await rest.get(rest.routes.regions());
1033
+ },
1034
+ async getBan (guildId, userId) {
1035
+ return await rest.get(rest.routes.guilds.members.ban(guildId, userId));
1036
+ },
1037
+ async getBans (guildId, options) {
1038
+ return await rest.get(rest.routes.guilds.members.bans(guildId, options));
1039
+ },
1040
+ async getChannel (id) {
1041
+ return await rest.get(rest.routes.channels.channel(id));
1042
+ },
1043
+ async getChannelInvites (channelId) {
1044
+ return await rest.get(rest.routes.channels.invites(channelId));
1045
+ },
1046
+ async getChannels (guildId) {
1047
+ return await rest.get(rest.routes.guilds.channels(guildId));
1048
+ },
1049
+ async getChannelWebhooks (channelId) {
1050
+ return await rest.get(rest.routes.channels.webhooks(channelId));
1051
+ },
1052
+ async getDmChannel (userId) {
1053
+ return await rest.post(rest.routes.channels.dm(), {
1054
+ body: {
1055
+ recipient_id: userId
1056
+ }
1057
+ });
1058
+ },
1059
+ async getGroupDmChannel (body) {
1060
+ return await rest.post(rest.routes.channels.dm(), {
1061
+ body
1062
+ });
1063
+ },
1064
+ async getEmoji (guildId, emojiId) {
1065
+ return await rest.get(rest.routes.guilds.emoji(guildId, emojiId));
1066
+ },
1067
+ async getApplicationEmoji (emojiId) {
1068
+ return await rest.get(rest.routes.applicationEmoji(rest.applicationId, emojiId));
1069
+ },
1070
+ async getEmojis (guildId) {
1071
+ return await rest.get(rest.routes.guilds.emojis(guildId));
1072
+ },
1073
+ async getApplicationEmojis () {
1074
+ return await rest.get(rest.routes.applicationEmojis(rest.applicationId));
1075
+ },
1076
+ async getFollowupMessage (token, messageId) {
1077
+ return await rest.get(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), {
1078
+ unauthorized: true
1079
+ });
1080
+ },
1081
+ async getGatewayBot () {
1082
+ return await rest.get(rest.routes.gatewayBot());
1083
+ },
1084
+ async getGlobalApplicationCommand (commandId) {
1085
+ return await rest.get(rest.routes.interactions.commands.command(rest.applicationId, commandId));
1086
+ },
1087
+ async getGlobalApplicationCommands () {
1088
+ return await rest.get(rest.routes.interactions.commands.commands(rest.applicationId));
1089
+ },
1090
+ async getGuild (guildId, options = {
1091
+ counts: true
1092
+ }) {
1093
+ return await rest.get(rest.routes.guilds.guild(guildId, options.counts));
1094
+ },
1095
+ async getGuilds (token, options) {
1096
+ const makeRequestOptions = token ? {
1097
+ headers: {
1098
+ authorization: `Bearer ${token}`
1099
+ },
1100
+ unauthorized: true
1101
+ } : undefined;
1102
+ return await rest.get(rest.routes.guilds.userGuilds(options), makeRequestOptions);
1103
+ },
1104
+ async getGuildApplicationCommand (commandId, guildId) {
1105
+ return await rest.get(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId));
1106
+ },
1107
+ async getGuildApplicationCommands (guildId) {
1108
+ return await rest.get(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId));
1109
+ },
1110
+ async getGuildPreview (guildId) {
1111
+ return await rest.get(rest.routes.guilds.preview(guildId));
1112
+ },
1113
+ async getGuildTemplate (templateCode) {
1114
+ return await rest.get(rest.routes.guilds.templates.code(templateCode));
1115
+ },
1116
+ async getGuildTemplates (guildId) {
1117
+ return await rest.get(rest.routes.guilds.templates.all(guildId));
1118
+ },
1119
+ async getGuildWebhooks (guildId) {
1120
+ return await rest.get(rest.routes.guilds.webhooks(guildId));
1121
+ },
1122
+ async getIntegrations (guildId) {
1123
+ return await rest.get(rest.routes.guilds.integrations(guildId));
1124
+ },
1125
+ async getInvite (inviteCode, options) {
1126
+ return await rest.get(rest.routes.guilds.invite(inviteCode, options));
1127
+ },
1128
+ async getInvites (guildId) {
1129
+ return await rest.get(rest.routes.guilds.invites(guildId));
1130
+ },
1131
+ async getMessage (channelId, messageId) {
1132
+ return await rest.get(rest.routes.channels.message(channelId, messageId));
1133
+ },
1134
+ async getMessages (channelId, options) {
1135
+ return await rest.get(rest.routes.channels.messages(channelId, options));
1136
+ },
1137
+ async getStickerPacks () {
1138
+ return await rest.get(rest.routes.stickerPacks());
1139
+ },
1140
+ async getOriginalInteractionResponse (token) {
1141
+ return await rest.get(rest.routes.interactions.responses.original(rest.applicationId, token), {
1142
+ unauthorized: true
1143
+ });
1144
+ },
1145
+ async getPinnedMessages (channelId) {
1146
+ return await rest.get(rest.routes.channels.pins(channelId));
1147
+ },
1148
+ async getPrivateArchivedThreads (channelId, options) {
1149
+ return await rest.get(rest.routes.channels.threads.private(channelId, options));
1150
+ },
1151
+ async getPrivateJoinedArchivedThreads (channelId, options) {
1152
+ return await rest.get(rest.routes.channels.threads.joined(channelId, options));
1153
+ },
1154
+ async getPruneCount (guildId, options) {
1155
+ return await rest.get(rest.routes.guilds.prune(guildId, options));
1156
+ },
1157
+ async getPublicArchivedThreads (channelId, options) {
1158
+ return await rest.get(rest.routes.channels.threads.public(channelId, options));
1159
+ },
1160
+ async getRoles (guildId) {
1161
+ return await rest.get(rest.routes.guilds.roles.all(guildId));
1162
+ },
1163
+ async getScheduledEvent (guildId, eventId, options) {
1164
+ return await rest.get(rest.routes.guilds.events.event(guildId, eventId, options?.withUserCount));
1165
+ },
1166
+ async getScheduledEvents (guildId, options) {
1167
+ return await rest.get(rest.routes.guilds.events.events(guildId, options?.withUserCount));
1168
+ },
1169
+ async getScheduledEventUsers (guildId, eventId, options) {
1170
+ return await rest.get(rest.routes.guilds.events.users(guildId, eventId, options));
1171
+ },
1172
+ async getSessionInfo () {
1173
+ return await rest.getGatewayBot();
1174
+ },
1175
+ async getStageInstance (channelId) {
1176
+ return await rest.get(rest.routes.channels.stage(channelId));
1177
+ },
1178
+ async getSticker (stickerId) {
1179
+ return await rest.get(rest.routes.sticker(stickerId));
1180
+ },
1181
+ async getGuildSticker (guildId, stickerId) {
1182
+ return await rest.get(rest.routes.guilds.sticker(guildId, stickerId));
1183
+ },
1184
+ async getGuildStickers (guildId) {
1185
+ return await rest.get(rest.routes.guilds.stickers(guildId));
1186
+ },
1187
+ async getThreadMember (channelId, userId) {
1188
+ return await rest.get(rest.routes.channels.threads.user(channelId, userId));
1189
+ },
1190
+ async getThreadMembers (channelId) {
1191
+ return await rest.get(rest.routes.channels.threads.members(channelId));
1192
+ },
1193
+ async getReactions (channelId, messageId, reaction, options) {
1194
+ return await rest.get(rest.routes.channels.reactions.message(channelId, messageId, reaction, options));
1195
+ },
1196
+ async getUser (id) {
1197
+ return await rest.get(rest.routes.user(id));
1198
+ },
1199
+ async getCurrentUser (token) {
1200
+ return await rest.get(rest.routes.currentUser(), {
1201
+ headers: {
1202
+ authorization: `Bearer ${token}`
1203
+ },
1204
+ unauthorized: true
1205
+ });
1206
+ },
1207
+ async getUserConnections (token) {
1208
+ return await rest.get(rest.routes.oauth2.connections(), {
1209
+ headers: {
1210
+ authorization: `Bearer ${token}`
1211
+ },
1212
+ unauthorized: true
1213
+ });
1214
+ },
1215
+ async getUserApplicationRoleConnection (token, applicationId) {
1216
+ return await rest.get(rest.routes.oauth2.roleConnections(applicationId), {
1217
+ headers: {
1218
+ authorization: `Bearer ${token}`
1219
+ },
1220
+ unauthorized: true
1221
+ });
1222
+ },
1223
+ async getVanityUrl (guildId) {
1224
+ return await rest.get(rest.routes.guilds.vanity(guildId));
1225
+ },
1226
+ async getVoiceRegions (guildId) {
1227
+ return await rest.get(rest.routes.guilds.regions(guildId));
1228
+ },
1229
+ async getWebhook (webhookId) {
1230
+ return await rest.get(rest.routes.webhooks.id(webhookId));
1231
+ },
1232
+ async getWebhookMessage (webhookId, token, messageId, options) {
1233
+ return await rest.get(rest.routes.webhooks.message(webhookId, token, messageId, options), {
1234
+ unauthorized: true
1235
+ });
1236
+ },
1237
+ async getWebhookWithToken (webhookId, token) {
1238
+ return await rest.get(rest.routes.webhooks.webhook(webhookId, token), {
1239
+ unauthorized: true
1240
+ });
1241
+ },
1242
+ async getWelcomeScreen (guildId) {
1243
+ return await rest.get(rest.routes.guilds.welcome(guildId));
1244
+ },
1245
+ async getWidget (guildId) {
1246
+ return await rest.get(rest.routes.guilds.widgetJson(guildId));
1247
+ },
1248
+ async getWidgetSettings (guildId) {
1249
+ return await rest.get(rest.routes.guilds.widget(guildId));
1250
+ },
1251
+ async joinThread (channelId) {
1252
+ await rest.put(rest.routes.channels.threads.me(channelId));
1253
+ },
1254
+ async leaveGuild (guildId) {
1255
+ await rest.delete(rest.routes.guilds.leave(guildId));
1256
+ },
1257
+ async leaveThread (channelId) {
1258
+ await rest.delete(rest.routes.channels.threads.me(channelId));
1259
+ },
1260
+ async publishMessage (channelId, messageId) {
1261
+ return await rest.post(rest.routes.channels.crosspost(channelId, messageId));
1262
+ },
1263
+ async removeRole (guildId, userId, roleId, reason) {
1264
+ await rest.delete(rest.routes.guilds.roles.member(guildId, userId, roleId), {
1265
+ reason
1266
+ });
1267
+ },
1268
+ async removeThreadMember (channelId, userId) {
1269
+ await rest.delete(rest.routes.channels.threads.user(channelId, userId));
1270
+ },
1271
+ async removeDmRecipient (channelId, userId) {
1272
+ await rest.delete(rest.routes.channels.dmRecipient(channelId, userId));
1273
+ },
1274
+ async sendFollowupMessage (token, options) {
1275
+ return await rest.post(rest.routes.webhooks.webhook(rest.applicationId, token), {
1276
+ body: options,
1277
+ files: options.files,
1278
+ unauthorized: true
1279
+ });
1280
+ },
1281
+ async sendInteractionResponse (interactionId, token, options) {
1282
+ return await rest.post(rest.routes.interactions.responses.callback(interactionId, token), {
1283
+ body: options,
1284
+ files: options.data?.files,
1285
+ runThroughQueue: false,
1286
+ unauthorized: true
1287
+ });
1288
+ },
1289
+ async sendMessage (channelId, body) {
1290
+ return await rest.post(rest.routes.channels.messages(channelId), {
1291
+ body,
1292
+ files: body.files
1293
+ });
1294
+ },
1295
+ async startThreadWithMessage (channelId, messageId, body, reason) {
1296
+ return await rest.post(rest.routes.channels.threads.message(channelId, messageId), {
1297
+ body,
1298
+ reason
1299
+ });
1300
+ },
1301
+ async startThreadWithoutMessage (channelId, body, reason) {
1302
+ return await rest.post(rest.routes.channels.threads.all(channelId), {
1303
+ body,
1304
+ reason
1305
+ });
1306
+ },
1307
+ async getPollAnswerVoters (channelId, messageId, answerId, options) {
1308
+ return await rest.get(rest.routes.channels.polls.votes(channelId, messageId, answerId, options));
1309
+ },
1310
+ async endPoll (channelId, messageId) {
1311
+ return await rest.post(rest.routes.channels.polls.expire(channelId, messageId));
1312
+ },
1313
+ async syncGuildTemplate (guildId) {
1314
+ return await rest.put(rest.routes.guilds.templates.all(guildId));
1315
+ },
1316
+ async banMember (guildId, userId, body, reason) {
1317
+ await rest.put(rest.routes.guilds.members.ban(guildId, userId), {
1318
+ body,
1319
+ reason
1320
+ });
1321
+ },
1322
+ async bulkBanMembers (guildId, options, reason) {
1323
+ return await rest.post(rest.routes.guilds.members.bulkBan(guildId), {
1324
+ body: options,
1325
+ reason
1326
+ });
1327
+ },
1328
+ async editBotMember (guildId, body, reason) {
1329
+ return await rest.patch(rest.routes.guilds.members.bot(guildId), {
1330
+ body,
1331
+ reason
1332
+ });
1333
+ },
1334
+ async editMember (guildId, userId, body, reason) {
1335
+ return await rest.patch(rest.routes.guilds.members.member(guildId, userId), {
1336
+ body,
1337
+ reason
1338
+ });
1339
+ },
1340
+ async getMember (guildId, userId) {
1341
+ return await rest.get(rest.routes.guilds.members.member(guildId, userId));
1342
+ },
1343
+ async getCurrentMember (guildId, token) {
1344
+ return await rest.get(rest.routes.guilds.members.currentMember(guildId), {
1345
+ headers: {
1346
+ authorization: `Bearer ${token}`
1347
+ },
1348
+ unauthorized: true
1349
+ });
1350
+ },
1351
+ async getMembers (guildId, options) {
1352
+ return await rest.get(rest.routes.guilds.members.members(guildId, options));
1353
+ },
1354
+ async kickMember (guildId, userId, reason) {
1355
+ await rest.delete(rest.routes.guilds.members.member(guildId, userId), {
1356
+ reason
1357
+ });
1358
+ },
1359
+ async pinMessage (channelId, messageId, reason) {
1360
+ await rest.put(rest.routes.channels.pin(channelId, messageId), {
1361
+ reason
1362
+ });
1363
+ },
1364
+ async pruneMembers (guildId, body, reason) {
1365
+ return await rest.post(rest.routes.guilds.members.prune(guildId), {
1366
+ body,
1367
+ reason
1368
+ });
1369
+ },
1370
+ async searchMembers (guildId, query, options) {
1371
+ return await rest.get(rest.routes.guilds.members.search(guildId, query, options));
1372
+ },
1373
+ async getGuildOnboarding (guildId) {
1374
+ return await rest.get(rest.routes.guilds.onboarding(guildId));
1375
+ },
1376
+ async editGuildOnboarding (guildId, options, reason) {
1377
+ return await rest.put(rest.routes.guilds.onboarding(guildId), {
1378
+ body: options,
1379
+ reason
1380
+ });
1381
+ },
1382
+ async unbanMember (guildId, userId, reason) {
1383
+ await rest.delete(rest.routes.guilds.members.ban(guildId, userId), {
1384
+ reason
1385
+ });
1386
+ },
1387
+ async unpinMessage (channelId, messageId, reason) {
1388
+ await rest.delete(rest.routes.channels.pin(channelId, messageId), {
1389
+ reason
1390
+ });
1391
+ },
1392
+ async triggerTypingIndicator (channelId) {
1393
+ await rest.post(rest.routes.channels.typing(channelId));
1394
+ },
1395
+ async upsertGlobalApplicationCommands (body, options) {
1396
+ const restOptions = {
1397
+ body
1398
+ };
1399
+ if (options?.bearerToken) {
1400
+ restOptions.unauthorized = true;
1401
+ restOptions.headers = {
1402
+ authorization: `Bearer ${options.bearerToken}`
1403
+ };
1404
+ }
1405
+ return await rest.put(rest.routes.interactions.commands.commands(rest.applicationId), restOptions);
1406
+ },
1407
+ async upsertGuildApplicationCommands (guildId, body, options) {
1408
+ const restOptions = {
1409
+ body
1410
+ };
1411
+ if (options?.bearerToken) {
1412
+ restOptions.unauthorized = true;
1413
+ restOptions.headers = {
1414
+ authorization: `Bearer ${options.bearerToken}`
1415
+ };
1416
+ }
1417
+ return await rest.put(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), restOptions);
1418
+ },
1419
+ async editUserApplicationRoleConnection (token, applicationId, body) {
1420
+ return await rest.put(rest.routes.oauth2.roleConnections(applicationId), {
1421
+ body,
1422
+ headers: {
1423
+ authorization: `Bearer ${token}`
1424
+ },
1425
+ unauthorized: true
1426
+ });
1427
+ },
1428
+ async addGuildMember (guildId, userId, body) {
1429
+ return await rest.put(rest.routes.guilds.members.member(guildId, userId), {
1430
+ body
1431
+ });
1432
+ },
1433
+ async createTestEntitlement (applicationId, body) {
1434
+ return await rest.post(rest.routes.monetization.entitlements(applicationId), {
1435
+ body
1436
+ });
1437
+ },
1438
+ async listEntitlements (applicationId, options) {
1439
+ return await rest.get(rest.routes.monetization.entitlements(applicationId, options));
1440
+ },
1441
+ async deleteTestEntitlement (applicationId, entitlementId) {
1442
+ await rest.delete(rest.routes.monetization.entitlement(applicationId, entitlementId));
1443
+ },
1444
+ async consumeEntitlement (applicationId, entitlementId) {
1445
+ await rest.post(rest.routes.monetization.consumeEntitlement(applicationId, entitlementId));
1446
+ },
1447
+ async listSkus (applicationId) {
1448
+ return await rest.get(rest.routes.monetization.skus(applicationId));
1449
+ },
1450
+ preferSnakeCase (enabled) {
1451
+ const camelizer = enabled ? (x)=>x : _utils.camelize;
1452
+ rest.get = async (url, options)=>{
1453
+ return camelizer(await rest.makeRequest('GET', url, options));
1454
+ };
1455
+ rest.post = async (url, options)=>{
1456
+ return camelizer(await rest.makeRequest('POST', url, options));
1457
+ };
1458
+ rest.delete = async (url, options)=>{
1459
+ camelizer(await rest.makeRequest('DELETE', url, options));
1460
+ };
1461
+ rest.patch = async (url, options)=>{
1462
+ return camelizer(await rest.makeRequest('PATCH', url, options));
1463
+ };
1464
+ rest.put = async (url, options)=>{
1465
+ return camelizer(await rest.makeRequest('PUT', url, options));
1466
+ };
1467
+ return rest;
1468
+ }
1469
+ };
1470
+ return rest;
1471
+ }
1472
+ var HttpResponseCode;
1473
+ (function(HttpResponseCode) {
1474
+ /** Minimum value of a code in oder to consider that it was successful. */ HttpResponseCode[HttpResponseCode["Success"] = 200] = "Success";
1475
+ /** Request completed successfully, but Discord returned an empty body. */ HttpResponseCode[HttpResponseCode["NoContent"] = 204] = "NoContent";
1476
+ /** Minimum value of a code in order to consider that something went wrong. */ HttpResponseCode[HttpResponseCode["Error"] = 400] = "Error";
1477
+ /** This request got rate limited. */ HttpResponseCode[HttpResponseCode["TooManyRequests"] = 429] = "TooManyRequests";
1478
+ })(HttpResponseCode || (HttpResponseCode = {}));
1479
+
1480
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/manager.ts"],"sourcesContent":["import { Buffer } from 'node:buffer'\nimport {\n  type BigString,\n  type Camelize,\n  type DiscordAccessTokenResponse,\n  type DiscordApplication,\n  type DiscordApplicationCommand,\n  type DiscordApplicationRoleConnection,\n  type DiscordAuditLog,\n  type DiscordAutoModerationRule,\n  type DiscordBan,\n  type DiscordBulkBan,\n  type DiscordChannel,\n  type DiscordConnection,\n  type DiscordCurrentAuthorization,\n  type DiscordEmoji,\n  type DiscordEntitlement,\n  type DiscordFollowedChannel,\n  type DiscordGetAnswerVotesResponse,\n  type DiscordGetGatewayBot,\n  type DiscordGuild,\n  type DiscordGuildApplicationCommandPermissions,\n  type DiscordGuildOnboarding,\n  type DiscordGuildPreview,\n  type DiscordGuildWidget,\n  type DiscordGuildWidgetSettings,\n  type DiscordIntegration,\n  type DiscordInvite,\n  type DiscordInviteMetadata,\n  type DiscordListActiveThreads,\n  type DiscordListArchivedThreads,\n  type DiscordMember,\n  type DiscordMemberWithUser,\n  type DiscordMessage,\n  type DiscordPrunedCount,\n  type DiscordRole,\n  type DiscordScheduledEvent,\n  type DiscordSku,\n  type DiscordStageInstance,\n  type DiscordSticker,\n  type DiscordStickerPack,\n  type DiscordTemplate,\n  type DiscordThreadMember,\n  type DiscordUser,\n  type DiscordVanityUrl,\n  type DiscordVoiceRegion,\n  type DiscordWebhook,\n  type DiscordWelcomeScreen,\n  InteractionResponseTypes,\n  type MfaLevels,\n  type ModifyGuildTemplate,\n} from '@discordeno/types'\nimport { calculateBits, camelToSnakeCase, camelize, delay, getBotIdFromToken, logger, processReactionString, urlToBase64 } from '@discordeno/utils'\nimport { createInvalidRequestBucket } from './invalidBucket.js'\nimport { Queue } from './queue.js'\nimport { createRoutes } from './routes.js'\nimport type { CreateRequestBodyOptions, CreateRestManagerOptions, MakeRequestOptions, RestManager, SendRequestOptions } from './types.js'\n\n// TODO: make dynamic based on package.json file\nconst version = '19.0.0-alpha.1'\n\nexport const DISCORD_API_VERSION = 10\nexport const DISCORD_API_URL = 'https://discord.com/api'\n\nexport const AUDIT_LOG_REASON_HEADER = 'x-audit-log-reason'\nexport const RATE_LIMIT_REMAINING_HEADER = 'x-ratelimit-remaining'\nexport const RATE_LIMIT_RESET_AFTER_HEADER = 'x-ratelimit-reset-after'\nexport const RATE_LIMIT_GLOBAL_HEADER = 'x-ratelimit-global'\nexport const RATE_LIMIT_BUCKET_HEADER = 'x-ratelimit-bucket'\nexport const RATE_LIMIT_LIMIT_HEADER = 'x-ratelimit-limit'\nexport const RATE_LIMIT_SCOPE_HEADER = 'x-ratelimit-scope'\n\nexport function createRestManager(options: CreateRestManagerOptions): RestManager {\n  const applicationId = options.applicationId ? BigInt(options.applicationId) : getBotIdFromToken(options.token)\n\n  const baseUrl = options.proxy?.baseUrl ?? DISCORD_API_URL\n\n  const rest: RestManager = {\n    applicationId,\n    authorization: options.proxy?.authorization,\n    authorizationHeader: options.proxy?.authorizationHeader ?? 'authorization',\n    baseUrl,\n    deleteQueueDelay: 60000,\n    globallyRateLimited: false,\n    invalidBucket: createInvalidRequestBucket({ logger: options.logger }),\n    isProxied: !baseUrl.startsWith(DISCORD_API_URL),\n    updateBearerTokenEndpoint: options.proxy?.updateBearerTokenEndpoint,\n    maxRetryCount: Infinity,\n    processingRateLimitedPaths: false,\n    queues: new Map(),\n    rateLimitedPaths: new Map(),\n    token: options.token,\n    version: options.version ?? DISCORD_API_VERSION,\n    logger: options.logger ?? logger,\n\n    routes: createRoutes(),\n\n    createBaseHeaders() {\n      return {\n        'user-agent': `DiscordBot (https://github.com/discordeno/discordeno, v${version})`,\n      }\n    },\n\n    checkRateLimits(url, identifier) {\n      const ratelimited = rest.rateLimitedPaths.get(`${identifier}${url}`)\n\n      const global = rest.rateLimitedPaths.get('global')\n      const now = Date.now()\n\n      if (ratelimited && now < ratelimited.resetTimestamp) {\n        return ratelimited.resetTimestamp - now\n      }\n\n      if (global && now < global.resetTimestamp) {\n        return global.resetTimestamp - now\n      }\n\n      return false\n    },\n\n    async updateTokenQueues(oldToken, newToken) {\n      if (rest.isProxied) {\n        if (!rest.updateBearerTokenEndpoint) {\n          throw new Error(\n            \"The 'proxy.updateBearerTokenEndpoint' option needs to be set when using a rest proxy and needed to call 'updateTokenQueues'\",\n          )\n        }\n\n        const headers = {\n          'content-type': 'application/json',\n        } as Record<string, string>\n\n        if (rest.authorization !== undefined) {\n          headers[rest.authorizationHeader] = rest.authorization\n        }\n\n        await fetch(`${rest.baseUrl}/${rest.updateBearerTokenEndpoint}`, {\n          method: 'POST',\n          body: JSON.stringify({\n            oldToken,\n            newToken,\n          }),\n          headers,\n        })\n\n        return\n      }\n\n      const newIdentifier = `Bearer ${newToken}`\n\n      // Update all the queues\n      for (const [key, queue] of rest.queues.entries()) {\n        if (!key.startsWith(`Bearer ${oldToken}`)) continue\n\n        rest.queues.delete(key)\n        queue.identifier = newIdentifier\n\n        const newKey = `${newIdentifier}${queue.url}`\n        const newQueue = rest.queues.get(newKey)\n\n        // Merge the queues\n        if (newQueue) {\n          newQueue.waiting.unshift(...queue.waiting)\n          newQueue.pending.unshift(...queue.pending)\n\n          queue.waiting = []\n          queue.pending = []\n\n          queue.cleanup()\n        } else {\n          rest.queues.set(newKey, queue)\n        }\n      }\n\n      for (const [key, ratelimitPath] of rest.rateLimitedPaths.entries()) {\n        if (!key.startsWith(`Bearer ${oldToken}`)) continue\n\n        rest.rateLimitedPaths.set(`${newIdentifier}${ratelimitPath.url}`, ratelimitPath)\n\n        if (ratelimitPath.bucketId) {\n          rest.rateLimitedPaths.set(`${newIdentifier}${ratelimitPath.bucketId}`, ratelimitPath)\n        }\n      }\n    },\n\n    changeToDiscordFormat(obj: any): any {\n      if (obj === null) return null\n\n      if (typeof obj === 'object') {\n        if (Array.isArray(obj)) {\n          return obj.map((item) => rest.changeToDiscordFormat(item))\n        }\n\n        const newObj: any = {}\n\n        for (const key of Object.keys(obj)) {\n          // If the key is already in snake_case we have no reason for the rest of the code to run.\n          if (key.includes('_')) continue\n\n          const value = obj[key]\n\n          // Some falsy values should be allowed like null or 0\n          if (value !== undefined) {\n            switch (key) {\n              case 'permissions':\n              case 'allow':\n              case 'deny':\n                newObj[key] = typeof value === 'string' ? value : calculateBits(value)\n                continue\n              case 'defaultMemberPermissions':\n                newObj.default_member_permissions = typeof value === 'string' ? value : calculateBits(value)\n                continue\n              case 'nameLocalizations':\n                newObj.name_localizations = value\n                continue\n              case 'descriptionLocalizations':\n                newObj.description_localizations = value\n                continue\n            }\n          }\n\n          newObj[camelToSnakeCase(key)] = rest.changeToDiscordFormat(value)\n        }\n\n        return newObj\n      }\n\n      if (typeof obj === 'bigint') return obj.toString()\n\n      return obj\n    },\n\n    createRequestBody(method, options) {\n      const headers = this.createBaseHeaders()\n\n      if (options?.unauthorized !== true) headers.authorization = `Bot ${rest.token}`\n\n      // IF A REASON IS PROVIDED ENCODE IT IN HEADERS\n      if (options?.reason !== undefined) {\n        headers[AUDIT_LOG_REASON_HEADER] = encodeURIComponent(options?.reason)\n      }\n\n      let body: string | FormData | undefined\n\n      // TODO: check if we need to add specific check for GET method\n      // Since GET does not allow bodies\n\n      // Have to check for attachments first, since body then has to be send in a different way.\n      if (options?.files !== undefined) {\n        const form = new FormData()\n        for (let i = 0; i < options.files.length; ++i) {\n          form.append(`file${i}`, options.files[i].blob, options.files[i].name)\n        }\n\n        // Have to use changeToDiscordFormat or else JSON.stringify may throw an error for the presence of BigInt(s) in the json\n        form.append('payload_json', JSON.stringify(rest.changeToDiscordFormat({ ...options.body, files: undefined })))\n\n        // No need to set the `content-type` header since `fetch` does that automatically for us when we use a `FormData` object.\n        body = form\n      } else if (options?.body && options.headers && options.headers['content-type'] === 'application/x-www-form-urlencoded') {\n        // OAuth2 body handling\n        const formBody: string[] = []\n\n        const discordBody = rest.changeToDiscordFormat(options.body)\n\n        for (const prop in discordBody) {\n          formBody.push(`${encodeURIComponent(prop)}=${encodeURIComponent(discordBody[prop])}`)\n        }\n\n        body = formBody.join('&')\n      } else if (options?.body !== undefined) {\n        if (options.body instanceof FormData) {\n          body = options.body\n          // No need to set the `content-type` header since `fetch` does that automatically for us when we use a `FormData` object.\n        } else {\n          body = JSON.stringify(rest.changeToDiscordFormat(options.body))\n          headers['content-type'] = `application/json`\n        }\n      }\n\n      // SOMETIMES SPECIAL HEADERS (E.G. CUSTOM AUTHORIZATION) NEED TO BE USED\n      if (options?.headers) {\n        Object.assign(headers, options.headers)\n      }\n\n      return {\n        body,\n        headers,\n        method,\n      }\n    },\n\n    processRateLimitedPaths() {\n      const now = Date.now()\n\n      for (const [key, value] of rest.rateLimitedPaths.entries()) {\n        //   rest.debug(\n        // `[REST - processRateLimitedPaths] Running for of loop. ${\n        //   value.resetTimestamp - now\n        // }`\n        //   )\n        // If the time has not reached cancel\n        if (value.resetTimestamp > now) continue\n\n        // Rate limit is over, delete the rate limiter\n        rest.rateLimitedPaths.delete(key)\n        // If it was global, also mark the global value as false\n        if (key === 'global') rest.globallyRateLimited = false\n      }\n\n      // ALL PATHS ARE CLEARED CAN CANCEL OUT!\n      if (rest.rateLimitedPaths.size === 0) {\n        rest.processingRateLimitedPaths = false\n      } else {\n        rest.processingRateLimitedPaths = true\n        // RECHECK IN 1 SECOND\n        setTimeout(() => {\n          // rest.debug('[REST - processRateLimitedPaths] Running setTimeout.')\n          rest.processRateLimitedPaths()\n        }, 1000)\n      }\n    },\n\n    /** Processes the rate limit headers and determines if it needs to be rate limited and returns the bucket id if available */\n    processHeaders(url, headers, identifier) {\n      let rateLimited = false\n\n      // GET ALL NECESSARY HEADERS\n      const remaining = headers.get(RATE_LIMIT_REMAINING_HEADER)\n      const retryAfter = headers.get(RATE_LIMIT_RESET_AFTER_HEADER)\n      const reset = Date.now() + Number(retryAfter) * 1000\n      const global = headers.get(RATE_LIMIT_GLOBAL_HEADER)\n      // undefined override null needed for typings\n      const bucketId = headers.get(RATE_LIMIT_BUCKET_HEADER) ?? undefined\n      const limit = headers.get(RATE_LIMIT_LIMIT_HEADER)\n\n      // If we didn't received the identifier, fallback to the bot token\n      identifier ??= `Bot ${rest.token}`\n\n      rest.queues.get(`${identifier}${url}`)?.handleCompletedRequest({\n        remaining: remaining ? Number(remaining) : undefined,\n        interval: retryAfter ? Number(retryAfter) * 1000 : undefined,\n        max: limit ? Number(limit) : undefined,\n      })\n\n      // IF THERE IS NO REMAINING RATE LIMIT, MARK IT AS RATE LIMITED\n      if (remaining === '0') {\n        rateLimited = true\n\n        // SAVE THE URL AS LIMITED, IMPORTANT FOR NEW REQUESTS BY USER WITHOUT BUCKET\n        rest.rateLimitedPaths.set(`${identifier}${url}`, {\n          url,\n          resetTimestamp: reset,\n          bucketId,\n        })\n\n        // SAVE THE BUCKET AS LIMITED SINCE DIFFERENT URLS MAY SHARE A BUCKET\n        if (bucketId) {\n          rest.rateLimitedPaths.set(`${identifier}${bucketId}`, {\n            url,\n            resetTimestamp: reset,\n            bucketId,\n          })\n        }\n      }\n\n      // IF THERE IS NO REMAINING GLOBAL LIMIT, MARK IT RATE LIMITED GLOBALLY\n      if (global) {\n        const retryAfter = Number(headers.get('retry-after')) * 1000\n        const globalReset = Date.now() + retryAfter\n        //   rest.debug(\n        // `[REST = Globally Rate Limited] URL: ${url} | Global Rest: ${globalReset}`\n        //   )\n        rest.globallyRateLimited = true\n        rateLimited = true\n\n        setTimeout(() => {\n          rest.globallyRateLimited = false\n        }, retryAfter)\n\n        rest.rateLimitedPaths.set('global', {\n          url: 'global',\n          resetTimestamp: globalReset,\n          bucketId,\n        })\n\n        if (bucketId) {\n          rest.rateLimitedPaths.set(identifier, {\n            url: 'global',\n            resetTimestamp: globalReset,\n            bucketId,\n          })\n        }\n      }\n\n      if (rateLimited && !rest.processingRateLimitedPaths) {\n        rest.processRateLimitedPaths()\n      }\n      return rateLimited ? bucketId : undefined\n    },\n\n    async sendRequest(options) {\n      const url = `${rest.baseUrl}/v${rest.version}${options.route}`\n      const payload = rest.createRequestBody(options.method, options.requestBodyOptions)\n\n      const loggingHeaders = { ...payload.headers }\n\n      if (payload.headers.authorization) {\n        const authorizationScheme = payload.headers.authorization?.split(' ')[0]\n        loggingHeaders.authorization = `${authorizationScheme} tokenhere`\n      }\n\n      rest.logger.debug(`sending request to ${url}`, 'with payload:', { ...payload, headers: loggingHeaders })\n      const response = await fetch(url, payload).catch(async (error) => {\n        rest.logger.error(error)\n        // Mark request and completed\n        rest.invalidBucket.handleCompletedRequest(999, false)\n        options.reject({\n          ok: false,\n          status: 999,\n          error: 'Possible network or request shape issue occurred. If this is rare, its a network glitch. If it occurs a lot something is wrong.',\n        })\n        throw error\n      })\n      rest.logger.debug(`request fetched from ${url} with status ${response.status} & ${response.statusText}`)\n\n      // Mark request and completed\n      rest.invalidBucket.handleCompletedRequest(response.status, response.headers.get(RATE_LIMIT_SCOPE_HEADER) === 'shared')\n\n      // Set the bucket id if it was available on the headers\n      const bucketId = rest.processHeaders(rest.simplifyUrl(options.route, options.method), response.headers, payload.headers.authorization)\n\n      if (bucketId) options.bucketId = bucketId\n\n      if (response.status < HttpResponseCode.Success || response.status >= HttpResponseCode.Error) {\n        rest.logger.debug(`Request to ${url} failed.`)\n\n        if (response.status !== HttpResponseCode.TooManyRequests) {\n          options.reject({ ok: false, status: response.status, body: await response.text() })\n          return\n        }\n\n        rest.logger.debug(`Request to ${url} was ratelimited.`)\n        // Too many attempts, get rid of request from queue.\n        if (options.retryCount >= rest.maxRetryCount) {\n          rest.logger.debug(`Request to ${url} exceeded the maximum allowed retries.`, 'with payload:', payload)\n          // rest.debug(`[REST - RetriesMaxed] ${JSON.stringify(options)}`)\n          options.reject({\n            ok: false,\n            status: response.status,\n            error: 'The request was rate limited and it maxed out the retries limit.',\n          })\n\n          return\n        }\n\n        options.retryCount += 1\n\n        const resetAfter = response.headers.get(RATE_LIMIT_RESET_AFTER_HEADER)\n        if (resetAfter) await delay(Number(resetAfter) * 1000)\n        // process the response to prevent mem leak\n        await response.arrayBuffer()\n\n        return await options.retryRequest?.(options)\n      }\n\n      // Discord sometimes sends no response with no content.\n      options.resolve({ ok: true, status: response.status, body: response.status === HttpResponseCode.NoContent ? undefined : await response.text() })\n    },\n\n    simplifyUrl(url, method) {\n      const parts = url.split('/')\n      const secondLastPart = parts[parts.length - 2]\n\n      if (secondLastPart === 'channels' || secondLastPart === 'guilds') {\n        return url\n      }\n\n      if (secondLastPart === 'reactions' || parts[parts.length - 1] === '@me') {\n        parts.splice(-2)\n        parts.push('reactions')\n      } else {\n        parts.splice(-1)\n        parts.push('x')\n      }\n\n      if (parts[parts.length - 3] === 'reactions') {\n        parts.splice(-2)\n      }\n\n      if (method === 'DELETE' && secondLastPart === 'messages') {\n        return `D${parts.join('/')}`\n      }\n\n      return parts.join('/')\n    },\n\n    async processRequest(request: SendRequestOptions) {\n      const url = rest.simplifyUrl(request.route, request.method)\n\n      if (request.runThroughQueue === false) {\n        await rest.sendRequest(request)\n\n        return\n      }\n\n      // If we the request has a token, use it\n      // Else fallback to prefix with the bot token\n      const queueIdentifier = request.requestBodyOptions?.headers?.authorization ?? `Bot ${rest.token}`\n\n      const queue = rest.queues.get(`${queueIdentifier}${url}`)\n\n      if (queue !== undefined) {\n        queue.makeRequest(request)\n      } else {\n        // CREATES A NEW QUEUE\n        const bucketQueue = new Queue(rest, { url, deleteQueueDelay: rest.deleteQueueDelay, identifier: queueIdentifier })\n\n        // Save queue\n        rest.queues.set(`${queueIdentifier}${url}`, bucketQueue)\n\n        // Add request to queue\n        bucketQueue.makeRequest(request)\n      }\n    },\n\n    async makeRequest(method, route, options) {\n      if (rest.isProxied) {\n        if (rest.authorization !== undefined) {\n          options ??= {}\n          options.headers ??= {}\n          options.headers[rest.authorizationHeader] = rest.authorization\n        }\n\n        const result = await fetch(`${rest.baseUrl}/v${rest.version}${route}`, rest.createRequestBody(method, options))\n\n        if (!result.ok) {\n          const err = (await result.json().catch(() => {})) as Record<string, any>\n          // Legacy Handling to not break old code or when body is missing\n          if (!err?.body) throw new Error(`Error: ${err.message ?? result.statusText}`)\n          throw new Error(JSON.stringify(err))\n        }\n\n        return result.status !== 204 ? await result.json() : undefined\n      }\n\n      // This error needs to be created here because of how stack traces get calculated\n      const error = new Error()\n      error.message = 'Failed to send request to discord.'\n\n      return await new Promise(async (resolve, reject) => {\n        const payload: SendRequestOptions = {\n          route,\n          method,\n          requestBodyOptions: options,\n          retryCount: 0,\n          retryRequest: async (payload: SendRequestOptions) => {\n            await rest.processRequest(payload)\n          },\n          resolve: (data) => {\n            resolve(data.status !== 204 ? JSON.parse(data.body ?? '{}') : undefined)\n          },\n          reject: (reason) => {\n            error.cause = reason\n            reject(error)\n          },\n          runThroughQueue: options?.runThroughQueue,\n        }\n\n        await rest.processRequest(payload)\n      })\n    },\n\n    async get<T = Record<string, unknown>>(url: string, options?: Omit<CreateRequestBodyOptions, 'body' | 'method'>) {\n      return camelize(await rest.makeRequest('GET', url, options)) as Camelize<T>\n    },\n\n    async post<T = Record<string, unknown>>(url: string, options?: Omit<CreateRequestBodyOptions, 'body' | 'method'>) {\n      return camelize(await rest.makeRequest('POST', url, options)) as Camelize<T>\n    },\n\n    async delete(url: string, options?: Omit<CreateRequestBodyOptions, 'body' | 'method'>) {\n      camelize(await rest.makeRequest('DELETE', url, options))\n    },\n\n    async patch<T = Record<string, unknown>>(url: string, options?: Omit<CreateRequestBodyOptions, 'body' | 'method'>) {\n      return camelize(await rest.makeRequest('PATCH', url, options)) as Camelize<T>\n    },\n\n    async put<T = void>(url: string, options?: Omit<CreateRequestBodyOptions, 'body' | 'method'>) {\n      return camelize(await rest.makeRequest('PUT', url, options)) as Camelize<T>\n    },\n\n    async addReaction(channelId, messageId, reaction) {\n      reaction = processReactionString(reaction)\n\n      await rest.put(rest.routes.channels.reactions.bot(channelId, messageId, reaction))\n    },\n\n    async addReactions(channelId, messageId, reactions, ordered = false) {\n      if (!ordered) {\n        await Promise.all(\n          reactions.map(async (reaction) => {\n            await rest.addReaction(channelId, messageId, reaction)\n          }),\n        )\n        return\n      }\n\n      for (const reaction of reactions) {\n        await rest.addReaction(channelId, messageId, reaction)\n      }\n    },\n\n    async addRole(guildId, userId, roleId, reason) {\n      await rest.put(rest.routes.guilds.roles.member(guildId, userId, roleId), { reason })\n    },\n\n    async addThreadMember(channelId, userId) {\n      await rest.put(rest.routes.channels.threads.user(channelId, userId))\n    },\n\n    async addDmRecipient(channelId, userId, body) {\n      await rest.put(rest.routes.channels.dmRecipient(channelId, userId), { body })\n    },\n\n    async createAutomodRule(guildId, body, reason) {\n      return await rest.post<DiscordAutoModerationRule>(rest.routes.guilds.automod.rules(guildId), { body, reason })\n    },\n\n    async createChannel(guildId, body, reason) {\n      return await rest.post<DiscordChannel>(rest.routes.guilds.channels(guildId), { body, reason })\n    },\n\n    async createEmoji(guildId, body, reason) {\n      return await rest.post<DiscordEmoji>(rest.routes.guilds.emojis(guildId), { body, reason })\n    },\n\n    async createApplicationEmoji(body) {\n      return await rest.post<DiscordEmoji>(rest.routes.applicationEmojis(rest.applicationId), { body })\n    },\n\n    async createGlobalApplicationCommand(body, options) {\n      const restOptions: MakeRequestOptions = { body }\n\n      if (options?.bearerToken) {\n        restOptions.unauthorized = true\n        restOptions.headers = {\n          authorization: `Bearer ${options.bearerToken}`,\n        }\n      }\n\n      return await rest.post<DiscordApplicationCommand>(rest.routes.interactions.commands.commands(rest.applicationId), restOptions)\n    },\n\n    async createGuild(body) {\n      return await rest.post<DiscordGuild>(rest.routes.guilds.all(), { body })\n    },\n\n    async createGuildApplicationCommand(body, guildId, options) {\n      const restOptions: MakeRequestOptions = { body }\n\n      if (options?.bearerToken) {\n        restOptions.unauthorized = true\n        restOptions.headers = {\n          authorization: `Bearer ${options.bearerToken}`,\n        }\n      }\n\n      return await rest.post<DiscordApplicationCommand>(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), restOptions)\n    },\n\n    async createGuildFromTemplate(templateCode, body) {\n      if (body.icon) {\n        body.icon = await urlToBase64(body.icon)\n      }\n\n      return await rest.post<DiscordGuild>(rest.routes.guilds.templates.code(templateCode), { body })\n    },\n\n    async createGuildSticker(guildId, options, reason) {\n      const form = new FormData()\n      form.append('file', options.file.blob, options.file.name)\n      form.append('name', options.name)\n      form.append('description', options.description)\n      form.append('tags', options.tags)\n\n      return await rest.post<DiscordSticker>(rest.routes.guilds.stickers(guildId), { body: form, reason })\n    },\n\n    async createGuildTemplate(guildId, body) {\n      return await rest.post<DiscordTemplate>(rest.routes.guilds.templates.all(guildId), { body })\n    },\n\n    async createForumThread(channelId, body, reason) {\n      return await rest.post<DiscordChannel>(rest.routes.channels.forum(channelId), { body, files: body.files, reason })\n    },\n\n    async createInvite(channelId, body = {}, reason) {\n      return await rest.post<DiscordInvite>(rest.routes.channels.invites(channelId), { body, reason })\n    },\n\n    async createRole(guildId, body, reason) {\n      return await rest.post<DiscordRole>(rest.routes.guilds.roles.all(guildId), { body, reason })\n    },\n\n    async createScheduledEvent(guildId, body, reason) {\n      return await rest.post<DiscordScheduledEvent>(rest.routes.guilds.events.events(guildId), { body, reason })\n    },\n\n    async createStageInstance(body, reason) {\n      return await rest.post<DiscordStageInstance>(rest.routes.channels.stages(), { body, reason })\n    },\n\n    async createWebhook(channelId, options, reason) {\n      return await rest.post<DiscordWebhook>(rest.routes.channels.webhooks(channelId), {\n        body: {\n          name: options.name,\n          avatar: options.avatar ? await urlToBase64(options.avatar) : undefined,\n        },\n        reason,\n      })\n    },\n\n    async deleteAutomodRule(guildId, ruleId, reason) {\n      await rest.delete(rest.routes.guilds.automod.rule(guildId, ruleId), { reason })\n    },\n\n    async deleteChannel(channelId, reason) {\n      await rest.delete(rest.routes.channels.channel(channelId), {\n        reason,\n      })\n    },\n\n    async deleteChannelPermissionOverride(channelId, overwriteId, reason) {\n      await rest.delete(rest.routes.channels.overwrite(channelId, overwriteId), { reason })\n    },\n\n    async deleteEmoji(guildId, id, reason) {\n      await rest.delete(rest.routes.guilds.emoji(guildId, id), { reason })\n    },\n\n    async deleteApplicationEmoji(id) {\n      await rest.delete(rest.routes.applicationEmoji(rest.applicationId, id))\n    },\n\n    async deleteFollowupMessage(token, messageId) {\n      await rest.delete(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), { unauthorized: true })\n    },\n\n    async deleteGlobalApplicationCommand(commandId) {\n      await rest.delete(rest.routes.interactions.commands.command(rest.applicationId, commandId))\n    },\n\n    async deleteGuild(guildId) {\n      await rest.delete(rest.routes.guilds.guild(guildId))\n    },\n\n    async deleteGuildApplicationCommand(commandId, guildId) {\n      await rest.delete(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId))\n    },\n\n    async deleteGuildSticker(guildId, stickerId, reason) {\n      await rest.delete(rest.routes.guilds.sticker(guildId, stickerId), { reason })\n    },\n\n    async deleteGuildTemplate(guildId, templateCode) {\n      await rest.delete(rest.routes.guilds.templates.guild(guildId, templateCode))\n    },\n\n    async deleteIntegration(guildId, integrationId, reason) {\n      await rest.delete(rest.routes.guilds.integration(guildId, integrationId), { reason })\n    },\n\n    async deleteInvite(inviteCode, reason) {\n      await rest.delete(rest.routes.guilds.invite(inviteCode), { reason })\n    },\n\n    async deleteMessage(channelId, messageId, reason) {\n      await rest.delete(rest.routes.channels.message(channelId, messageId), { reason })\n    },\n\n    async deleteMessages(channelId, messageIds, reason) {\n      await rest.post(rest.routes.channels.bulk(channelId), {\n        body: {\n          messages: messageIds.slice(0, 100).map((id) => id.toString()),\n        },\n        reason,\n      })\n    },\n\n    async deleteOriginalInteractionResponse(token) {\n      await rest.delete(rest.routes.interactions.responses.original(rest.applicationId, token), { unauthorized: true })\n    },\n\n    async deleteOwnReaction(channelId, messageId, reaction) {\n      reaction = processReactionString(reaction)\n\n      await rest.delete(rest.routes.channels.reactions.bot(channelId, messageId, reaction))\n    },\n\n    async deleteReactionsAll(channelId, messageId) {\n      await rest.delete(rest.routes.channels.reactions.all(channelId, messageId))\n    },\n\n    async deleteReactionsEmoji(channelId, messageId, reaction) {\n      reaction = processReactionString(reaction)\n\n      await rest.delete(rest.routes.channels.reactions.emoji(channelId, messageId, reaction))\n    },\n\n    async deleteRole(guildId, roleId, reason) {\n      await rest.delete(rest.routes.guilds.roles.one(guildId, roleId), { reason })\n    },\n\n    async deleteScheduledEvent(guildId, eventId) {\n      await rest.delete(rest.routes.guilds.events.event(guildId, eventId))\n    },\n\n    async deleteStageInstance(channelId, reason) {\n      await rest.delete(rest.routes.channels.stage(channelId), { reason })\n    },\n\n    async deleteUserReaction(channelId, messageId, userId, reaction) {\n      reaction = processReactionString(reaction)\n\n      await rest.delete(rest.routes.channels.reactions.user(channelId, messageId, reaction, userId))\n    },\n\n    async deleteWebhook(webhookId, reason) {\n      await rest.delete(rest.routes.webhooks.id(webhookId), { reason })\n    },\n\n    async deleteWebhookMessage(webhookId, token, messageId, options) {\n      await rest.delete(rest.routes.webhooks.message(webhookId, token, messageId, options))\n    },\n\n    async deleteWebhookWithToken(webhookId, token) {\n      await rest.delete(rest.routes.webhooks.webhook(webhookId, token), {\n        unauthorized: true,\n      })\n    },\n\n    async editApplicationCommandPermissions(guildId, commandId, bearerToken, permissions) {\n      return await rest.put<DiscordGuildApplicationCommandPermissions>(\n        rest.routes.interactions.commands.permission(rest.applicationId, guildId, commandId),\n        {\n          body: {\n            permissions,\n          },\n          headers: { authorization: `Bearer ${bearerToken}` },\n        },\n      )\n    },\n\n    async editAutomodRule(guildId, ruleId, body, reason) {\n      return await rest.patch<DiscordAutoModerationRule>(rest.routes.guilds.automod.rule(guildId, ruleId), { body, reason })\n    },\n\n    async editBotProfile(options) {\n      const avatar = options?.botAvatarURL ? await urlToBase64(options?.botAvatarURL) : options?.botAvatarURL\n      const banner = options?.botBannerURL ? await urlToBase64(options?.botBannerURL) : options?.botBannerURL\n\n      return await rest.patch<DiscordUser>(rest.routes.currentUser(), {\n        body: {\n          username: options.username?.trim(),\n          avatar,\n          banner,\n        },\n      })\n    },\n\n    async editChannel(channelId, body, reason) {\n      return await rest.patch<DiscordChannel>(rest.routes.channels.channel(channelId), { body, reason })\n    },\n\n    async editChannelPermissionOverrides(channelId, body, reason) {\n      await rest.put(rest.routes.channels.overwrite(channelId, body.id), { body, reason })\n    },\n\n    async editChannelPositions(guildId, body) {\n      await rest.patch(rest.routes.guilds.channels(guildId), { body })\n    },\n\n    async editEmoji(guildId, id, body, reason) {\n      return await rest.patch<DiscordEmoji>(rest.routes.guilds.emoji(guildId, id), { body, reason })\n    },\n\n    async editApplicationEmoji(id, body) {\n      return await rest.patch<DiscordEmoji>(rest.routes.applicationEmoji(rest.applicationId, id), { body })\n    },\n\n    async editFollowupMessage(token, messageId, body) {\n      return await rest.patch<DiscordMessage>(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), {\n        body,\n        files: body.files,\n        unauthorized: true,\n      })\n    },\n\n    async editGlobalApplicationCommand(commandId, body) {\n      return await rest.patch<DiscordApplicationCommand>(rest.routes.interactions.commands.command(rest.applicationId, commandId), { body })\n    },\n\n    async editGuild(guildId, body, reason) {\n      return await rest.patch<DiscordGuild>(rest.routes.guilds.guild(guildId), { body, reason })\n    },\n\n    async editGuildApplicationCommand(commandId, guildId, body) {\n      return await rest.patch<DiscordApplicationCommand>(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId), {\n        body,\n      })\n    },\n\n    async editGuildMfaLevel(guildId: BigString, mfaLevel: MfaLevels, reason?: string): Promise<void> {\n      await rest.post(rest.routes.guilds.mfa(guildId), { body: { level: mfaLevel }, reason })\n    },\n\n    async editGuildSticker(guildId, stickerId, body, reason) {\n      return await rest.patch<DiscordSticker>(rest.routes.guilds.sticker(guildId, stickerId), { body, reason })\n    },\n\n    async editGuildTemplate(guildId, templateCode: string, body: ModifyGuildTemplate): Promise<Camelize<DiscordTemplate>> {\n      return await rest.patch<DiscordTemplate>(rest.routes.guilds.templates.guild(guildId, templateCode), { body })\n    },\n\n    async editMessage(channelId, messageId, body) {\n      return await rest.patch<DiscordMessage>(rest.routes.channels.message(channelId, messageId), { body, files: body.files })\n    },\n\n    async editOriginalInteractionResponse(token, body) {\n      return await rest.patch<DiscordMessage>(rest.routes.interactions.responses.original(rest.applicationId, token), {\n        body,\n        files: body.files,\n      })\n    },\n\n    async editOriginalWebhookMessage(webhookId, token, options) {\n      return await rest.patch<DiscordMessage>(rest.routes.webhooks.original(webhookId, token, options), {\n        body: {\n          type: InteractionResponseTypes.UpdateMessage,\n          data: options,\n        },\n        files: options.files,\n        unauthorized: true,\n      })\n    },\n\n    async editOwnVoiceState(guildId, options) {\n      await rest.patch(rest.routes.guilds.voice(guildId), {\n        body: {\n          ...options,\n          request_to_speak_timestamp: options.requestToSpeakTimestamp\n            ? new Date(options.requestToSpeakTimestamp).toISOString()\n            : options.requestToSpeakTimestamp,\n        },\n      })\n    },\n\n    async editScheduledEvent(guildId, eventId, body, reason) {\n      return await rest.patch<DiscordScheduledEvent>(rest.routes.guilds.events.event(guildId, eventId), { body, reason })\n    },\n\n    async editRole(guildId, roleId, body, reason) {\n      return await rest.patch<DiscordRole>(rest.routes.guilds.roles.one(guildId, roleId), { body, reason })\n    },\n\n    async editRolePositions(guildId, body, reason) {\n      return await rest.patch<DiscordRole[]>(rest.routes.guilds.roles.all(guildId), { body, reason })\n    },\n\n    async editStageInstance(channelId, topic, reason?: string) {\n      return await rest.patch<DiscordStageInstance>(rest.routes.channels.stage(channelId), { body: { topic }, reason })\n    },\n\n    async editUserVoiceState(guildId, options) {\n      await rest.patch(rest.routes.guilds.voice(guildId, options.userId), { body: options })\n    },\n\n    async editWebhook(webhookId, body, reason) {\n      return await rest.patch<DiscordWebhook>(rest.routes.webhooks.id(webhookId), { body, reason })\n    },\n\n    async editWebhookMessage(webhookId, token, messageId, options) {\n      return await rest.patch<DiscordMessage>(rest.routes.webhooks.message(webhookId, token, messageId, options), {\n        body: options,\n        files: options.files,\n        unauthorized: true,\n      })\n    },\n\n    async editWebhookWithToken(webhookId, token, body) {\n      return await rest.patch<DiscordWebhook>(rest.routes.webhooks.webhook(webhookId, token), {\n        body,\n        unauthorized: true,\n      })\n    },\n\n    async editWelcomeScreen(guildId, body, reason) {\n      return await rest.patch<DiscordWelcomeScreen>(rest.routes.guilds.welcome(guildId), { body, reason })\n    },\n\n    async editWidgetSettings(guildId, body, reason) {\n      return await rest.patch<DiscordGuildWidgetSettings>(rest.routes.guilds.widget(guildId), { body, reason })\n    },\n\n    async executeWebhook(webhookId, token, options) {\n      return await rest.post<DiscordMessage>(rest.routes.webhooks.webhook(webhookId, token, options), {\n        body: options,\n        unauthorized: true,\n      })\n    },\n\n    async followAnnouncement(sourceChannelId, targetChannelId, reason) {\n      return await rest.post<DiscordFollowedChannel>(rest.routes.channels.follow(sourceChannelId), {\n        body: {\n          webhook_channel_id: targetChannelId,\n        },\n        reason,\n      })\n    },\n\n    async getActiveThreads(guildId) {\n      return await rest.get<DiscordListActiveThreads>(rest.routes.channels.threads.active(guildId))\n    },\n\n    async getApplicationCommandPermission(guildId, commandId, options) {\n      const restOptions: Omit<MakeRequestOptions, 'body'> = {}\n\n      if (options?.accessToken) {\n        restOptions.unauthorized = true\n        restOptions.headers = {\n          authorization: `Bearer ${options.accessToken}`,\n        }\n      }\n\n      return await rest.get<DiscordGuildApplicationCommandPermissions>(\n        rest.routes.interactions.commands.permission(options?.applicationId ?? rest.applicationId, guildId, commandId),\n        restOptions,\n      )\n    },\n\n    async getApplicationCommandPermissions(guildId, options) {\n      const restOptions: Omit<MakeRequestOptions, 'body'> = {}\n\n      if (options?.accessToken) {\n        restOptions.unauthorized = true\n        restOptions.headers = {\n          authorization: `Bearer ${options.accessToken}`,\n        }\n      }\n\n      return await rest.get<DiscordGuildApplicationCommandPermissions[]>(\n        rest.routes.interactions.commands.permissions(options?.applicationId ?? rest.applicationId, guildId),\n        restOptions,\n      )\n    },\n\n    async getApplicationInfo() {\n      return await rest.get<DiscordApplication>(rest.routes.oauth2.application())\n    },\n\n    async editApplicationInfo(body) {\n      return await rest.patch<DiscordApplication>(rest.routes.application(), {\n        body,\n      })\n    },\n\n    async getCurrentAuthenticationInfo(token) {\n      return await rest.get<DiscordCurrentAuthorization>(rest.routes.oauth2.currentAuthorization(), {\n        headers: {\n          authorization: `Bearer ${token}`,\n        },\n        unauthorized: true,\n      })\n    },\n\n    async exchangeToken(clientId, clientSecret, body) {\n      const basicCredentials = Buffer.from(`${clientId}:${clientSecret}`)\n\n      const restOptions: MakeRequestOptions = {\n        body,\n        headers: {\n          'content-type': 'application/x-www-form-urlencoded',\n          authorization: `Basic ${basicCredentials.toString('base64')}`,\n        },\n        runThroughQueue: false,\n        unauthorized: true,\n      }\n\n      if (body.grantType === 'client_credentials') {\n        restOptions.body.scope = body.scope.join(' ')\n      }\n\n      return await rest.post<DiscordAccessTokenResponse>(rest.routes.oauth2.tokenExchange(), restOptions)\n    },\n\n    async revokeToken(clientId, clientSecret, body) {\n      const basicCredentials = Buffer.from(`${clientId}:${clientSecret}`)\n\n      await rest.post(rest.routes.oauth2.tokenRevoke(), {\n        body,\n        headers: {\n          'content-type': 'application/x-www-form-urlencoded',\n          authorization: `Basic ${basicCredentials.toString('base64')}`,\n        },\n        unauthorized: true,\n      })\n    },\n\n    async getAuditLog(guildId, options) {\n      return await rest.get<DiscordAuditLog>(rest.routes.guilds.auditlogs(guildId, options))\n    },\n\n    async getAutomodRule(guildId, ruleId) {\n      return await rest.get<DiscordAutoModerationRule>(rest.routes.guilds.automod.rule(guildId, ruleId))\n    },\n\n    async getAutomodRules(guildId) {\n      return await rest.get<DiscordAutoModerationRule[]>(rest.routes.guilds.automod.rules(guildId))\n    },\n\n    async getAvailableVoiceRegions() {\n      return await rest.get<DiscordVoiceRegion[]>(rest.routes.regions())\n    },\n\n    async getBan(guildId, userId) {\n      return await rest.get<DiscordBan>(rest.routes.guilds.members.ban(guildId, userId))\n    },\n\n    async getBans(guildId, options) {\n      return await rest.get<DiscordBan[]>(rest.routes.guilds.members.bans(guildId, options))\n    },\n\n    async getChannel(id) {\n      return await rest.get<DiscordChannel>(rest.routes.channels.channel(id))\n    },\n\n    async getChannelInvites(channelId) {\n      return await rest.get<DiscordInviteMetadata[]>(rest.routes.channels.invites(channelId))\n    },\n\n    async getChannels(guildId) {\n      return await rest.get<DiscordChannel[]>(rest.routes.guilds.channels(guildId))\n    },\n\n    async getChannelWebhooks(channelId) {\n      return await rest.get<DiscordWebhook[]>(rest.routes.channels.webhooks(channelId))\n    },\n\n    async getDmChannel(userId) {\n      return await rest.post<DiscordChannel>(rest.routes.channels.dm(), {\n        body: { recipient_id: userId },\n      })\n    },\n\n    async getGroupDmChannel(body) {\n      return await rest.post<DiscordChannel>(rest.routes.channels.dm(), {\n        body,\n      })\n    },\n\n    async getEmoji(guildId, emojiId) {\n      return await rest.get<DiscordEmoji>(rest.routes.guilds.emoji(guildId, emojiId))\n    },\n\n    async getApplicationEmoji(emojiId) {\n      return await rest.get<DiscordEmoji>(rest.routes.applicationEmoji(rest.applicationId, emojiId))\n    },\n\n    async getEmojis(guildId) {\n      return await rest.get<DiscordEmoji[]>(rest.routes.guilds.emojis(guildId))\n    },\n\n    async getApplicationEmojis() {\n      return await rest.get<{ items: DiscordEmoji[] }>(rest.routes.applicationEmojis(rest.applicationId))\n    },\n\n    async getFollowupMessage(token, messageId) {\n      return await rest.get<DiscordMessage>(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), { unauthorized: true })\n    },\n\n    async getGatewayBot() {\n      return await rest.get<DiscordGetGatewayBot>(rest.routes.gatewayBot())\n    },\n\n    async getGlobalApplicationCommand(commandId) {\n      return await rest.get<DiscordApplicationCommand>(rest.routes.interactions.commands.command(rest.applicationId, commandId))\n    },\n\n    async getGlobalApplicationCommands() {\n      return await rest.get<DiscordApplicationCommand[]>(rest.routes.interactions.commands.commands(rest.applicationId))\n    },\n\n    async getGuild(guildId, options = { counts: true }) {\n      return await rest.get<DiscordGuild>(rest.routes.guilds.guild(guildId, options.counts))\n    },\n\n    async getGuilds(token, options) {\n      const makeRequestOptions: MakeRequestOptions | undefined = token\n        ? {\n            headers: {\n              authorization: `Bearer ${token}`,\n            },\n            unauthorized: true,\n          }\n        : undefined\n\n      return await rest.get<Partial<DiscordGuild>[]>(rest.routes.guilds.userGuilds(options), makeRequestOptions)\n    },\n\n    async getGuildApplicationCommand(commandId, guildId) {\n      return await rest.get<DiscordApplicationCommand>(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId))\n    },\n\n    async getGuildApplicationCommands(guildId) {\n      return await rest.get<DiscordApplicationCommand[]>(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId))\n    },\n\n    async getGuildPreview(guildId) {\n      return await rest.get<DiscordGuildPreview>(rest.routes.guilds.preview(guildId))\n    },\n\n    async getGuildTemplate(templateCode) {\n      return await rest.get<DiscordTemplate>(rest.routes.guilds.templates.code(templateCode))\n    },\n\n    async getGuildTemplates(guildId) {\n      return await rest.get<DiscordTemplate[]>(rest.routes.guilds.templates.all(guildId))\n    },\n\n    async getGuildWebhooks(guildId) {\n      return await rest.get<DiscordWebhook[]>(rest.routes.guilds.webhooks(guildId))\n    },\n\n    async getIntegrations(guildId) {\n      return await rest.get<DiscordIntegration[]>(rest.routes.guilds.integrations(guildId))\n    },\n\n    async getInvite(inviteCode, options) {\n      return await rest.get<DiscordInviteMetadata>(rest.routes.guilds.invite(inviteCode, options))\n    },\n\n    async getInvites(guildId) {\n      return await rest.get<DiscordInviteMetadata[]>(rest.routes.guilds.invites(guildId))\n    },\n\n    async getMessage(channelId, messageId) {\n      return await rest.get<DiscordMessage>(rest.routes.channels.message(channelId, messageId))\n    },\n\n    async getMessages(channelId, options) {\n      return await rest.get<DiscordMessage[]>(rest.routes.channels.messages(channelId, options))\n    },\n\n    async getStickerPacks() {\n      return await rest.get<DiscordStickerPack[]>(rest.routes.stickerPacks())\n    },\n\n    async getOriginalInteractionResponse(token) {\n      return await rest.get<DiscordMessage>(rest.routes.interactions.responses.original(rest.applicationId, token), { unauthorized: true })\n    },\n\n    async getPinnedMessages(channelId) {\n      return await rest.get<DiscordMessage[]>(rest.routes.channels.pins(channelId))\n    },\n\n    async getPrivateArchivedThreads(channelId, options) {\n      return await rest.get<DiscordListArchivedThreads>(rest.routes.channels.threads.private(channelId, options))\n    },\n\n    async getPrivateJoinedArchivedThreads(channelId, options) {\n      return await rest.get<DiscordListArchivedThreads>(rest.routes.channels.threads.joined(channelId, options))\n    },\n\n    async getPruneCount(guildId, options) {\n      return await rest.get<DiscordPrunedCount>(rest.routes.guilds.prune(guildId, options))\n    },\n\n    async getPublicArchivedThreads(channelId, options) {\n      return await rest.get<DiscordListArchivedThreads>(rest.routes.channels.threads.public(channelId, options))\n    },\n\n    async getRoles(guildId) {\n      return await rest.get<DiscordRole[]>(rest.routes.guilds.roles.all(guildId))\n    },\n\n    async getScheduledEvent(guildId, eventId, options) {\n      return await rest.get<DiscordScheduledEvent>(rest.routes.guilds.events.event(guildId, eventId, options?.withUserCount))\n    },\n\n    async getScheduledEvents(guildId, options) {\n      return await rest.get<DiscordScheduledEvent[]>(rest.routes.guilds.events.events(guildId, options?.withUserCount))\n    },\n\n    async getScheduledEventUsers(guildId, eventId, options) {\n      return await rest.get<Array<{ user: DiscordUser; member?: DiscordMember }>>(rest.routes.guilds.events.users(guildId, eventId, options))\n    },\n\n    async getSessionInfo() {\n      return await rest.getGatewayBot()\n    },\n\n    async getStageInstance(channelId) {\n      return await rest.get<DiscordStageInstance>(rest.routes.channels.stage(channelId))\n    },\n\n    async getSticker(stickerId: BigString) {\n      return await rest.get<DiscordSticker>(rest.routes.sticker(stickerId))\n    },\n\n    async getGuildSticker(guildId, stickerId) {\n      return await rest.get<DiscordSticker>(rest.routes.guilds.sticker(guildId, stickerId))\n    },\n\n    async getGuildStickers(guildId) {\n      return await rest.get<DiscordSticker[]>(rest.routes.guilds.stickers(guildId))\n    },\n\n    async getThreadMember(channelId, userId) {\n      return await rest.get<DiscordThreadMember>(rest.routes.channels.threads.user(channelId, userId))\n    },\n\n    async getThreadMembers(channelId) {\n      return await rest.get<DiscordThreadMember[]>(rest.routes.channels.threads.members(channelId))\n    },\n\n    async getReactions(channelId, messageId, reaction, options) {\n      return await rest.get<DiscordUser[]>(rest.routes.channels.reactions.message(channelId, messageId, reaction, options))\n    },\n\n    async getUser(id) {\n      return await rest.get<DiscordUser>(rest.routes.user(id))\n    },\n\n    async getCurrentUser(token) {\n      return await rest.get<DiscordUser>(rest.routes.currentUser(), {\n        headers: {\n          authorization: `Bearer ${token}`,\n        },\n        unauthorized: true,\n      })\n    },\n\n    async getUserConnections(token) {\n      return await rest.get<DiscordConnection[]>(rest.routes.oauth2.connections(), {\n        headers: {\n          authorization: `Bearer ${token}`,\n        },\n        unauthorized: true,\n      })\n    },\n\n    async getUserApplicationRoleConnection(token, applicationId) {\n      return await rest.get<DiscordApplicationRoleConnection>(rest.routes.oauth2.roleConnections(applicationId), {\n        headers: {\n          authorization: `Bearer ${token}`,\n        },\n        unauthorized: true,\n      })\n    },\n\n    async getVanityUrl(guildId) {\n      return await rest.get<DiscordVanityUrl>(rest.routes.guilds.vanity(guildId))\n    },\n\n    async getVoiceRegions(guildId) {\n      return await rest.get<DiscordVoiceRegion[]>(rest.routes.guilds.regions(guildId))\n    },\n\n    async getWebhook(webhookId) {\n      return await rest.get<DiscordWebhook>(rest.routes.webhooks.id(webhookId))\n    },\n\n    async getWebhookMessage(webhookId, token, messageId, options) {\n      return await rest.get<DiscordMessage>(rest.routes.webhooks.message(webhookId, token, messageId, options), {\n        unauthorized: true,\n      })\n    },\n\n    async getWebhookWithToken(webhookId, token) {\n      return await rest.get<DiscordWebhook>(rest.routes.webhooks.webhook(webhookId, token), {\n        unauthorized: true,\n      })\n    },\n\n    async getWelcomeScreen(guildId) {\n      return await rest.get<DiscordWelcomeScreen>(rest.routes.guilds.welcome(guildId))\n    },\n\n    async getWidget(guildId) {\n      return await rest.get<DiscordGuildWidget>(rest.routes.guilds.widgetJson(guildId))\n    },\n\n    async getWidgetSettings(guildId) {\n      return await rest.get<DiscordGuildWidgetSettings>(rest.routes.guilds.widget(guildId))\n    },\n\n    async joinThread(channelId) {\n      await rest.put(rest.routes.channels.threads.me(channelId))\n    },\n\n    async leaveGuild(guildId) {\n      await rest.delete(rest.routes.guilds.leave(guildId))\n    },\n\n    async leaveThread(channelId) {\n      await rest.delete(rest.routes.channels.threads.me(channelId))\n    },\n\n    async publishMessage(channelId, messageId) {\n      return await rest.post<DiscordMessage>(rest.routes.channels.crosspost(channelId, messageId))\n    },\n\n    async removeRole(guildId, userId, roleId, reason) {\n      await rest.delete(rest.routes.guilds.roles.member(guildId, userId, roleId), { reason })\n    },\n\n    async removeThreadMember(channelId, userId) {\n      await rest.delete(rest.routes.channels.threads.user(channelId, userId))\n    },\n\n    async removeDmRecipient(channelId, userId) {\n      await rest.delete(rest.routes.channels.dmRecipient(channelId, userId))\n    },\n\n    async sendFollowupMessage(token, options) {\n      return await rest.post(rest.routes.webhooks.webhook(rest.applicationId, token), {\n        body: options,\n        files: options.files,\n        unauthorized: true,\n      })\n    },\n\n    async sendInteractionResponse(interactionId, token, options) {\n      return await rest.post(rest.routes.interactions.responses.callback(interactionId, token), {\n        body: options,\n        files: options.data?.files,\n        runThroughQueue: false,\n        unauthorized: true,\n      })\n    },\n\n    async sendMessage(channelId, body) {\n      return await rest.post<DiscordMessage>(rest.routes.channels.messages(channelId), { body, files: body.files })\n    },\n\n    async startThreadWithMessage(channelId, messageId, body, reason) {\n      return await rest.post<DiscordChannel>(rest.routes.channels.threads.message(channelId, messageId), { body, reason })\n    },\n\n    async startThreadWithoutMessage(channelId, body, reason) {\n      return await rest.post<DiscordChannel>(rest.routes.channels.threads.all(channelId), { body, reason })\n    },\n\n    async getPollAnswerVoters(channelId, messageId, answerId, options) {\n      return await rest.get<DiscordGetAnswerVotesResponse>(rest.routes.channels.polls.votes(channelId, messageId, answerId, options))\n    },\n\n    async endPoll(channelId, messageId) {\n      return await rest.post<DiscordMessage>(rest.routes.channels.polls.expire(channelId, messageId))\n    },\n\n    async syncGuildTemplate(guildId) {\n      return await rest.put<DiscordTemplate>(rest.routes.guilds.templates.all(guildId))\n    },\n\n    async banMember(guildId, userId, body, reason) {\n      await rest.put<void>(rest.routes.guilds.members.ban(guildId, userId), { body, reason })\n    },\n\n    async bulkBanMembers(guildId, options, reason) {\n      return await rest.post<DiscordBulkBan>(rest.routes.guilds.members.bulkBan(guildId), { body: options, reason })\n    },\n\n    async editBotMember(guildId, body, reason) {\n      return await rest.patch<DiscordMember>(rest.routes.guilds.members.bot(guildId), { body, reason })\n    },\n\n    async editMember(guildId, userId, body, reason) {\n      return await rest.patch<DiscordMemberWithUser>(rest.routes.guilds.members.member(guildId, userId), { body, reason })\n    },\n\n    async getMember(guildId, userId) {\n      return await rest.get<DiscordMemberWithUser>(rest.routes.guilds.members.member(guildId, userId))\n    },\n\n    async getCurrentMember(guildId, token) {\n      return await rest.get<DiscordMemberWithUser>(rest.routes.guilds.members.currentMember(guildId), {\n        headers: {\n          authorization: `Bearer ${token}`,\n        },\n        unauthorized: true,\n      })\n    },\n\n    async getMembers(guildId, options) {\n      return await rest.get<DiscordMemberWithUser[]>(rest.routes.guilds.members.members(guildId, options))\n    },\n\n    async kickMember(guildId, userId, reason) {\n      await rest.delete(rest.routes.guilds.members.member(guildId, userId), {\n        reason,\n      })\n    },\n\n    async pinMessage(channelId, messageId, reason) {\n      await rest.put(rest.routes.channels.pin(channelId, messageId), { reason })\n    },\n\n    async pruneMembers(guildId, body, reason) {\n      return await rest.post<{ pruned: number | null }>(rest.routes.guilds.members.prune(guildId), { body, reason })\n    },\n\n    async searchMembers(guildId, query, options) {\n      return await rest.get<DiscordMemberWithUser[]>(rest.routes.guilds.members.search(guildId, query, options))\n    },\n\n    async getGuildOnboarding(guildId) {\n      return await rest.get<DiscordGuildOnboarding>(rest.routes.guilds.onboarding(guildId))\n    },\n\n    async editGuildOnboarding(guildId, options, reason) {\n      return await rest.put<DiscordGuildOnboarding>(rest.routes.guilds.onboarding(guildId), {\n        body: options,\n        reason,\n      })\n    },\n\n    async unbanMember(guildId, userId, reason) {\n      await rest.delete(rest.routes.guilds.members.ban(guildId, userId), { reason })\n    },\n\n    async unpinMessage(channelId, messageId, reason) {\n      await rest.delete(rest.routes.channels.pin(channelId, messageId), { reason })\n    },\n\n    async triggerTypingIndicator(channelId) {\n      await rest.post(rest.routes.channels.typing(channelId))\n    },\n\n    async upsertGlobalApplicationCommands(body, options) {\n      const restOptions: MakeRequestOptions = { body }\n\n      if (options?.bearerToken) {\n        restOptions.unauthorized = true\n        restOptions.headers = {\n          authorization: `Bearer ${options.bearerToken}`,\n        }\n      }\n\n      return await rest.put<DiscordApplicationCommand[]>(rest.routes.interactions.commands.commands(rest.applicationId), restOptions)\n    },\n\n    async upsertGuildApplicationCommands(guildId, body, options) {\n      const restOptions: MakeRequestOptions = { body }\n\n      if (options?.bearerToken) {\n        restOptions.unauthorized = true\n        restOptions.headers = {\n          authorization: `Bearer ${options.bearerToken}`,\n        }\n      }\n\n      return await rest.put<DiscordApplicationCommand[]>(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), restOptions)\n    },\n\n    async editUserApplicationRoleConnection(token, applicationId, body) {\n      return await rest.put<DiscordApplicationRoleConnection>(rest.routes.oauth2.roleConnections(applicationId), {\n        body,\n        headers: {\n          authorization: `Bearer ${token}`,\n        },\n        unauthorized: true,\n      })\n    },\n\n    async addGuildMember(guildId, userId, body) {\n      return await rest.put(rest.routes.guilds.members.member(guildId, userId), {\n        body,\n      })\n    },\n\n    async createTestEntitlement(applicationId, body) {\n      return await rest.post<DiscordEntitlement>(rest.routes.monetization.entitlements(applicationId), {\n        body,\n      })\n    },\n\n    async listEntitlements(applicationId, options) {\n      return await rest.get<DiscordEntitlement[]>(rest.routes.monetization.entitlements(applicationId, options))\n    },\n\n    async deleteTestEntitlement(applicationId, entitlementId) {\n      await rest.delete(rest.routes.monetization.entitlement(applicationId, entitlementId))\n    },\n\n    async consumeEntitlement(applicationId, entitlementId) {\n      await rest.post(rest.routes.monetization.consumeEntitlement(applicationId, entitlementId))\n    },\n\n    async listSkus(applicationId) {\n      return await rest.get<DiscordSku[]>(rest.routes.monetization.skus(applicationId))\n    },\n\n    preferSnakeCase(enabled: boolean) {\n      const camelizer = enabled ? (x: any) => x : camelize\n\n      rest.get = async (url, options) => {\n        return camelizer(await rest.makeRequest('GET', url, options))\n      }\n\n      rest.post = async (url: string, options?: Omit<CreateRequestBodyOptions, 'body' | 'method'>) => {\n        return camelizer(await rest.makeRequest('POST', url, options))\n      }\n\n      rest.delete = async (url: string, options?: Omit<CreateRequestBodyOptions, 'body' | 'method'>) => {\n        camelizer(await rest.makeRequest('DELETE', url, options))\n      }\n\n      rest.patch = async (url: string, options?: Omit<CreateRequestBodyOptions, 'body' | 'method'>) => {\n        return camelizer(await rest.makeRequest('PATCH', url, options))\n      }\n\n      rest.put = async (url: string, options?: Omit<CreateRequestBodyOptions, 'body' | 'method'>) => {\n        return camelizer(await rest.makeRequest('PUT', url, options))\n      }\n\n      return rest\n    },\n  }\n\n  return rest\n}\n\nenum HttpResponseCode {\n  /** Minimum value of a code in oder to consider that it was successful. */\n  Success = 200,\n  /** Request completed successfully, but Discord returned an empty body. */\n  NoContent = 204,\n  /** Minimum value of a code in order to consider that something went wrong. */\n  Error = 400,\n  /** This request got rate limited. */\n  TooManyRequests = 429,\n}\n"],"names":["AUDIT_LOG_REASON_HEADER","DISCORD_API_URL","DISCORD_API_VERSION","RATE_LIMIT_BUCKET_HEADER","RATE_LIMIT_GLOBAL_HEADER","RATE_LIMIT_LIMIT_HEADER","RATE_LIMIT_REMAINING_HEADER","RATE_LIMIT_RESET_AFTER_HEADER","RATE_LIMIT_SCOPE_HEADER","createRestManager","version","options","applicationId","BigInt","getBotIdFromToken","token","baseUrl","proxy","rest","authorization","authorizationHeader","deleteQueueDelay","globallyRateLimited","invalidBucket","createInvalidRequestBucket","logger","isProxied","startsWith","updateBearerTokenEndpoint","maxRetryCount","Infinity","processingRateLimitedPaths","queues","Map","rateLimitedPaths","routes","createRoutes","createBaseHeaders","checkRateLimits","url","identifier","ratelimited","get","global","now","Date","resetTimestamp","updateTokenQueues","oldToken","newToken","Error","headers","undefined","fetch","method","body","JSON","stringify","newIdentifier","key","queue","entries","delete","newKey","newQueue","waiting","unshift","pending","cleanup","set","ratelimitPath","bucketId","changeToDiscordFormat","obj","Array","isArray","map","item","newObj","Object","keys","includes","value","calculateBits","default_member_permissions","name_localizations","description_localizations","camelToSnakeCase","toString","createRequestBody","unauthorized","reason","encodeURIComponent","files","form","FormData","i","length","append","blob","name","formBody","discordBody","prop","push","join","assign","processRateLimitedPaths","size","setTimeout","processHeaders","rateLimited","remaining","retryAfter","reset","Number","limit","handleCompletedRequest","interval","max","globalReset","sendRequest","route","payload","requestBodyOptions","loggingHeaders","authorizationScheme","split","debug","response","catch","error","reject","ok","status","statusText","simplifyUrl","text","retryCount","resetAfter","delay","arrayBuffer","retryRequest","resolve","parts","secondLastPart","splice","processRequest","request","runThroughQueue","queueIdentifier","makeRequest","bucketQueue","Queue","result","err","json","message","Promise","data","parse","cause","camelize","post","patch","put","addReaction","channelId","messageId","reaction","processReactionString","channels","reactions","bot","addReactions","ordered","all","addRole","guildId","userId","roleId","guilds","roles","member","addThreadMember","threads","user","addDmRecipient","dmRecipient","createAutomodRule","automod","rules","createChannel","createEmoji","emojis","createApplicationEmoji","applicationEmojis","createGlobalApplicationCommand","restOptions","bearerToken","interactions","commands","createGuild","createGuildApplicationCommand","createGuildFromTemplate","templateCode","icon","urlToBase64","templates","code","createGuildSticker","file","description","tags","stickers","createGuildTemplate","createForumThread","forum","createInvite","invites","createRole","createScheduledEvent","events","createStageInstance","stages","createWebhook","webhooks","avatar","deleteAutomodRule","ruleId","rule","deleteChannel","channel","deleteChannelPermissionOverride","overwriteId","overwrite","deleteEmoji","id","emoji","deleteApplicationEmoji","applicationEmoji","deleteFollowupMessage","responses","deleteGlobalApplicationCommand","commandId","command","deleteGuild","guild","deleteGuildApplicationCommand","one","deleteGuildSticker","stickerId","sticker","deleteGuildTemplate","deleteIntegration","integrationId","integration","deleteInvite","inviteCode","invite","deleteMessage","deleteMessages","messageIds","bulk","messages","slice","deleteOriginalInteractionResponse","original","deleteOwnReaction","deleteReactionsAll","deleteReactionsEmoji","deleteRole","deleteScheduledEvent","eventId","event","deleteStageInstance","stage","deleteUserReaction","deleteWebhook","webhookId","deleteWebhookMessage","deleteWebhookWithToken","webhook","editApplicationCommandPermissions","permissions","permission","editAutomodRule","editBotProfile","botAvatarURL","banner","botBannerURL","currentUser","username","trim","editChannel","editChannelPermissionOverrides","editChannelPositions","editEmoji","editApplicationEmoji","editFollowupMessage","editGlobalApplicationCommand","editGuild","editGuildApplicationCommand","editGuildMfaLevel","mfaLevel","mfa","level","editGuildSticker","editGuildTemplate","editMessage","editOriginalInteractionResponse","editOriginalWebhookMessage","type","InteractionResponseTypes","UpdateMessage","editOwnVoiceState","voice","request_to_speak_timestamp","requestToSpeakTimestamp","toISOString","editScheduledEvent","editRole","editRolePositions","editStageInstance","topic","editUserVoiceState","editWebhook","editWebhookMessage","editWebhookWithToken","editWelcomeScreen","welcome","editWidgetSettings","widget","executeWebhook","followAnnouncement","sourceChannelId","targetChannelId","follow","webhook_channel_id","getActiveThreads","active","getApplicationCommandPermission","accessToken","getApplicationCommandPermissions","getApplicationInfo","oauth2","application","editApplicationInfo","getCurrentAuthenticationInfo","currentAuthorization","exchangeToken","clientId","clientSecret","basicCredentials","Buffer","from","grantType","scope","tokenExchange","revokeToken","tokenRevoke","getAuditLog","auditlogs","getAutomodRule","getAutomodRules","getAvailableVoiceRegions","regions","getBan","members","ban","getBans","bans","getChannel","getChannelInvites","getChannels","getChannelWebhooks","getDmChannel","dm","recipient_id","getGroupDmChannel","getEmoji","emojiId","getApplicationEmoji","getEmojis","getApplicationEmojis","getFollowupMessage","getGatewayBot","gatewayBot","getGlobalApplicationCommand","getGlobalApplicationCommands","getGuild","counts","getGuilds","makeRequestOptions","userGuilds","getGuildApplicationCommand","getGuildApplicationCommands","getGuildPreview","preview","getGuildTemplate","getGuildTemplates","getGuildWebhooks","getIntegrations","integrations","getInvite","getInvites","getMessage","getMessages","getStickerPacks","stickerPacks","getOriginalInteractionResponse","getPinnedMessages","pins","getPrivateArchivedThreads","private","getPrivateJoinedArchivedThreads","joined","getPruneCount","prune","getPublicArchivedThreads","public","getRoles","getScheduledEvent","withUserCount","getScheduledEvents","getScheduledEventUsers","users","getSessionInfo","getStageInstance","getSticker","getGuildSticker","getGuildStickers","getThreadMember","getThreadMembers","getReactions","getUser","getCurrentUser","getUserConnections","connections","getUserApplicationRoleConnection","roleConnections","getVanityUrl","vanity","getVoiceRegions","getWebhook","getWebhookMessage","getWebhookWithToken","getWelcomeScreen","getWidget","widgetJson","getWidgetSettings","joinThread","me","leaveGuild","leave","leaveThread","publishMessage","crosspost","removeRole","removeThreadMember","removeDmRecipient","sendFollowupMessage","sendInteractionResponse","interactionId","callback","sendMessage","startThreadWithMessage","startThreadWithoutMessage","getPollAnswerVoters","answerId","polls","votes","endPoll","expire","syncGuildTemplate","banMember","bulkBanMembers","bulkBan","editBotMember","editMember","getMember","getCurrentMember","currentMember","getMembers","kickMember","pinMessage","pin","pruneMembers","searchMembers","query","search","getGuildOnboarding","onboarding","editGuildOnboarding","unbanMember","unpinMessage","triggerTypingIndicator","typing","upsertGlobalApplicationCommands","upsertGuildApplicationCommands","editUserApplicationRoleConnection","addGuildMember","createTestEntitlement","monetization","entitlements","listEntitlements","deleteTestEntitlement","entitlementId","entitlement","consumeEntitlement","listSkus","skus","preferSnakeCase","enabled","camelizer","x","HttpResponseCode"],"mappings":"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"}