equipped 4.0.0-alpha-10

package/lib/mongoose/query.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQueryParams = exports.Conditions = exports.QueryKeys = void 0;
+const instance_1 = require("../instance");
+var QueryKeys;
+(function (QueryKeys) {
+    QueryKeys["and"] = "and";
+    QueryKeys["or"] = "or";
+})(QueryKeys = exports.QueryKeys || (exports.QueryKeys = {}));
+var Conditions;
+(function (Conditions) {
+    Conditions["lt"] = "lt";
+    Conditions["lte"] = "lte";
+    Conditions["gt"] = "gt";
+    Conditions["gte"] = "gte";
+    Conditions["eq"] = "eq";
+    Conditions["ne"] = "ne";
+    Conditions["in"] = "in";
+    Conditions["nin"] = "nin";
+    Conditions["exists"] = "exists";
+})(Conditions = exports.Conditions || (exports.Conditions = {}));
+const parseQueryParams = async (collection, params) => {
+    const query = [];
+    const whereType = Object.values(QueryKeys).indexOf(params.whereType) !== -1 ? params.whereType : QueryKeys.and;
+    const authType = Object.values(QueryKeys).indexOf(params.authType) !== -1 ? params.authType : QueryKeys.and;
+    const where = buildWhereQuery(params.where ?? [], whereType);
+    if (where)
+        query.push(where);
+    const auth = buildWhereQuery(params.auth ?? [], authType);
+    if (auth)
+        query.push(auth);
+    if (params.search && params.search.fields.length > 0) {
+        const search = params.search.fields.map((field) => ({
+            [field]: {
+                $regex: new RegExp(params.search.value, 'i')
+            }
+        }));
+        query.push({ $or: search });
+    }
+    const totalClause = {};
+    if (query.length > 0)
+        totalClause['$and'] = query;
+    const sort = params.sort?.map((p) => [p.field, p.desc ? 'desc' : 'asc']) ?? [];
+    const all = params.all ?? false;
+    const settings = instance_1.Instance.get().settings;
+    const limit = Number(params.limit) <= settings.paginationDefaultLimit ? Number(params.limit) : settings.paginationDefaultLimit;
+    let page = Number.isNaN(Number(params.page)) ? 0 : Number(params.page);
+    page = page < 1 ? 1 : page;
+    const total = await collection.countDocuments(totalClause).exec();
+    let builtQuery = collection.find(totalClause);
+    if (sort.length)
+        builtQuery = builtQuery.sort(Object.fromEntries(sort));
+    if (!all && limit) {
+        builtQuery = builtQuery.limit(limit);
+        if (page)
+            builtQuery = builtQuery.skip((page - 1) * limit);
+    }
+    const results = await builtQuery.exec();
+    const start = 1;
+    const last = Math.ceil(total / limit) || 1;
+    const next = page >= last ? null : page + 1;
+    const previous = page <= start ? null : page - 1;
+    return {
+        pages: {
+            start, last, next, previous, current: page
+        },
+        docs: {
+            limit, total, count: results.length
+        },
+        results: results.map((r) => r.toJSON())
+    };
+};
+exports.parseQueryParams = parseQueryParams;
+const buildWhereQuery = (params, key = QueryKeys.and) => {
+    const where = params.map((param) => {
+        if (Object.values(QueryKeys).includes(param.condition))
+            return buildWhereQuery(param.value, param.condition);
+        const { field } = param;
+        const checkedField = field === 'id' ? '_id' : (field ?? '');
+        const checkedValue = param.value === undefined ? '' : param.value;
+        const checkedCondition = Object.keys(Conditions).indexOf(param.condition) > -1 ? param.condition : Conditions.eq;
+        return ({
+            field: checkedField,
+            value: checkedValue,
+            condition: checkedCondition,
+            isWhere: true
+        });
+    }).filter((c) => c).map((c) => {
+        if (c.isWhere)
+            return {
+                [`${c.field}`]: { [`$${c.condition}`]: c.value }
+            };
+        else
+            return c;
+    });
+    return where.length > 0 ? { [`$${key}`]: where } : null;
+};

package/lib/storage/index.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+export interface StorageFile {
+    name: string;
+    type: string;
+    size: number;
+    isTruncated: boolean;
+    data: Buffer;
+    duration: number;
+}
+export interface MediaOutput {
+    name: string;
+    type: string;
+    size: number;
+    path: string;
+    timestamp: number;
+    link: string;
+    duration: number;
+}

package/lib/storage/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/structure/baseEntity.d.ts

@@ -0,0 +1,5 @@
+export declare class BaseEntity {
+    hash: string;
+    constructor();
+    toJSON(): Record<string, any>;
+}

package/lib/structure/baseEntity.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEntity = void 0;
+const utils_1 = require("../utils/utils");
+class BaseEntity {
+    constructor() {
+        this.hash = utils_1.Random.string();
+    }
+    toJSON() {
+        const json = Object.assign({}, this);
+        const proto = Object.getPrototypeOf(this);
+        Object.getOwnPropertyNames(proto)
+            .filter((k) => k !== 'constructor')
+            .forEach((key) => {
+            const value = this[key];
+            json[key] = value?.toJSON?.() ?? value;
+        });
+        return json;
+    }
+}
+exports.BaseEntity = BaseEntity;

package/lib/structure/baseMapper.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class BaseMapper<From, To, Entity> {
+    abstract mapFrom(param: From | null): Entity | null;
+    abstract mapTo(param: Entity): To;
+}

package/lib/structure/baseMapper.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseMapper = void 0;
+class BaseMapper {
+}
+exports.BaseMapper = BaseMapper;

package/lib/structure/index.d.ts

@@ -0,0 +1,2 @@
+export * from './baseEntity';
+export * from './baseMapper';

package/lib/structure/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./baseEntity"), exports);
+__exportStar(require("./baseMapper"), exports);

package/lib/utils/auth.d.ts

@@ -0,0 +1,28 @@
+export declare const signinWithGoogle: (idToken: string) => Promise<{
+    email: string;
+    email_verified: 'true' | 'false';
+    first_name: string;
+    last_name: string;
+    picture: string;
+    sub: string;
+} & Record<string, any>>;
+export declare const signinWithApple: (idToken: string) => Promise<{
+    email?: string | undefined;
+    sub: string;
+    email_verified?: "false" | "true" | undefined;
+    is_private_email?: "false" | "true" | undefined;
+} & Record<string, any>>;
+export declare const signinWithFacebook: (accessToken: string, fields?: string[]) => Promise<{
+    id: string;
+    email: string;
+    email_verified: 'true' | 'false';
+    name: string;
+    picture: {
+        data: {
+            height: number;
+            is_silhouette: boolean;
+            url: string;
+            width: number;
+        };
+    };
+} & Record<string, any>>;

package/lib/utils/auth.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signinWithFacebook = exports.signinWithApple = exports.signinWithGoogle = void 0;
+const axios_1 = __importDefault(require("axios"));
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const jwks_rsa_1 = __importDefault(require("jwks-rsa"));
+const signinWithGoogle = async (idToken) => {
+    const authUrl = `https://oauth2.googleapis.com/tokeninfo?id_token=${idToken}`;
+    const { data } = await axios_1.default.get(authUrl).catch((err) => {
+        const message = err?.response?.data?.error;
+        throw new Error(message ? 'Invalid id token' : 'Something unexpected happened');
+    });
+    data.first_name = data.given_name;
+    data.last_name = data.family_name;
+    return data;
+};
+exports.signinWithGoogle = signinWithGoogle;
+const signinWithApple = async (idToken) => {
+    try {
+        const APPLE_BASE = 'https://appleid.apple.com';
+        const json = jsonwebtoken_1.default.decode(idToken, { complete: true });
+        if (!json?.header)
+            throw new Error('');
+        const { kid, alg } = json.header;
+        const publicKey = await (0, jwks_rsa_1.default)({ jwksUri: `${APPLE_BASE}/auth/keys`, cache: true })
+            .getSigningKey(kid).then((key) => key.getPublicKey()).catch(() => null);
+        if (!publicKey)
+            throw new Error('');
+        const data = jsonwebtoken_1.default.verify(idToken, publicKey, { algorithms: [alg] });
+        if (!data)
+            throw new Error('');
+        if (data.iss !== APPLE_BASE)
+            throw new Error('');
+        if (data.exp * 1000 < Date.now())
+            throw new Error('expired idToken');
+        return data;
+    }
+    catch (err) {
+        throw new Error(err.message || 'Invalid idToken');
+    }
+};
+exports.signinWithApple = signinWithApple;
+const signinWithFacebook = async (accessToken, fields = []) => {
+    fields = [...new Set([...fields, 'name', 'picture', 'email'])];
+    const { data } = await axios_1.default.request({
+        method: 'get',
+        url: 'https://graph.facebook.com/v15.0/me',
+        params: {
+            fields: fields.join(','),
+            access_token: accessToken
+        }
+    }).catch((err) => {
+        const message = err?.response?.data?.error?.message;
+        throw new Error(message ? 'Invalid access token' : 'Something unexpected happened');
+    });
+    const isValidData = fields.every((key) => key in data);
+    if (!isValidData)
+        throw new Error('Incomplete scope for access token');
+    data.email_verified = 'true';
+    return data;
+};
+exports.signinWithFacebook = signinWithFacebook;

package/lib/utils/authUser.d.ts

@@ -0,0 +1,10 @@
+import { Enum, IAuthRole } from '../enums/types';
+export interface RefreshUser {
+    id: string;
+}
+export interface AuthUser {
+    id: string;
+    roles: AuthRoles;
+}
+export interface AuthRoles extends Partial<Record<Enum<IAuthRole>, boolean>> {
+}

package/lib/utils/authUser.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/media.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare const getMediaDuration: (buffer: Buffer) => Promise<number>;

package/lib/utils/media.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMediaDuration = void 0;
+const music_metadata_1 = require("music-metadata");
+const getMediaDuration = async (buffer) => {
+    try {
+        const meta = await (0, music_metadata_1.parseBuffer)(buffer);
+        return meta.format.duration ?? 0;
+    }
+    catch (e) {
+        return 0;
+    }
+};
+exports.getMediaDuration = getMediaDuration;

package/lib/utils/tokens.d.ts

@@ -0,0 +1,15 @@
+import { AuthUser, RefreshUser } from './authUser';
+export declare const makeAccessToken: (payload: AuthUser) => Promise<string>;
+export declare const makeRefreshToken: (payload: RefreshUser) => Promise<string>;
+export declare const verifyAccessToken: (token: string) => Promise<AuthUser>;
+export declare const verifyRefreshToken: (token: string) => Promise<RefreshUser>;
+export declare const getCachedAccessToken: (userId: string) => Promise<string | null>;
+export declare const getCachedRefreshToken: (userId: string) => Promise<string | null>;
+export declare const deleteCachedAccessToken: (userId: string) => Promise<void>;
+export declare const deleteCachedRefreshToken: (userId: string) => Promise<void>;
+type Tokens = {
+    accessToken: string;
+    refreshToken: string;
+};
+export declare const exchangeOldForNewTokens: ({ accessToken, refreshToken }: Tokens, makeTokens: (id: string) => Promise<Tokens>) => Promise<Tokens>;
+export {};

package/lib/utils/tokens.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exchangeOldForNewTokens = exports.deleteCachedRefreshToken = exports.deleteCachedAccessToken = exports.getCachedRefreshToken = exports.getCachedAccessToken = exports.verifyRefreshToken = exports.verifyAccessToken = exports.makeRefreshToken = exports.makeAccessToken = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const errors_1 = require("../errors");
+const express_1 = require("../express");
+const instance_1 = require("../instance");
+const getAccessTokenKey = (userId) => `${userId}-access-token`;
+const getRefreshTokenKey = (userId) => `${userId}-refresh-token`;
+const makeAccessToken = async (payload) => {
+    const token = jsonwebtoken_1.default.sign(payload, instance_1.Instance.get().settings.accessTokenKey, { expiresIn: instance_1.Instance.get().settings.accessTokenTTL });
+    await instance_1.Instance.get().cache.set(getAccessTokenKey(payload.id), token, instance_1.Instance.get().settings.accessTokenTTL);
+    return token;
+};
+exports.makeAccessToken = makeAccessToken;
+const makeRefreshToken = async (payload) => {
+    const token = jsonwebtoken_1.default.sign(payload, instance_1.Instance.get().settings.refreshTokenKey, { expiresIn: instance_1.Instance.get().settings.refreshTokenTTL });
+    await instance_1.Instance.get().cache.set(getRefreshTokenKey(payload.id), token, instance_1.Instance.get().settings.refreshTokenTTL);
+    return token;
+};
+exports.makeRefreshToken = makeRefreshToken;
+const verifyAccessToken = async (token) => {
+    try {
+        const user = jsonwebtoken_1.default.verify(token, instance_1.Instance.get().settings.accessTokenKey);
+        if (!user)
+            throw new errors_1.NotAuthenticatedError();
+        const cachedToken = await (0, exports.getCachedAccessToken)(user.id);
+        if (token && token !== cachedToken)
+            throw new errors_1.AccessTokenExpired();
+        return user;
+    }
+    catch (err) {
+        if (err instanceof errors_1.AccessTokenExpired)
+            throw err;
+        if (err instanceof jsonwebtoken_1.default.TokenExpiredError)
+            throw new errors_1.AccessTokenExpired();
+        else
+            throw new errors_1.NotAuthenticatedError();
+    }
+};
+exports.verifyAccessToken = verifyAccessToken;
+const verifyRefreshToken = async (token) => {
+    try {
+        const user = jsonwebtoken_1.default.verify(token, instance_1.Instance.get().settings.refreshTokenKey);
+        if (!user)
+            throw new errors_1.NotAuthenticatedError();
+        return user;
+    }
+    catch (err) {
+        throw new errors_1.NotAuthenticatedError();
+    }
+};
+exports.verifyRefreshToken = verifyRefreshToken;
+const getCachedAccessToken = async (userId) => instance_1.Instance.get().cache.get(getAccessTokenKey(userId));
+exports.getCachedAccessToken = getCachedAccessToken;
+const getCachedRefreshToken = async (userId) => instance_1.Instance.get().cache.get(getRefreshTokenKey(userId));
+exports.getCachedRefreshToken = getCachedRefreshToken;
+const deleteCachedAccessToken = async (userId) => instance_1.Instance.get().cache.delete(getAccessTokenKey(userId));
+exports.deleteCachedAccessToken = deleteCachedAccessToken;
+const deleteCachedRefreshToken = async (userId) => instance_1.Instance.get().cache.delete(getRefreshTokenKey(userId));
+exports.deleteCachedRefreshToken = deleteCachedRefreshToken;
+const exchangeOldForNewTokens = async ({ accessToken, refreshToken }, makeTokens) => {
+    const authUser = await (0, exports.verifyAccessToken)(accessToken).catch((err) => {
+        const error = err;
+        if (error.statusCode === express_1.StatusCodes.AccessTokenExpired)
+            return null;
+        else
+            throw err;
+    });
+    if (authUser)
+        return await makeTokens(authUser.id);
+    const refreshUser = await (0, exports.verifyRefreshToken)(refreshToken);
+    return await makeTokens(refreshUser.id);
+};
+exports.exchangeOldForNewTokens = exchangeOldForNewTokens;

package/lib/utils/utils.d.ts

@@ -0,0 +1,4 @@
+export declare class Random {
+    static string(length?: number): string;
+    static number(min?: number, max?: number): number;
+}

package/lib/utils/utils.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Random = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+class Random {
+    static string(length = 20) {
+        return crypto_1.default.randomBytes(length).toString('hex').slice(0, length);
+    }
+    static number(min = 0, max = 2 ** 48 - 1) {
+        return crypto_1.default.randomInt(min, max);
+    }
+}
+exports.Random = Random;

package/lib/validations/index.d.ts

@@ -0,0 +1,146 @@
+import * as Validate from 'valleyed';
+import { VCore } from 'valleyed/lib/api/core';
+import { StorageFile } from '../storage';
+type Phone = {
+    code: string;
+    number: string;
+};
+export declare const Schema: {
+    or: <T extends VCore<any, any>[]>(options: T, err?: string | undefined) => import("valleyed/lib/api/junctions").VOr<T>;
+    and: <I, O>(options: VCore<I, O>[], err?: string | undefined) => import("valleyed/lib/api/junctions").VAnd<I, O>;
+    string: (err?: string | undefined) => import("valleyed/lib/api/strings").VString;
+    number: (err?: string | undefined) => import("valleyed/lib/api/numbers").VNumber;
+    boolean: (err?: string | undefined) => import("valleyed/lib/api/booleans").VBoolean;
+    time: <T_1 extends Validate.Timeable = Validate.Timeable>(err?: string | undefined) => import("valleyed/lib/api/times").VTime<T_1>;
+    file: (err?: string | undefined) => import("valleyed/lib/api/files").VFile;
+    array: <I_1, O_1>(comparer: VCore<I_1, O_1>, err?: string | undefined) => import("valleyed/lib/api/arrays").VArray<I_1, O_1>;
+    tuple: <T_2 extends readonly VCore<any, any>[]>(schema: readonly [...T_2], err?: string | undefined) => import("valleyed/lib/api/tuples").VTuple<T_2>;
+    object: <T_3 extends Record<string, VCore<any, any>>>(schema: T_3, trim?: boolean | undefined, err?: string | undefined) => import("valleyed/lib/api/objects").VObject<T_3>;
+    record: <VI, VO>(vCom: VCore<VI, VO>, err?: string | undefined) => import("valleyed/lib/api/records").VRecord<VI, VO>;
+    map: <KI, VI_1, KO, VO_1>(kCom: VCore<KI, KO>, vCom: VCore<VI_1, VO_1>, err?: string | undefined) => import("valleyed/lib/api/records").VMap<KI, VI_1, KO, VO_1>;
+    null: (err?: string | undefined) => VCore<null, null>;
+    undefined: (err?: string | undefined) => VCore<undefined, undefined>;
+    instanceof: <T_4>(classDef: new () => T_4, err?: string | undefined) => VCore<T_4, T_4>;
+    any: <T_5 = any>() => VCore<T_5, T_5>;
+    force: {
+        string: (err?: string | undefined) => import("valleyed/lib/api/strings").VString;
+        number: (err?: string | undefined) => import("valleyed/lib/api/numbers").VNumber;
+        boolean: (err?: string | undefined) => import("valleyed/lib/api/booleans").VBoolean;
+        time: (err?: string | undefined) => import("valleyed/lib/api/times").VTime<Date>;
+    };
+};
+export declare const Validation: {
+    isNotTruncated: (error?: string) => Validate.Rule<StorageFile>;
+    isValidPhone: (error?: string) => Validate.Rule<Phone>;
+    Validator: typeof Validate.Validator;
+    v: {
+        or: <T extends VCore<any, any>[]>(options: T, err?: string | undefined) => import("valleyed/lib/api/junctions").VOr<T>;
+        and: <I, O>(options: VCore<I, O>[], err?: string | undefined) => import("valleyed/lib/api/junctions").VAnd<I, O>;
+        string: (err?: string | undefined) => import("valleyed/lib/api/strings").VString;
+        number: (err?: string | undefined) => import("valleyed/lib/api/numbers").VNumber;
+        boolean: (err?: string | undefined) => import("valleyed/lib/api/booleans").VBoolean;
+        time: <T_1 extends Validate.Timeable = Validate.Timeable>(err?: string | undefined) => import("valleyed/lib/api/times").VTime<T_1>;
+        file: (err?: string | undefined) => import("valleyed/lib/api/files").VFile;
+        array: <I_1, O_1>(comparer: VCore<I_1, O_1>, err?: string | undefined) => import("valleyed/lib/api/arrays").VArray<I_1, O_1>;
+        tuple: <T_2 extends readonly VCore<any, any>[]>(schema: readonly [...T_2], err?: string | undefined) => import("valleyed/lib/api/tuples").VTuple<T_2>;
+        object: <T_3 extends Record<string, VCore<any, any>>>(schema: T_3, trim?: boolean | undefined, err?: string | undefined) => import("valleyed/lib/api/objects").VObject<T_3>;
+        record: <VI, VO>(vCom: VCore<VI, VO>, err?: string | undefined) => import("valleyed/lib/api/records").VRecord<VI, VO>;
+        map: <KI, VI_1, KO, VO_1>(kCom: VCore<KI, KO>, vCom: VCore<VI_1, VO_1>, err?: string | undefined) => import("valleyed/lib/api/records").VMap<KI, VI_1, KO, VO_1>;
+        null: (err?: string | undefined) => VCore<null, null>;
+        undefined: (err?: string | undefined) => VCore<undefined, undefined>;
+        instanceof: <T_4>(classDef: new () => T_4, err?: string | undefined) => VCore<T_4, T_4>;
+        any: <T_5 = any>() => VCore<T_5, T_5>;
+        force: {
+            string: (err?: string | undefined) => import("valleyed/lib/api/strings").VString;
+            number: (err?: string | undefined) => import("valleyed/lib/api/numbers").VNumber;
+            boolean: (err?: string | undefined) => import("valleyed/lib/api/booleans").VBoolean;
+            time: (err?: string | undefined) => import("valleyed/lib/api/times").VTime<Date>;
+        };
+    };
+    isValid: <T>(value: T) => {
+        valid: true;
+        errors: string[];
+        value: T;
+    };
+    isInvalid: <T_1>(errors: string[], value: T_1) => {
+        valid: false;
+        errors: string[];
+        value: unknown;
+    };
+    makeRule: <T_2>(func: Validate.Rule<T_2>) => Validate.Rule<T_2>;
+    makeSanitizer: <T_3>(func: Validate.Sanitizer<T_3>) => (val: T_3) => T_3;
+    check: <T_4>(value: T_4, rules: Validate.Rule<T_4>[], options?: Partial<Validate.Options> | undefined) => {
+        errors: string[];
+        value: T_4;
+        valid: boolean;
+    };
+    isEqualTo: <Type>(compare: Type, comparer?: ((val: any, compare: Type) => boolean) | undefined, error?: string | undefined) => Validate.Rule<Type>;
+    arrayContains: <Type_1>(array: Type_1[], comparer?: ((val: any, arrayItem: Type_1) => boolean) | undefined, error?: string | undefined) => Validate.Rule<Type_1>;
+    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>;
+    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_2>(length: number, error?: string | undefined) => Validate.Rule<Type_2[]>;
+    hasMinOf: <Type_3>(length: number, error?: string | undefined) => Validate.Rule<Type_3[]>;
+    hasMaxOf: <Type_4>(length: number, error?: string | undefined) => Validate.Rule<Type_4[]>;
+    isArrayOf: <Type_5>(comparer: (cur: Type_5, idx: number) => boolean, error?: string | undefined) => Validate.Rule<Type_5[]>;
+    isUndefined: (error?: string | undefined) => Validate.Rule<undefined>;
+    isNull: (error?: string | undefined) => Validate.Rule<null>;
+    isBoolean: (error?: string | undefined) => Validate.Rule<boolean>;
+    isInstanceOf: <T_5>(classDef: new () => T_5, error?: string | undefined) => Validate.Rule<T_5>;
+    fileMimeTypes: string[];
+    videoMimeTypes: string[];
+    audioMimeTypes: string[];
+    imageMimeTypes: string[];
+    isImage: (error?: string | undefined) => Validate.Rule<any>;
+    isAudio: (error?: string | undefined) => Validate.Rule<any>;
+    isVideo: (error?: string | undefined) => Validate.Rule<any>;
+    isFile: (error?: string | undefined) => Validate.Rule<any>;
+    isTuple: <T_6 extends readonly ((v: any, idx: number) => boolean)[]>(comparer: readonly [...T_6], error?: string | undefined) => Validate.Rule<{ [K in keyof T_6]: T_6[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_7>(validity: (v: T_7) => boolean, error?: string | undefined) => Validate.Rule<T_7>;
+    isTime: <T_8 extends Validate.Timeable>(error?: string | undefined) => Validate.Rule<T_8>;
+    isLaterThan: <T_9 extends Validate.Timeable>(compare: Validate.Timeable, error?: string | undefined) => Validate.Rule<T_9>;
+    isEarlierThan: <T_10 extends Validate.Timeable>(compare: Validate.Timeable, error?: string | undefined) => Validate.Rule<T_10>;
+    capitalize: (text: string) => string;
+    stripHTML: (html: string) => string;
+    trimToLength: (body: string, length: number) => string;
+    extractUrls: (text: string) => {
+        original: string;
+        normalized: string;
+    }[];
+    formatNumber: (num: number, dp?: number | undefined) => string;
+    pluralize: (count: number, singular: string, plural: string) => string;
+    getRandomValue: () => string;
+    groupBy: <Type_6, Unique extends string | number>(array: Type_6[], func: (item: Type_6) => Unique) => {
+        key: Unique;
+        values: Type_6[];
+    }[];
+    getAlphabet: (num: number) => string;
+    addToArray: <T_11>(array: T_11[], item: T_11, getKey: (a: T_11) => any, getComparer: (a: T_11) => string | number, asc?: boolean | undefined) => T_11[];
+    divideByZero: (num: number, den: number) => number;
+    getPercentage: (num: number, den: number) => number;
+    getRandomSample: <Type_7>(population: Type_7[], n: number) => Type_7[];
+    shuffleArray: <Type_8>(array: Type_8[]) => Type_8[];
+};
+type Rules<T> = {
+    required?: boolean | (() => boolean);
+    nullable?: boolean;
+    rules: Validate.Rule<T>[];
+};
+export declare const validate: <Keys extends Record<string, any>>(data: Keys, rules: Record<keyof Keys, Rules<any>>) => Keys;
+export declare const validateReq: <T extends Record<string, VCore<any, any>>>(schema: T, value: Record<string, any>) => { [K in keyof T]: import("valleyed/lib/api/base").ExtractO<T[K]>; };
+export declare const Hash: {
+    hash: (password: string) => Promise<string>;
+    compare: (plainPassword: string, hashed: string) => Promise<boolean>;
+};
+export {};