equipped 5.0.0-beta.9 → 5.0.0-rc.2

package/lib/validations/index.d.ts

@@ -1,29 +1,32 @@
 import * as Validate from 'valleyed';
+import { ExtractI } from 'valleyed/lib/api/base';
+import { VCore } from 'valleyed/lib/api/core';
+import { VObject } from 'valleyed/lib/api/objects';
 import { StorageFile } from '../storage';
 type Phone = {
     code: string;
     number: string;
 };
 export declare const Schema: {
-    is: <T>(value: T) => Validate.VCore<T>;
-    in: <T_1>(values: readonly T_1[], comparer?: ((val: any, arrayItem: T_1) => boolean) | undefined) => Validate.VCore<T_1>;
-    or: <T_2 extends Validate.VCore<any>[]>(options: T_2, err?: string | undefined) => import("valleyed/lib/api/junctions").VOr<T_2>;
+    is: <T>(value: T, comparer?: (val: any, comp: T) => boolean, err?: string) => Validate.VCore<T>;
+    in: <T>(values: Readonly<T[]>, comparer?: (val: any, arrayItem: T) => boolean, err?: string) => Validate.VCore<T>;
+    or: <T extends Validate.VCore<any>[]>(options: T, err?: string | undefined) => import("valleyed/lib/api/junctions").VOr<T>;
     and: <I>(options: Validate.VCore<I>[], err?: string | undefined) => import("valleyed/lib/api/junctions").VAnd<I>;
     string: (err?: string | undefined) => import("valleyed/lib/api/strings").VString;
     discriminate: <D extends Record<string, Validate.VCore<any>>>(discriminator: (val: import("valleyed/lib/api/base").ExtractI<D[keyof D]>) => string, schemas: D, err?: string | undefined) => import("valleyed/lib/api/junctions").VDiscriminator<D>;
     number: (err?: string | undefined) => import("valleyed/lib/api/numbers").VNumber;
     boolean: (err?: string | undefined) => import("valleyed/lib/api/booleans").VBoolean;
-    time: <T_3 extends Validate.Timeable = Validate.Timeable>(err?: string | undefined) => import("valleyed/lib/api/times").VTime<T_3>;
+    time: <T extends import("valleyed/lib/api/times").Timeable = import("valleyed/lib/api/times").Timeable>(err?: string | undefined) => import("valleyed/lib/api/times").VTime<T>;
     file: (err?: string | undefined) => import("valleyed/lib/api/files").VFile;
-    array: <I_1>(comparer: Validate.VCore<I_1>, err?: string | undefined) => import("valleyed/lib/api/arrays").VArray<I_1>;
-    tuple: <T_4 extends readonly Validate.VCore<any>[]>(schema: readonly [...T_4], err?: string | undefined) => import("valleyed/lib/api/tuples").VTuple<T_4>;
-    object: <T_5 extends Record<string, Validate.VCore<any>>>(schema: T_5, trim?: boolean | undefined, err?: string | undefined) => import("valleyed/lib/api/objects").VObject<T_5>;
+    array: <I>(comparer: Validate.VCore<I>, err?: string | undefined) => import("valleyed/lib/api/arrays").VArray<I>;
+    tuple: <T extends ReadonlyArray<Validate.VCore<any>>>(schema: readonly [...T], err?: string | undefined) => import("valleyed/lib/api/tuples").VTuple<T>;
+    object: <T extends Record<string, Validate.VCore<any>>>(schema: T, trim?: boolean | undefined, err?: string | undefined) => VObject<T>;
     record: <VI>(vCom: Validate.VCore<VI>, err?: string | undefined) => import("valleyed/lib/api/records").VRecord<VI>;
-    map: <KI, VI_1>(kCom: Validate.VCore<KI>, vCom: Validate.VCore<VI_1>, err?: string | undefined) => import("valleyed/lib/api/records").VMap<KI, VI_1>;
-    null: (err?: string | undefined) => Validate.VCore<null>;
-    undefined: (err?: string | undefined) => Validate.VCore<undefined>;
-    instanceof: <T_6>(classDef: new () => T_6, err?: string | undefined) => Validate.VCore<T_6>;
-    any: <T_7 = any>() => Validate.VCore<T_7>;
+    map: <KI, VI>(kCom: Validate.VCore<KI>, vCom: Validate.VCore<VI>, err?: string | undefined) => import("valleyed/lib/api/records").VMap<KI, VI>;
+    null: (err?: string) => Validate.VCore<null>;
+    undefined: (err?: string) => Validate.VCore<undefined>;
+    instanceof: <T>(classDef: new () => T, err?: string) => Validate.VCore<T>;
+    any: <T = any>() => Validate.VCore<T>;
     force: {
         string: (err?: string | undefined) => import("valleyed/lib/api/strings").VString;
         number: (err?: string | undefined) => import("valleyed/lib/api/numbers").VNumber;
@@ -37,25 +40,25 @@ export declare const Validation: {
     Validator: typeof Validate.Validator;
     VCore: typeof Validate.VCore;
     v: {
-        is: <T>(value: T) => Validate.VCore<T>;
-        in: <T_1>(values: readonly T_1[], comparer?: ((val: any, arrayItem: T_1) => boolean) | undefined) => Validate.VCore<T_1>;
-        or: <T_2 extends Validate.VCore<any>[]>(options: T_2, err?: string | undefined) => import("valleyed/lib/api/junctions").VOr<T_2>;
+        is: <T>(value: T, comparer?: (val: any, comp: T) => boolean, err?: string) => Validate.VCore<T>;
+        in: <T>(values: Readonly<T[]>, comparer?: (val: any, arrayItem: T) => boolean, err?: string) => Validate.VCore<T>;
+        or: <T extends Validate.VCore<any>[]>(options: T, err?: string | undefined) => import("valleyed/lib/api/junctions").VOr<T>;
         and: <I>(options: Validate.VCore<I>[], err?: string | undefined) => import("valleyed/lib/api/junctions").VAnd<I>;
         string: (err?: string | undefined) => import("valleyed/lib/api/strings").VString;
         discriminate: <D extends Record<string, Validate.VCore<any>>>(discriminator: (val: import("valleyed/lib/api/base").ExtractI<D[keyof D]>) => string, schemas: D, err?: string | undefined) => import("valleyed/lib/api/junctions").VDiscriminator<D>;
         number: (err?: string | undefined) => import("valleyed/lib/api/numbers").VNumber;
         boolean: (err?: string | undefined) => import("valleyed/lib/api/booleans").VBoolean;
-        time: <T_3 extends Validate.Timeable = Validate.Timeable>(err?: string | undefined) => import("valleyed/lib/api/times").VTime<T_3>;
+        time: <T extends import("valleyed/lib/api/times").Timeable = import("valleyed/lib/api/times").Timeable>(err?: string | undefined) => import("valleyed/lib/api/times").VTime<T>;
         file: (err?: string | undefined) => import("valleyed/lib/api/files").VFile;
-        array: <I_1>(comparer: Validate.VCore<I_1>, err?: string | undefined) => import("valleyed/lib/api/arrays").VArray<I_1>;
-        tuple: <T_4 extends readonly Validate.VCore<any>[]>(schema: readonly [...T_4], err?: string | undefined) => import("valleyed/lib/api/tuples").VTuple<T_4>;
-        object: <T_5 extends Record<string, Validate.VCore<any>>>(schema: T_5, trim?: boolean | undefined, err?: string | undefined) => import("valleyed/lib/api/objects").VObject<T_5>;
+        array: <I>(comparer: Validate.VCore<I>, err?: string | undefined) => import("valleyed/lib/api/arrays").VArray<I>;
+        tuple: <T extends ReadonlyArray<Validate.VCore<any>>>(schema: readonly [...T], err?: string | undefined) => import("valleyed/lib/api/tuples").VTuple<T>;
+        object: <T extends Record<string, Validate.VCore<any>>>(schema: T, trim?: boolean | undefined, err?: string | undefined) => VObject<T>;
         record: <VI>(vCom: Validate.VCore<VI>, err?: string | undefined) => import("valleyed/lib/api/records").VRecord<VI>;
-        map: <KI, VI_1>(kCom: Validate.VCore<KI>, vCom: Validate.VCore<VI_1>, err?: string | undefined) => import("valleyed/lib/api/records").VMap<KI, VI_1>;
-        null: (err?: string | undefined) => Validate.VCore<null>;
-        undefined: (err?: string | undefined) => Validate.VCore<undefined>;
-        instanceof: <T_6>(classDef: new () => T_6, err?: string | undefined) => Validate.VCore<T_6>;
-        any: <T_7 = any>() => Validate.VCore<T_7>;
+        map: <KI, VI>(kCom: Validate.VCore<KI>, vCom: Validate.VCore<VI>, err?: string | undefined) => import("valleyed/lib/api/records").VMap<KI, VI>;
+        null: (err?: string) => Validate.VCore<null>;
+        undefined: (err?: string) => Validate.VCore<undefined>;
+        instanceof: <T>(classDef: new () => T, err?: string) => Validate.VCore<T>;
+        any: <T = any>() => Validate.VCore<T>;
         force: {
             string: (err?: string | undefined) => import("valleyed/lib/api/strings").VString;
             number: (err?: string | undefined) => import("valleyed/lib/api/numbers").VNumber;
@@ -63,48 +66,47 @@ export declare const Validation: {
             time: (err?: string | undefined) => import("valleyed/lib/api/times").VTime<Date>;
         };
     };
-    isEqualTo: <Type>(compare: Type, comparer?: ((val: any, compare: Type) => boolean) | undefined, error?: string | undefined) => Validate.Rule<Type>;
-    isNotEqualTo: <Compare, Type_1>(compare: Compare, comparer?: ((val: Type_1, compare: Compare) => boolean) | undefined, error?: string | undefined) => Validate.Rule<Type_1>;
-    arrayContains: <Type_2>(array: readonly Type_2[], comparer?: ((val: any, arrayItem: Type_2) => boolean) | undefined, error?: string | undefined) => Validate.Rule<Type_2>;
-    arrayNotContains: <Compare_1, Type_3>(array: readonly Compare_1[], comparer?: ((val: Type_3, arrayItem: Compare_1) => boolean) | undefined, error?: string | undefined) => Validate.Rule<Type_3>;
-    isString: (error?: string | undefined) => Validate.Rule<any>;
-    isLengthOf: (length: number, stripHTMLTags?: boolean | undefined, error?: string | undefined) => Validate.Rule<string>;
-    isMinOf: (length: number, stripHTMLTags?: boolean | undefined, error?: string | undefined) => Validate.Rule<string>;
-    isMaxOf: (length: number, stripHTMLTags?: boolean | undefined, error?: string | undefined) => Validate.Rule<string>;
-    isEmail: (error?: string | undefined) => Validate.Rule<string>;
-    isUrl: (error?: string | undefined) => Validate.Rule<string>;
-    isNumber: (error?: string | undefined) => Validate.Rule<any>;
-    isInt: (error?: string | undefined) => Validate.Rule<any>;
-    isMoreThan: (compare: number, error?: string | undefined) => Validate.Rule<number>;
-    isMoreThanOrEqualTo: (compare: number, error?: string | undefined) => Validate.Rule<number>;
-    isLessThan: (compare: number, error?: string | undefined) => Validate.Rule<number>;
-    isLessThanOrEqualTo: (compare: number, error?: string | undefined) => Validate.Rule<number>;
-    isArray: (error?: string | undefined) => Validate.Rule<any>;
-    hasLengthOf: <Type_4>(length: number, error?: string | undefined) => Validate.Rule<Type_4[]>;
-    hasMinOf: <Type_5>(length: number, error?: string | undefined) => Validate.Rule<Type_5[]>;
-    hasMaxOf: <Type_6>(length: number, error?: string | undefined) => Validate.Rule<Type_6[]>;
-    isArrayOf: <Type_7>(comparer: (cur: Type_7, idx: number) => boolean, error?: string | undefined) => Validate.Rule<Type_7[]>;
-    isUndefined: (error?: string | undefined) => Validate.Rule<undefined>;
-    isNull: (error?: string | undefined) => Validate.Rule<null>;
-    isBoolean: (error?: string | undefined) => Validate.Rule<boolean>;
-    isInstanceOf: <T>(classDef: new () => T, error?: string | undefined) => Validate.Rule<T>;
+    isEqualTo: <Type>(compare: Type, comparer?: (val: any, compare: Type) => boolean, error?: string) => import("valleyed/lib/utils/rules").Rule<Type>;
+    isNotEqualTo: <Compare, Type>(compare: Compare, comparer?: (val: Type, compare: Compare) => boolean, error?: string) => import("valleyed/lib/utils/rules").Rule<Type>;
+    arrayContains: <Type>(array: Readonly<Type[]>, comparer?: (val: any, arrayItem: Type) => boolean, error?: string) => import("valleyed/lib/utils/rules").Rule<Type>;
+    arrayNotContains: <Compare, Type>(array: Readonly<Compare[]>, comparer?: (val: Type, arrayItem: Compare) => boolean, error?: string) => import("valleyed/lib/utils/rules").Rule<Type>;
+    isString: (error?: string) => import("valleyed/lib/utils/rules").Rule<any>;
+    isLengthOf: (length: number, stripHTMLTags?: boolean, error?: string) => import("valleyed/lib/utils/rules").Rule<string>;
+    isMinOf: (length: number, stripHTMLTags?: boolean, error?: string) => import("valleyed/lib/utils/rules").Rule<string>;
+    isMaxOf: (length: number, stripHTMLTags?: boolean, error?: string) => import("valleyed/lib/utils/rules").Rule<string>;
+    isEmail: (error?: string) => import("valleyed/lib/utils/rules").Rule<string>;
+    isUrl: (error?: string) => import("valleyed/lib/utils/rules").Rule<string>;
+    isNumber: (error?: string) => import("valleyed/lib/utils/rules").Rule<any>;
+    isInt: (error?: string) => import("valleyed/lib/utils/rules").Rule<any>;
+    isMoreThan: (compare: number, error?: string) => import("valleyed/lib/utils/rules").Rule<number>;
+    isMoreThanOrEqualTo: (compare: number, error?: string) => import("valleyed/lib/utils/rules").Rule<number>;
+    isLessThan: (compare: number, error?: string) => import("valleyed/lib/utils/rules").Rule<number>;
+    isLessThanOrEqualTo: (compare: number, error?: string) => import("valleyed/lib/utils/rules").Rule<number>;
+    isArray: (error?: string) => import("valleyed/lib/utils/rules").Rule<any>;
+    hasLengthOf: <Type>(length: number, error?: string) => import("valleyed/lib/utils/rules").Rule<Type[]>;
+    hasMinOf: <Type>(length: number, error?: string) => import("valleyed/lib/utils/rules").Rule<Type[]>;
+    hasMaxOf: <Type>(length: number, error?: string) => import("valleyed/lib/utils/rules").Rule<Type[]>;
+    isArrayOf: <Type>(comparer: (cur: Type, idx: number) => boolean, error?: string) => import("valleyed/lib/utils/rules").Rule<Type[]>;
+    isUndefined: (error?: string) => import("valleyed/lib/utils/rules").Rule<undefined>;
+    isNull: (error?: string) => import("valleyed/lib/utils/rules").Rule<null>;
+    isBoolean: (error?: string) => import("valleyed/lib/utils/rules").Rule<boolean>;
+    isInstanceOf: <T>(classDef: new () => T, error?: string) => import("valleyed/lib/utils/rules").Rule<T>;
     fileMimeTypes: string[];
     videoMimeTypes: string[];
     audioMimeTypes: string[];
     imageMimeTypes: string[];
-    isImage: (error?: string | undefined) => Validate.Rule<import("valleyed/lib/types").File>;
-    isAudio: (error?: string | undefined) => Validate.Rule<import("valleyed/lib/types").File>;
-    isVideo: (error?: string | undefined) => Validate.Rule<import("valleyed/lib/types").File>;
-    isFile: (error?: string | undefined) => Validate.Rule<import("valleyed/lib/types").File>;
-    isTuple: <T_1 extends readonly ((v: any, idx: number) => boolean)[]>(comparer: readonly [...T_1], error?: string | undefined) => Validate.Rule<{ [K in keyof T_1]: T_1[K] extends (v: infer V, idx: number) => boolean ? V : never; }>;
-    isRecord: <V_1>(com: (cur: V_1) => boolean, error?: string | undefined) => Validate.Rule<Record<string, V_1>>;
-    isMap: <K_1, V_2>(kCom: (cur: K_1) => boolean, vCom: (cur: V_2) => boolean, error?: string | undefined) => Validate.Rule<Map<K_1, V_2>>;
-    isCustom: <T_8>(validity: (v: T_8) => boolean, error?: string | undefined) => Validate.Rule<T_8>;
-    isTime: <T_9 extends Validate.Timeable>(error?: string | undefined) => Validate.Rule<T_9>;
-    isLaterThan: <T_10 extends Validate.Timeable>(compare: Validate.Timeable, error?: string | undefined) => Validate.Rule<T_10>;
-    isEarlierThan: <T_11 extends Validate.Timeable>(compare: Validate.Timeable, error?: string | undefined) => Validate.Rule<T_11>;
+    isImage: (error?: string) => import("valleyed/lib/utils/rules").Rule<import("valleyed/lib/types").File>;
+    isAudio: (error?: string) => import("valleyed/lib/utils/rules").Rule<import("valleyed/lib/types").File>;
+    isVideo: (error?: string) => import("valleyed/lib/utils/rules").Rule<import("valleyed/lib/types").File>;
+    isFile: (error?: string) => import("valleyed/lib/utils/rules").Rule<import("valleyed/lib/types").File>;
+    isTuple: <T extends ReadonlyArray<(v: any, idx: number) => boolean>>(comparer: Validate.GetMap<T>, error?: string) => import("valleyed/lib/utils/rules").Rule<{ [K in keyof T]: T[K] extends (v: infer V, idx: number) => boolean ? V : never; }>;
+    isRecord: <V>(com: (cur: V) => boolean, error?: string) => import("valleyed/lib/utils/rules").Rule<Record<string, V>>;
+    isMap: <K, V>(kCom: (cur: K) => boolean, vCom: (cur: V) => boolean, error?: string) => import("valleyed/lib/utils/rules").Rule<Map<K, V>>;
+    isCustom: <T>(validity: (v: T) => boolean, error?: string) => import("valleyed/lib/utils/rules").Rule<T>;
+    isTime: <T extends Validate.Timeable>(error?: string) => import("valleyed/lib/utils/rules").Rule<T>;
+    isLaterThan: <T extends Validate.Timeable>(compare: Validate.Timeable, error?: string) => import("valleyed/lib/utils/rules").Rule<T>;
+    isEarlierThan: <T extends Validate.Timeable>(compare: Validate.Timeable, error?: string) => import("valleyed/lib/utils/rules").Rule<T>;
     ClassPropertiesWrapper: typeof Validate.ClassPropertiesWrapper;
-    A: typeof Validate.A;
     Differ: typeof Validate.Differ;
     capitalize: (text: string) => string;
     stripHTML: (html: string) => string;
@@ -113,48 +115,40 @@ export declare const Validation: {
         original: string;
         normalized: string;
     }[];
-    formatNumber: (num: number, dp?: number | undefined) => string;
+    formatNumber: (num: number, dp?: number) => string;
     pluralize: (count: number, singular: string, plural: string) => string;
     getRandomValue: () => string;
-    groupBy: <Type_8, Unique extends string | number>(array: Type_8[], func: (item: Type_8) => Unique) => {
+    groupBy: <Type, Unique extends string | number>(array: Array<Type>, func: (item: Type) => Unique) => {
         key: Unique;
-        values: Type_8[];
+        values: Type[];
     }[];
     getAlphabet: (num: number) => string;
-    addToArray: <T_12>(array: T_12[], item: T_12, getKey: (a: T_12) => any, getComparer: (a: T_12) => string | number, asc?: boolean | undefined) => T_12[];
+    addToArray: <T>(array: T[], item: T, getKey: (a: T) => any, getComparer: (a: T) => number | string, asc?: boolean) => T[];
     divideByZero: (num: number, den: number) => number;
     getPercentage: (num: number, den: number) => number;
-    getRandomSample: <Type_9>(population: Type_9[], n: number) => Type_9[];
-    shuffleArray: <Type_10>(array: Type_10[]) => Type_10[];
-    chunkArray: <T_13>(arr: T_13[], size: number) => T_13[][];
+    getRandomSample: <Type>(population: Array<Type>, n: number) => Type[];
+    shuffleArray: <Type>(array: Array<Type>) => Type[];
+    chunkArray: <T>(arr: T[], size: number) => T[][];
+    wrapInTryCatch: <T>(fn: () => T, defaultValue?: T) => T | undefined;
     Geohash: typeof Validate.Geohash;
-    isValid: <T_14>(value: T_14, ignored?: boolean | undefined) => {
+    isValid: <T>(value: T, ignored?: boolean) => {
         valid: true;
         errors: string[];
-        value: T_14;
+        value: T;
         ignored: boolean;
     };
-    isInvalid: <T_15>(errors: string[], value: T_15) => {
+    isInvalid: <T>(errors: string[], value: T) => {
         valid: false;
         errors: string[];
         value: unknown;
         ignored: boolean;
     };
-    makeRule: <T_16>(func: Validate.Rule<T_16>) => Validate.Rule<T_16>;
-    makeSanitizer: <T_17>(func: Validate.Sanitizer<T_17>) => (val: T_17) => T_17;
-    check: <T_18>(value: T_18, rules: Validate.Rule<T_18>[], options?: Partial<Validate.Options> | undefined) => {
-        valid: false;
-        errors: string[];
-        value: unknown;
-        ignored: boolean;
-    } | {
-        valid: true;
-        errors: string[];
-        value: T_18;
-        ignored: boolean;
-    };
+    makeRule: <T>(func: Validate.Rule<T>) => Validate.Rule<T>;
+    makeSanitizer: <T>(func: Validate.Sanitizer<T>) => (val: T) => T;
+    check: <T>(value: T, rules: Validate.Rule<T>[], options?: Partial<Validate.Options>) => ReturnType<Validate.Rule<T>>;
 };
-export declare const validate: <T extends Record<string, Validate.VCore<any>>, S extends Validate.VCore<any> = Validate.VCore<any>>(schema: T | S, value: unknown) => any;
+export declare function validate<T extends Record<string, VCore<any>>>(schema: T, value: unknown): ExtractI<VObject<T>>;
+export declare function validate<T extends VCore<any>>(schema: T, value: unknown): ExtractI<T>;
 export declare const Hash: {
     hash: (password: string) => Promise<string>;
     compare: (plainPassword: string, hashed: string) => Promise<boolean>;

package/lib/validations/index.js

@@ -23,7 +23,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hash = exports.validate = exports.Validation = exports.Schema = void 0;
+exports.Hash = exports.Validation = exports.Schema = void 0;
+exports.validate = validate;
 const bcrypt = __importStar(require("bcryptjs"));
 const Validate = __importStar(require("valleyed"));
 const errors_1 = require("../errors");
@@ -47,7 +48,7 @@ const file = Validate.v.file;
 Validate.v.file = (...args) => file(...args).addRule(isNotTruncated());
 exports.Schema = Validate.v;
 exports.Validation = { ...Validate, isNotTruncated, isValidPhone };
-const validate = (schema, value) => {
+function validate(schema, value) {
     const validator = schema instanceof Validate.VCore ? schema : Validate.v.object(schema);
     const validity = validator.parse(value);
     if (validity.valid)
@@ -66,8 +67,7 @@ const validate = (schema, value) => {
     }), {});
     throw new errors_1.ValidationError(Object.entries(errorsObject)
         .map(([key, value]) => ({ field: key, messages: value })));
-};
-exports.validate = validate;
+}
 const hash = async (password) => {
     password = password.trim();
     if (!password)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "equipped",
-	"version": "5.0.0-beta.9",
+	"version": "5.0.0-rc.2",
 	"private": false,
 	"description": "",
 	"main": "lib/index.js",
@@ -18,7 +18,7 @@
 	"devDependencies": {
 		"@commitlint/cli": "^19.3.0",
 		"@commitlint/config-conventional": "^19.2.2",
-		"@stylistic/eslint-plugin": "^2.1.0",
+		"@stylistic/eslint-plugin": "^2.4.0",
 		"@types/amqplib": "^0.10.5",
 		"@types/bcryptjs": "^2.4.6",
 		"@types/bull": "^3.15.9",
@@ -26,63 +26,62 @@
 		"@types/express": "^4.17.21",
 		"@types/express-fileupload": "^1.5.0",
 		"@types/jsonwebtoken": "^9.0.6",
-		"@types/node": "^20.12.12",
+		"@types/node": "^22.0.0",
 		"@types/pug": "^2.0.10",
 		"@types/supertest": "^6.0.2",
-		"@typescript-eslint/eslint-plugin": "^7.10.0",
-		"@typescript-eslint/parser": "^7.10.0",
-		"eslint": "^9.3.0",
-		"eslint-plugin-promise": "^6.1.1",
-		"husky": "^9.0.11",
+		"@typescript-eslint/eslint-plugin": "^7.18.0",
+		"@typescript-eslint/parser": "^7.18.0",
+		"eslint": "^9.8.0",
+		"eslint-plugin-promise": "^7.0.0",
+		"husky": "^9.1.4",
 		"standard-version": "^9.5.0",
-		"typescript": "^5.4.5"
+		"typescript": "^5.5.4"
 	},
 	"dependencies": {
 		"@fastify/cookie": "^9.3.1",
 		"@fastify/cors": "^9.0.1",
 		"@fastify/formbody": "^7.4.0",
 		"@fastify/helmet": "^11.1.1",
-		"@fastify/multipart": "^8.2.0",
+		"@fastify/multipart": "^8.3.0",
 		"@fastify/rate-limit": "^9.1.0",
 		"@fastify/static": "^7.0.4",
-		"@fastify/swagger": "^8.14.0",
-		"@fastify/swagger-ui": "^3.0.0",
-		"@wesleytodd/openapi": "^1.0.0",
+		"@fastify/swagger": "^8.15.0",
+		"@wesleytodd/openapi": "^1.1.0",
 		"amqp-connection-manager": "^4.1.14",
 		"amqplib": "^0.10.4",
 		"axios": "^1.7.2",
 		"bcryptjs": "^2.4.3",
-		"bull": "^4.12.9",
+		"bull": "^4.16.0",
 		"cookie-parser": "^1.4.6",
 		"cors": "^2.8.5",
 		"dotenv": "^16.4.5",
 		"express": "^4.19.2",
-		"express-fileupload": "^1.5.0",
-		"express-rate-limit": "^7.2.0",
+		"express-fileupload": "^1.5.1",
+		"express-rate-limit": "^7.4.0",
 		"express-slow-down": "^2.0.3",
-		"fastify": "^4.27.0",
+		"fastify": "^4.28.1",
 		"fastify-slow-down": "^1.2.2",
 		"helmet": "^7.1.0",
 		"json-schema-resolver": "^2.0.0",
 		"jsonwebtoken": "^9.0.2",
 		"jwks-rsa": "^3.1.0",
 		"kafkajs": "^2.2.4",
-		"mongoose": "^8.4.0",
+		"mongoose": "^8.5.2",
 		"mongoose-lean-defaults": "^2.2.1",
 		"mongoose-lean-getters": "^2.1.0",
 		"mongoose-lean-virtuals": "^0.9.1",
 		"music-metadata": "^7.14.0",
 		"openapi-types": "^12.1.3",
-		"path-to-regexp": "^6.2.2",
-		"pino": "^9.1.0",
-		"pino-http": "^10.1.0",
+		"path-to-regexp": "^7.1.0",
+		"pino": "^9.3.2",
+		"pino-http": "^10.2.0",
 		"pug": "^3.0.3",
-		"qs": "^6.12.1",
-		"redis": "^4.6.14",
+		"qs": "^6.12.3",
+		"redis": "^4.7.0",
 		"socket.io": "4.7.5",
 		"supertest": "^7.0.0",
-		"ts-oas": "^0.4.1",
-		"valleyed": "4.2.11"
+		"ts-oas": "^0.4.4",
+		"valleyed": "4.3.1"
 	},
 	"repository": {
 		"url": "git://github.com/kevinand11/equipped.git"