mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2026-06-28 14:20:12 +00:00
New version on Joi, now the v9 is available. (#9335)
This commit is contained in:
Gael Magnan de bornier
committed by
Masahiro Wakame
Masahiro Wakame
parent
6d46dce92e
commit
672b7b71d1
774
joi/joi-6.5.0-tests.ts
Normal file
774
joi/joi-6.5.0-tests.ts
Normal file
@@ -0,0 +1,774 @@
|
||||
/// <reference path="joi.d.ts" />
|
||||
/// <reference path="../node/node.d.ts" />
|
||||
|
||||
import Joi = require('joi');
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
var x: any = null;
|
||||
var value: any = null;
|
||||
var num: number = 0;
|
||||
var str: string = '';
|
||||
var bool: boolean = false;
|
||||
var exp: RegExp = null;
|
||||
var obj: Object = null;
|
||||
var date: Date = null;
|
||||
var bin: NodeBuffer = null;
|
||||
var err: Error = null;
|
||||
var func: Function = null;
|
||||
|
||||
var anyArr: any[] = [];
|
||||
var numArr: number[] = [];
|
||||
var strArr: string[] = [];
|
||||
var boolArr: boolean[] = [];
|
||||
var expArr: RegExp[] = [];
|
||||
var objArr: Object[] = [];
|
||||
var bufArr: NodeBuffer[] = [];
|
||||
var errArr: Error[] = [];
|
||||
var funcArr: Function[] = [];
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
var schema: Joi.Schema = null;
|
||||
|
||||
var anySchema: Joi.AnySchema<Joi.Schema> = null;
|
||||
var numSchema: Joi.NumberSchema = null;
|
||||
var strSchema: Joi.StringSchema = null;
|
||||
var arrSchema: Joi.ArraySchema = null;
|
||||
var boolSchema: Joi.BooleanSchema = null;
|
||||
var binSchema: Joi.BinarySchema = null;
|
||||
var dateSchema: Joi.DateSchema = null;
|
||||
var funcSchema: Joi.FunctionSchema = null;
|
||||
var objSchema: Joi.ObjectSchema = null;
|
||||
var altSchema: Joi.AlternativesSchema = null;
|
||||
|
||||
var schemaArr: Joi.Schema[] = [];
|
||||
|
||||
var ref: Joi.Reference = null;
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
var validOpts: Joi.ValidationOptions = null;
|
||||
|
||||
validOpts = {abortEarly: bool};
|
||||
validOpts = {convert: bool};
|
||||
validOpts = {allowUnknown: bool};
|
||||
validOpts = {skipFunctions: bool};
|
||||
validOpts = {stripUnknown: bool};
|
||||
validOpts = {language: bool};
|
||||
validOpts = {presence: str};
|
||||
validOpts = {context: obj};
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
var renOpts: Joi.RenameOptions = null;
|
||||
|
||||
renOpts = {alias: bool};
|
||||
renOpts = {multiple: bool};
|
||||
renOpts = {override: bool};
|
||||
renOpts = {ignoreUndefined: bool};
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
var emailOpts: Joi.EmailOptions = null;
|
||||
|
||||
emailOpts = {errorLevel: num};
|
||||
emailOpts = {errorLevel: bool};
|
||||
emailOpts = {tldWhitelist: strArr};
|
||||
emailOpts = {tldWhitelist: obj};
|
||||
emailOpts = {minDomainAtoms: num};
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
var ipOpts: Joi.IpOptions = null;
|
||||
|
||||
ipOpts = {version: str};
|
||||
ipOpts = {version: strArr};
|
||||
ipOpts = {cidr: str};
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
var uriOpts: Joi.UriOptions = null;
|
||||
|
||||
uriOpts = {scheme: str};
|
||||
uriOpts = {scheme: exp};
|
||||
uriOpts = {scheme: strArr};
|
||||
uriOpts = {scheme: expArr};
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
var whenOpts: Joi.WhenOptions<any> = null;
|
||||
|
||||
whenOpts = {is: x};
|
||||
whenOpts = {is: schema, then: schema};
|
||||
whenOpts = {is: schema, otherwise: schema};
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
var refOpts: Joi.ReferenceOptions = null;
|
||||
|
||||
refOpts = {separator: str};
|
||||
refOpts = {contextPrefix: str};
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
var validErr: Joi.ValidationError = null;
|
||||
var validErrItem: Joi.ValidationErrorItem;
|
||||
|
||||
validErrItem= {
|
||||
message: str,
|
||||
type: str,
|
||||
path: str
|
||||
};
|
||||
|
||||
validErrItem = {
|
||||
message: str,
|
||||
type: str,
|
||||
path: str,
|
||||
options: validOpts
|
||||
};
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
schema = anySchema;
|
||||
schema = numSchema;
|
||||
schema = strSchema;
|
||||
schema = arrSchema;
|
||||
schema = boolSchema;
|
||||
schema = binSchema;
|
||||
schema = dateSchema;
|
||||
schema = funcSchema;
|
||||
schema = objSchema;
|
||||
|
||||
schema = ref;
|
||||
|
||||
anySchema = anySchema;
|
||||
anySchema = numSchema;
|
||||
anySchema = strSchema;
|
||||
anySchema = arrSchema;
|
||||
anySchema = boolSchema;
|
||||
anySchema = binSchema;
|
||||
anySchema = dateSchema;
|
||||
anySchema = funcSchema;
|
||||
anySchema = objSchema;
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
var schemaMap: Joi.SchemaMap = null;
|
||||
|
||||
schemaMap = {
|
||||
a: numSchema,
|
||||
b: strSchema
|
||||
};
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
anySchema = Joi.any();
|
||||
|
||||
namespace common {
|
||||
anySchema = anySchema.allow(x);
|
||||
anySchema = anySchema.allow(x, x);
|
||||
anySchema = anySchema.allow([x, x, x]);
|
||||
anySchema = anySchema.valid(x);
|
||||
anySchema = anySchema.valid(x, x);
|
||||
anySchema = anySchema.valid([x, x, x]);
|
||||
anySchema = anySchema.only(x);
|
||||
anySchema = anySchema.only(x, x);
|
||||
anySchema = anySchema.only([x, x, x]);
|
||||
anySchema = anySchema.equal(x);
|
||||
anySchema = anySchema.equal(x, x);
|
||||
anySchema = anySchema.equal([x, x, x]);
|
||||
anySchema = anySchema.invalid(x);
|
||||
anySchema = anySchema.invalid(x, x);
|
||||
anySchema = anySchema.invalid([x, x, x]);
|
||||
anySchema = anySchema.disallow(x);
|
||||
anySchema = anySchema.disallow(x, x);
|
||||
anySchema = anySchema.disallow([x, x, x]);
|
||||
anySchema = anySchema.not(x);
|
||||
anySchema = anySchema.not(x, x);
|
||||
anySchema = anySchema.not([x, x, x]);
|
||||
|
||||
anySchema = anySchema.default();
|
||||
anySchema = anySchema.default(x);
|
||||
anySchema = anySchema.default(x, str);
|
||||
|
||||
anySchema = anySchema.required();
|
||||
anySchema = anySchema.optional();
|
||||
anySchema = anySchema.forbidden();
|
||||
anySchema = anySchema.strip();
|
||||
|
||||
anySchema = anySchema.description(str);
|
||||
anySchema = anySchema.notes(str);
|
||||
anySchema = anySchema.notes(strArr);
|
||||
anySchema = anySchema.tags(str);
|
||||
anySchema = anySchema.tags(strArr);
|
||||
|
||||
anySchema = anySchema.meta(obj);
|
||||
anySchema = anySchema.example(obj);
|
||||
anySchema = anySchema.unit(str);
|
||||
|
||||
anySchema = anySchema.options(validOpts);
|
||||
anySchema = anySchema.strict();
|
||||
anySchema = anySchema.strict(bool);
|
||||
anySchema = anySchema.concat(x);
|
||||
|
||||
altSchema = anySchema.when(str, whenOpts);
|
||||
altSchema = anySchema.when(ref, whenOpts);
|
||||
|
||||
anySchema = anySchema.label(str);
|
||||
anySchema = anySchema.raw();
|
||||
anySchema = anySchema.raw(bool);
|
||||
anySchema = anySchema.empty();
|
||||
anySchema = anySchema.empty(str);
|
||||
anySchema = anySchema.empty(anySchema);
|
||||
}
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
arrSchema = Joi.array();
|
||||
|
||||
arrSchema = arrSchema.sparse();
|
||||
arrSchema = arrSchema.sparse(bool);
|
||||
arrSchema = arrSchema.single();
|
||||
arrSchema = arrSchema.single(bool);
|
||||
arrSchema = arrSchema.min(num);
|
||||
arrSchema = arrSchema.max(num);
|
||||
arrSchema = arrSchema.length(num);
|
||||
arrSchema = arrSchema.unique();
|
||||
|
||||
arrSchema = arrSchema.items(numSchema);
|
||||
arrSchema = arrSchema.items(numSchema, strSchema);
|
||||
arrSchema = arrSchema.items([numSchema, strSchema]);
|
||||
|
||||
|
||||
// - - - - - - - -
|
||||
|
||||
namespace common_copy_paste {
|
||||
// use search & replace from any
|
||||
arrSchema = arrSchema.allow(x);
|
||||
arrSchema = arrSchema.allow(x, x);
|
||||
arrSchema = arrSchema.allow([x, x, x]);
|
||||
arrSchema = arrSchema.valid(x);
|
||||
arrSchema = arrSchema.valid(x, x);
|
||||
arrSchema = arrSchema.valid([x, x, x]);
|
||||
arrSchema = arrSchema.only(x);
|
||||
arrSchema = arrSchema.only(x, x);
|
||||
arrSchema = arrSchema.only([x, x, x]);
|
||||
arrSchema = arrSchema.equal(x);
|
||||
arrSchema = arrSchema.equal(x, x);
|
||||
arrSchema = arrSchema.equal([x, x, x]);
|
||||
arrSchema = arrSchema.invalid(x);
|
||||
arrSchema = arrSchema.invalid(x, x);
|
||||
arrSchema = arrSchema.invalid([x, x, x]);
|
||||
arrSchema = arrSchema.disallow(x);
|
||||
arrSchema = arrSchema.disallow(x, x);
|
||||
arrSchema = arrSchema.disallow([x, x, x]);
|
||||
arrSchema = arrSchema.not(x);
|
||||
arrSchema = arrSchema.not(x, x);
|
||||
arrSchema = arrSchema.not([x, x, x]);
|
||||
|
||||
arrSchema = arrSchema.default(x);
|
||||
|
||||
arrSchema = arrSchema.required();
|
||||
arrSchema = arrSchema.optional();
|
||||
arrSchema = arrSchema.forbidden();
|
||||
|
||||
arrSchema = arrSchema.description(str);
|
||||
arrSchema = arrSchema.notes(str);
|
||||
arrSchema = arrSchema.notes(strArr);
|
||||
arrSchema = arrSchema.tags(str);
|
||||
arrSchema = arrSchema.tags(strArr);
|
||||
|
||||
arrSchema = arrSchema.meta(obj);
|
||||
arrSchema = arrSchema.example(obj);
|
||||
arrSchema = arrSchema.unit(str);
|
||||
|
||||
arrSchema = arrSchema.options(validOpts);
|
||||
arrSchema = arrSchema.strict();
|
||||
arrSchema = arrSchema.concat(x);
|
||||
|
||||
altSchema = arrSchema.when(str, whenOpts);
|
||||
altSchema = arrSchema.when(ref, whenOpts);
|
||||
}
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
boolSchema = Joi.bool();
|
||||
boolSchema = Joi.boolean();
|
||||
|
||||
namespace common_copy_paste {
|
||||
boolSchema = boolSchema.allow(x);
|
||||
boolSchema = boolSchema.allow(x, x);
|
||||
boolSchema = boolSchema.allow([x, x, x]);
|
||||
boolSchema = boolSchema.valid(x);
|
||||
boolSchema = boolSchema.valid(x, x);
|
||||
boolSchema = boolSchema.valid([x, x, x]);
|
||||
boolSchema = boolSchema.only(x);
|
||||
boolSchema = boolSchema.only(x, x);
|
||||
boolSchema = boolSchema.only([x, x, x]);
|
||||
boolSchema = boolSchema.equal(x);
|
||||
boolSchema = boolSchema.equal(x, x);
|
||||
boolSchema = boolSchema.equal([x, x, x]);
|
||||
boolSchema = boolSchema.invalid(x);
|
||||
boolSchema = boolSchema.invalid(x, x);
|
||||
boolSchema = boolSchema.invalid([x, x, x]);
|
||||
boolSchema = boolSchema.disallow(x);
|
||||
boolSchema = boolSchema.disallow(x, x);
|
||||
boolSchema = boolSchema.disallow([x, x, x]);
|
||||
boolSchema = boolSchema.not(x);
|
||||
boolSchema = boolSchema.not(x, x);
|
||||
boolSchema = boolSchema.not([x, x, x]);
|
||||
|
||||
boolSchema = boolSchema.default(x);
|
||||
|
||||
boolSchema = boolSchema.required();
|
||||
boolSchema = boolSchema.optional();
|
||||
boolSchema = boolSchema.forbidden();
|
||||
|
||||
boolSchema = boolSchema.description(str);
|
||||
boolSchema = boolSchema.notes(str);
|
||||
boolSchema = boolSchema.notes(strArr);
|
||||
boolSchema = boolSchema.tags(str);
|
||||
boolSchema = boolSchema.tags(strArr);
|
||||
|
||||
boolSchema = boolSchema.meta(obj);
|
||||
boolSchema = boolSchema.example(obj);
|
||||
boolSchema = boolSchema.unit(str);
|
||||
|
||||
boolSchema = boolSchema.options(validOpts);
|
||||
boolSchema = boolSchema.strict();
|
||||
boolSchema = boolSchema.concat(x);
|
||||
|
||||
altSchema = boolSchema.when(str, whenOpts);
|
||||
altSchema = boolSchema.when(ref, whenOpts);
|
||||
}
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
binSchema = Joi.binary();
|
||||
|
||||
binSchema = binSchema.encoding(str);
|
||||
binSchema = binSchema.min(num);
|
||||
binSchema = binSchema.max(num);
|
||||
binSchema = binSchema.length(num);
|
||||
|
||||
namespace common {
|
||||
binSchema = binSchema.allow(x);
|
||||
binSchema = binSchema.allow(x, x);
|
||||
binSchema = binSchema.allow([x, x, x]);
|
||||
binSchema = binSchema.valid(x);
|
||||
binSchema = binSchema.valid(x, x);
|
||||
binSchema = binSchema.valid([x, x, x]);
|
||||
binSchema = binSchema.only(x);
|
||||
binSchema = binSchema.only(x, x);
|
||||
binSchema = binSchema.only([x, x, x]);
|
||||
binSchema = binSchema.equal(x);
|
||||
binSchema = binSchema.equal(x, x);
|
||||
binSchema = binSchema.equal([x, x, x]);
|
||||
binSchema = binSchema.invalid(x);
|
||||
binSchema = binSchema.invalid(x, x);
|
||||
binSchema = binSchema.invalid([x, x, x]);
|
||||
binSchema = binSchema.disallow(x);
|
||||
binSchema = binSchema.disallow(x, x);
|
||||
binSchema = binSchema.disallow([x, x, x]);
|
||||
binSchema = binSchema.not(x);
|
||||
binSchema = binSchema.not(x, x);
|
||||
binSchema = binSchema.not([x, x, x]);
|
||||
|
||||
binSchema = binSchema.default(x);
|
||||
|
||||
binSchema = binSchema.required();
|
||||
binSchema = binSchema.optional();
|
||||
binSchema = binSchema.forbidden();
|
||||
|
||||
binSchema = binSchema.description(str);
|
||||
binSchema = binSchema.notes(str);
|
||||
binSchema = binSchema.notes(strArr);
|
||||
binSchema = binSchema.tags(str);
|
||||
binSchema = binSchema.tags(strArr);
|
||||
|
||||
binSchema = binSchema.meta(obj);
|
||||
binSchema = binSchema.example(obj);
|
||||
binSchema = binSchema.unit(str);
|
||||
|
||||
binSchema = binSchema.options(validOpts);
|
||||
binSchema = binSchema.strict();
|
||||
binSchema = binSchema.concat(x);
|
||||
|
||||
altSchema = binSchema.when(str, whenOpts);
|
||||
altSchema = binSchema.when(ref, whenOpts);
|
||||
}
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
dateSchema = Joi.date();
|
||||
|
||||
dateSchema = dateSchema.min(date);
|
||||
dateSchema = dateSchema.max(date);
|
||||
|
||||
dateSchema = dateSchema.min(str);
|
||||
dateSchema = dateSchema.max(str);
|
||||
|
||||
dateSchema = dateSchema.min(num);
|
||||
dateSchema = dateSchema.max(num);
|
||||
|
||||
dateSchema = dateSchema.min(ref);
|
||||
dateSchema = dateSchema.max(ref);
|
||||
|
||||
dateSchema = dateSchema.format(str);
|
||||
dateSchema = dateSchema.format(strArr);
|
||||
|
||||
dateSchema = dateSchema.iso();
|
||||
|
||||
namespace common {
|
||||
dateSchema = dateSchema.allow(x);
|
||||
dateSchema = dateSchema.allow(x, x);
|
||||
dateSchema = dateSchema.allow([x, x, x]);
|
||||
dateSchema = dateSchema.valid(x);
|
||||
dateSchema = dateSchema.valid(x, x);
|
||||
dateSchema = dateSchema.valid([x, x, x]);
|
||||
dateSchema = dateSchema.only(x);
|
||||
dateSchema = dateSchema.only(x, x);
|
||||
dateSchema = dateSchema.only([x, x, x]);
|
||||
dateSchema = dateSchema.equal(x);
|
||||
dateSchema = dateSchema.equal(x, x);
|
||||
dateSchema = dateSchema.equal([x, x, x]);
|
||||
dateSchema = dateSchema.invalid(x);
|
||||
dateSchema = dateSchema.invalid(x, x);
|
||||
dateSchema = dateSchema.invalid([x, x, x]);
|
||||
dateSchema = dateSchema.disallow(x);
|
||||
dateSchema = dateSchema.disallow(x, x);
|
||||
dateSchema = dateSchema.disallow([x, x, x]);
|
||||
dateSchema = dateSchema.not(x);
|
||||
dateSchema = dateSchema.not(x, x);
|
||||
dateSchema = dateSchema.not([x, x, x]);
|
||||
|
||||
dateSchema = dateSchema.default(x);
|
||||
|
||||
dateSchema = dateSchema.required();
|
||||
dateSchema = dateSchema.optional();
|
||||
dateSchema = dateSchema.forbidden();
|
||||
|
||||
dateSchema = dateSchema.description(str);
|
||||
dateSchema = dateSchema.notes(str);
|
||||
dateSchema = dateSchema.notes(strArr);
|
||||
dateSchema = dateSchema.tags(str);
|
||||
dateSchema = dateSchema.tags(strArr);
|
||||
|
||||
dateSchema = dateSchema.meta(obj);
|
||||
dateSchema = dateSchema.example(obj);
|
||||
dateSchema = dateSchema.unit(str);
|
||||
|
||||
dateSchema = dateSchema.options(validOpts);
|
||||
dateSchema = dateSchema.strict();
|
||||
dateSchema = dateSchema.concat(x);
|
||||
|
||||
altSchema = dateSchema.when(str, whenOpts);
|
||||
altSchema = dateSchema.when(ref, whenOpts);
|
||||
}
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
funcSchema = Joi.func();
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
numSchema = Joi.number();
|
||||
|
||||
numSchema = numSchema.min(num);
|
||||
numSchema = numSchema.min(ref);
|
||||
numSchema = numSchema.max(num);
|
||||
numSchema = numSchema.max(ref);
|
||||
numSchema = numSchema.greater(num);
|
||||
numSchema = numSchema.greater(ref);
|
||||
numSchema = numSchema.less(num);
|
||||
numSchema = numSchema.less(ref);
|
||||
numSchema = numSchema.integer();
|
||||
numSchema = numSchema.precision(num);
|
||||
numSchema = numSchema.multiple(num);
|
||||
numSchema = numSchema.positive();
|
||||
numSchema = numSchema.negative();
|
||||
|
||||
namespace common {
|
||||
numSchema = numSchema.allow(x);
|
||||
numSchema = numSchema.allow(x, x);
|
||||
numSchema = numSchema.allow([x, x, x]);
|
||||
numSchema = numSchema.valid(x);
|
||||
numSchema = numSchema.valid(x, x);
|
||||
numSchema = numSchema.valid([x, x, x]);
|
||||
numSchema = numSchema.only(x);
|
||||
numSchema = numSchema.only(x, x);
|
||||
numSchema = numSchema.only([x, x, x]);
|
||||
numSchema = numSchema.equal(x);
|
||||
numSchema = numSchema.equal(x, x);
|
||||
numSchema = numSchema.equal([x, x, x]);
|
||||
numSchema = numSchema.invalid(x);
|
||||
numSchema = numSchema.invalid(x, x);
|
||||
numSchema = numSchema.invalid([x, x, x]);
|
||||
numSchema = numSchema.disallow(x);
|
||||
numSchema = numSchema.disallow(x, x);
|
||||
numSchema = numSchema.disallow([x, x, x]);
|
||||
numSchema = numSchema.not(x);
|
||||
numSchema = numSchema.not(x, x);
|
||||
numSchema = numSchema.not([x, x, x]);
|
||||
|
||||
numSchema = numSchema.default(x);
|
||||
|
||||
numSchema = numSchema.required();
|
||||
numSchema = numSchema.optional();
|
||||
numSchema = numSchema.forbidden();
|
||||
|
||||
numSchema = numSchema.description(str);
|
||||
numSchema = numSchema.notes(str);
|
||||
numSchema = numSchema.notes(strArr);
|
||||
numSchema = numSchema.tags(str);
|
||||
numSchema = numSchema.tags(strArr);
|
||||
|
||||
numSchema = numSchema.meta(obj);
|
||||
numSchema = numSchema.example(obj);
|
||||
numSchema = numSchema.unit(str);
|
||||
|
||||
numSchema = numSchema.options(validOpts);
|
||||
numSchema = numSchema.strict();
|
||||
numSchema = numSchema.concat(x);
|
||||
|
||||
altSchema = numSchema.when(str, whenOpts);
|
||||
altSchema = numSchema.when(ref, whenOpts);
|
||||
}
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
objSchema = Joi.object();
|
||||
objSchema = Joi.object(schemaMap);
|
||||
|
||||
objSchema = objSchema.keys();
|
||||
objSchema = objSchema.keys(schemaMap);
|
||||
|
||||
objSchema = objSchema.min(num);
|
||||
objSchema = objSchema.max(num);
|
||||
objSchema = objSchema.length(num);
|
||||
|
||||
objSchema = objSchema.pattern(exp, schema);
|
||||
|
||||
objSchema = objSchema.and(str);
|
||||
objSchema = objSchema.and(str, str);
|
||||
objSchema = objSchema.and(str, str, str);
|
||||
objSchema = objSchema.and(strArr);
|
||||
|
||||
objSchema = objSchema.nand(str);
|
||||
objSchema = objSchema.nand(str, str);
|
||||
objSchema = objSchema.nand(str, str, str);
|
||||
objSchema = objSchema.nand(strArr);
|
||||
|
||||
objSchema = objSchema.or(str);
|
||||
objSchema = objSchema.or(str, str);
|
||||
objSchema = objSchema.or(str, str, str);
|
||||
objSchema = objSchema.or(strArr);
|
||||
|
||||
objSchema = objSchema.xor(str);
|
||||
objSchema = objSchema.xor(str, str);
|
||||
objSchema = objSchema.xor(str, str, str);
|
||||
objSchema = objSchema.xor(strArr);
|
||||
|
||||
objSchema = objSchema.with(str, str);
|
||||
objSchema = objSchema.with(str, strArr);
|
||||
|
||||
objSchema = objSchema.without(str, str);
|
||||
objSchema = objSchema.without(str, strArr);
|
||||
|
||||
objSchema = objSchema.rename(str, str);
|
||||
objSchema = objSchema.rename(str, str, renOpts);
|
||||
|
||||
objSchema = objSchema.assert(str, schema);
|
||||
objSchema = objSchema.assert(str, schema, str);
|
||||
objSchema = objSchema.assert(ref, schema);
|
||||
objSchema = objSchema.assert(ref, schema, str);
|
||||
|
||||
objSchema = objSchema.unknown();
|
||||
objSchema = objSchema.unknown(bool);
|
||||
|
||||
objSchema = objSchema.type(func);
|
||||
objSchema = objSchema.type(func, str);
|
||||
|
||||
objSchema = objSchema.requiredKeys(str);
|
||||
objSchema = objSchema.requiredKeys(str, str);
|
||||
objSchema = objSchema.requiredKeys(strArr);
|
||||
|
||||
objSchema = objSchema.optionalKeys(str);
|
||||
objSchema = objSchema.optionalKeys(str, str);
|
||||
objSchema = objSchema.optionalKeys(strArr);
|
||||
|
||||
namespace common {
|
||||
objSchema = objSchema.allow(x);
|
||||
objSchema = objSchema.allow(x, x);
|
||||
objSchema = objSchema.allow([x, x, x]);
|
||||
objSchema = objSchema.valid(x);
|
||||
objSchema = objSchema.valid(x, x);
|
||||
objSchema = objSchema.valid([x, x, x]);
|
||||
objSchema = objSchema.only(x);
|
||||
objSchema = objSchema.only(x, x);
|
||||
objSchema = objSchema.only([x, x, x]);
|
||||
objSchema = objSchema.equal(x);
|
||||
objSchema = objSchema.equal(x, x);
|
||||
objSchema = objSchema.equal([x, x, x]);
|
||||
objSchema = objSchema.invalid(x);
|
||||
objSchema = objSchema.invalid(x, x);
|
||||
objSchema = objSchema.invalid([x, x, x]);
|
||||
objSchema = objSchema.disallow(x);
|
||||
objSchema = objSchema.disallow(x, x);
|
||||
objSchema = objSchema.disallow([x, x, x]);
|
||||
objSchema = objSchema.not(x);
|
||||
objSchema = objSchema.not(x, x);
|
||||
objSchema = objSchema.not([x, x, x]);
|
||||
|
||||
objSchema = objSchema.default(x);
|
||||
|
||||
objSchema = objSchema.required();
|
||||
objSchema = objSchema.optional();
|
||||
objSchema = objSchema.forbidden();
|
||||
|
||||
objSchema = objSchema.description(str);
|
||||
objSchema = objSchema.notes(str);
|
||||
objSchema = objSchema.notes(strArr);
|
||||
objSchema = objSchema.tags(str);
|
||||
objSchema = objSchema.tags(strArr);
|
||||
|
||||
objSchema = objSchema.meta(obj);
|
||||
objSchema = objSchema.example(obj);
|
||||
objSchema = objSchema.unit(str);
|
||||
|
||||
objSchema = objSchema.options(validOpts);
|
||||
objSchema = objSchema.strict();
|
||||
objSchema = objSchema.concat(x);
|
||||
|
||||
altSchema = objSchema.when(str, whenOpts);
|
||||
altSchema = objSchema.when(ref, whenOpts);
|
||||
}
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
strSchema = Joi.string();
|
||||
|
||||
strSchema = strSchema.insensitive();
|
||||
strSchema = strSchema.min(num);
|
||||
strSchema = strSchema.min(num, str);
|
||||
strSchema = strSchema.min(ref);
|
||||
strSchema = strSchema.min(ref, str);
|
||||
strSchema = strSchema.max(num);
|
||||
strSchema = strSchema.max(num, str);
|
||||
strSchema = strSchema.max(ref);
|
||||
strSchema = strSchema.max(ref, str);
|
||||
strSchema = strSchema.creditCard();
|
||||
strSchema = strSchema.length(num);
|
||||
strSchema = strSchema.length(num, str);
|
||||
strSchema = strSchema.length(ref);
|
||||
strSchema = strSchema.length(ref, str);
|
||||
strSchema = strSchema.regex(exp);
|
||||
strSchema = strSchema.regex(exp, str);
|
||||
strSchema = strSchema.replace(exp, str);
|
||||
strSchema = strSchema.replace(str, str);
|
||||
strSchema = strSchema.alphanum();
|
||||
strSchema = strSchema.token();
|
||||
strSchema = strSchema.email();
|
||||
strSchema = strSchema.email(emailOpts);
|
||||
strSchema = strSchema.ip();
|
||||
strSchema = strSchema.ip(ipOpts);
|
||||
strSchema = strSchema.uri();
|
||||
strSchema = strSchema.uri(uriOpts);
|
||||
strSchema = strSchema.guid();
|
||||
strSchema = strSchema.hex();
|
||||
strSchema = strSchema.hostname();
|
||||
strSchema = strSchema.isoDate();
|
||||
strSchema = strSchema.lowercase();
|
||||
strSchema = strSchema.uppercase();
|
||||
strSchema = strSchema.trim();
|
||||
|
||||
namespace common {
|
||||
strSchema = strSchema.allow(x);
|
||||
strSchema = strSchema.allow(x, x);
|
||||
strSchema = strSchema.allow([x, x, x]);
|
||||
strSchema = strSchema.valid(x);
|
||||
strSchema = strSchema.valid(x, x);
|
||||
strSchema = strSchema.valid([x, x, x]);
|
||||
strSchema = strSchema.only(x);
|
||||
strSchema = strSchema.only(x, x);
|
||||
strSchema = strSchema.only([x, x, x]);
|
||||
strSchema = strSchema.equal(x);
|
||||
strSchema = strSchema.equal(x, x);
|
||||
strSchema = strSchema.equal([x, x, x]);
|
||||
strSchema = strSchema.invalid(x);
|
||||
strSchema = strSchema.invalid(x, x);
|
||||
strSchema = strSchema.invalid([x, x, x]);
|
||||
strSchema = strSchema.disallow(x);
|
||||
strSchema = strSchema.disallow(x, x);
|
||||
strSchema = strSchema.disallow([x, x, x]);
|
||||
strSchema = strSchema.not(x);
|
||||
strSchema = strSchema.not(x, x);
|
||||
strSchema = strSchema.not([x, x, x]);
|
||||
|
||||
strSchema = strSchema.default(x);
|
||||
|
||||
strSchema = strSchema.required();
|
||||
strSchema = strSchema.optional();
|
||||
strSchema = strSchema.forbidden();
|
||||
|
||||
strSchema = strSchema.description(str);
|
||||
strSchema = strSchema.notes(str);
|
||||
strSchema = strSchema.notes(strArr);
|
||||
strSchema = strSchema.tags(str);
|
||||
strSchema = strSchema.tags(strArr);
|
||||
|
||||
strSchema = strSchema.meta(obj);
|
||||
strSchema = strSchema.example(obj);
|
||||
strSchema = strSchema.unit(str);
|
||||
|
||||
strSchema = strSchema.options(validOpts);
|
||||
strSchema = strSchema.strict();
|
||||
strSchema = strSchema.concat(x);
|
||||
|
||||
altSchema = strSchema.when(str, whenOpts);
|
||||
altSchema = strSchema.when(ref, whenOpts);
|
||||
}
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
schema = Joi.alternatives(schemaArr);
|
||||
schema = Joi.alternatives(schema, anySchema, boolSchema);
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
Joi.validate(value, obj);
|
||||
Joi.validate(value, schema);
|
||||
Joi.validate(value, schema, validOpts);
|
||||
Joi.validate(value, schema, validOpts, (err, value) => {
|
||||
x = value;
|
||||
str = err.message;
|
||||
str = err.details[0].path;
|
||||
str = err.details[0].message;
|
||||
str = err.details[0].type;
|
||||
});
|
||||
Joi.validate(value, schema, (err, value) => {
|
||||
x = value;
|
||||
str = err.message;
|
||||
str = err.details[0].path;
|
||||
str = err.details[0].message;
|
||||
str = err.details[0].type;
|
||||
});
|
||||
// variant
|
||||
Joi.validate(num, schema, validOpts, (err, value) => {
|
||||
num = value;
|
||||
});
|
||||
|
||||
// plain opts
|
||||
Joi.validate(value, {});
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
schema = Joi.compile(obj);
|
||||
|
||||
Joi.assert(obj, schema);
|
||||
Joi.assert(obj, schema, str);
|
||||
Joi.assert(obj, schema, err);
|
||||
|
||||
ref = Joi.ref(str, refOpts);
|
||||
ref = Joi.ref(str);
|
||||
778
joi/joi-6.5.0.d.ts
vendored
Normal file
778
joi/joi-6.5.0.d.ts
vendored
Normal file
@@ -0,0 +1,778 @@
|
||||
// Type definitions for joi v6.5.0
|
||||
// Project: https://github.com/spumko/joi
|
||||
// Definitions by: Bart van der Schoor <https://github.com/Bartvds>, Laurence Dougal Myers <https://github.com/laurence-myers>, Christopher Glantschnig <https://github.com/cglantschnig>, David Broder-Rodgers <https://github.com/DavidBR-SW>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
|
||||
// TODO express type of Schema in a type-parameter (.default, .valid, .example etc)
|
||||
|
||||
declare module 'joi' {
|
||||
|
||||
export interface ValidationOptions {
|
||||
/**
|
||||
* when true, stops validation on the first error, otherwise returns all the errors found. Defaults to true.
|
||||
*/
|
||||
abortEarly?: boolean;
|
||||
/**
|
||||
* when true, attempts to cast values to the required types (e.g. a string to a number). Defaults to true.
|
||||
*/
|
||||
convert?: boolean;
|
||||
/**
|
||||
* when true, allows object to contain unknown keys which are ignored. Defaults to false.
|
||||
*/
|
||||
allowUnknown?: boolean;
|
||||
/**
|
||||
* when true, ignores unknown keys with a function value. Defaults to false.
|
||||
*/
|
||||
skipFunctions?: boolean;
|
||||
/**
|
||||
* when true, unknown keys are deleted (only when value is an object). Defaults to false.
|
||||
*/
|
||||
stripUnknown?: boolean;
|
||||
/**
|
||||
* overrides individual error messages. Defaults to no override ({}).
|
||||
*/
|
||||
language?: Object;
|
||||
/**
|
||||
* sets the default presence requirements. Supported modes: 'optional', 'required', and 'forbidden'. Defaults to 'optional'.
|
||||
*/
|
||||
presence?: string;
|
||||
/**
|
||||
* provides an external data set to be used in references
|
||||
*/
|
||||
context?: Object;
|
||||
}
|
||||
|
||||
export interface RenameOptions {
|
||||
/**
|
||||
* if true, does not delete the old key name, keeping both the new and old keys in place. Defaults to false.
|
||||
*/
|
||||
alias?: boolean;
|
||||
/**
|
||||
* if true, allows renaming multiple keys to the same destination where the last rename wins. Defaults to false.
|
||||
*/
|
||||
multiple?: boolean;
|
||||
/**
|
||||
* if true, allows renaming a key over an existing key. Defaults to false.
|
||||
*/
|
||||
override?: boolean;
|
||||
/**
|
||||
* if true, skip renaming of a key if it's undefined. Defaults to false.
|
||||
*/
|
||||
ignoreUndefined?: boolean;
|
||||
}
|
||||
|
||||
export interface EmailOptions {
|
||||
/**
|
||||
* Numerical threshold at which an email address is considered invalid
|
||||
*/
|
||||
errorLevel?: number | boolean;
|
||||
/**
|
||||
* Specifies a list of acceptable TLDs.
|
||||
*/
|
||||
tldWhitelist?: string[] | Object;
|
||||
/**
|
||||
* Number of atoms required for the domain. Be careful since some domains, such as io, directly allow email.
|
||||
*/
|
||||
minDomainAtoms?: number;
|
||||
}
|
||||
|
||||
export interface IpOptions {
|
||||
/**
|
||||
* One or more IP address versions to validate against. Valid values: ipv4, ipv6, ipvfuture
|
||||
*/
|
||||
version ?: string | string[];
|
||||
/**
|
||||
* Used to determine if a CIDR is allowed or not. Valid values: optional, required, forbidden
|
||||
*/
|
||||
cidr?: string;
|
||||
}
|
||||
|
||||
export interface UriOptions {
|
||||
/**
|
||||
* Specifies one or more acceptable Schemes, should only include the scheme name.
|
||||
* Can be an Array or String (strings are automatically escaped for use in a Regular Expression).
|
||||
*/
|
||||
scheme ?: string | RegExp | Array<string | RegExp>;
|
||||
}
|
||||
|
||||
export interface WhenOptions<T> {
|
||||
/**
|
||||
* the required condition joi type.
|
||||
*/
|
||||
is: T;
|
||||
/**
|
||||
* the alternative schema type if the condition is true. Required if otherwise is missing.
|
||||
*/
|
||||
then?: Schema;
|
||||
/**
|
||||
* the alternative schema type if the condition is false. Required if then is missing
|
||||
*/
|
||||
otherwise?: Schema;
|
||||
}
|
||||
|
||||
export interface ReferenceOptions {
|
||||
separator?: string;
|
||||
contextPrefix?: string;
|
||||
}
|
||||
|
||||
export interface IPOptions {
|
||||
version?: Array<string>;
|
||||
cidr?: string
|
||||
}
|
||||
|
||||
export interface ValidationError extends Error {
|
||||
message: string;
|
||||
details: ValidationErrorItem[];
|
||||
simple(): string;
|
||||
annotated(): string;
|
||||
}
|
||||
|
||||
export interface ValidationErrorItem {
|
||||
message: string;
|
||||
type: string;
|
||||
path: string;
|
||||
options?: ValidationOptions;
|
||||
}
|
||||
|
||||
export interface ValidationResult<T> {
|
||||
error: ValidationError;
|
||||
value: T;
|
||||
}
|
||||
|
||||
export interface SchemaMap {
|
||||
[key: string]: Schema;
|
||||
}
|
||||
|
||||
export interface Schema extends AnySchema<Schema> {
|
||||
|
||||
}
|
||||
|
||||
export interface Reference extends Schema {
|
||||
|
||||
}
|
||||
|
||||
export interface AnySchema<T extends AnySchema<Schema>> {
|
||||
/**
|
||||
* Whitelists a value
|
||||
*/
|
||||
allow(value: any, ...values: any[]): T;
|
||||
allow(values: any[]): T;
|
||||
|
||||
/**
|
||||
* Adds the provided values into the allowed whitelist and marks them as the only valid values allowed.
|
||||
*/
|
||||
valid(value: any, ...values: any[]): T;
|
||||
valid(values: any[]): T;
|
||||
only(value: any, ...values : any[]): T;
|
||||
only(values: any[]): T;
|
||||
equal(value: any, ...values : any[]): T;
|
||||
equal(values: any[]): T;
|
||||
|
||||
/**
|
||||
* Blacklists a value
|
||||
*/
|
||||
invalid(value: any, ...values: any[]): T;
|
||||
invalid(values: any[]): T;
|
||||
disallow(value: any, ...values : any[]): T;
|
||||
disallow(values: any[]): T;
|
||||
not(value: any, ...values : any[]): T;
|
||||
not(values: any[]): T;
|
||||
|
||||
/**
|
||||
* Marks a key as required which will not allow undefined as value. All keys are optional by default.
|
||||
*/
|
||||
required(): T;
|
||||
|
||||
/**
|
||||
* Marks a key as optional which will allow undefined as values. Used to annotate the schema for readability as all keys are optional by default.
|
||||
*/
|
||||
optional(): T;
|
||||
|
||||
/**
|
||||
* Marks a key as forbidden which will not allow any value except undefined. Used to explicitly forbid keys.
|
||||
*/
|
||||
forbidden(): T;
|
||||
|
||||
/**
|
||||
* Marks a key to be removed from a resulting object or array after validation. Used to sanitize output.
|
||||
*/
|
||||
strip(): T;
|
||||
|
||||
/**
|
||||
* Annotates the key
|
||||
*/
|
||||
description(desc: string): T;
|
||||
|
||||
/**
|
||||
* Annotates the key
|
||||
*/
|
||||
notes(notes: string): T;
|
||||
notes(notes: string[]): T;
|
||||
|
||||
/**
|
||||
* Annotates the key
|
||||
*/
|
||||
tags(notes: string): T;
|
||||
tags(notes: string[]): T;
|
||||
|
||||
/**
|
||||
* Attaches metadata to the key.
|
||||
*/
|
||||
meta(meta: Object): T;
|
||||
|
||||
/**
|
||||
* Annotates the key with an example value, must be valid.
|
||||
*/
|
||||
example(value: any): T;
|
||||
|
||||
/**
|
||||
* Annotates the key with an unit name.
|
||||
*/
|
||||
unit(name: string): T;
|
||||
|
||||
/**
|
||||
* Overrides the global validate() options for the current key and any sub-key.
|
||||
*/
|
||||
options(options: ValidationOptions): T;
|
||||
|
||||
/**
|
||||
* Sets the options.convert options to false which prevent type casting for the current key and any child keys.
|
||||
*/
|
||||
strict(isStrict?: boolean): T;
|
||||
|
||||
/**
|
||||
* Sets a default value if the original value is undefined.
|
||||
* @param value - the value.
|
||||
* value supports references.
|
||||
* value may also be a function which returns the default value.
|
||||
* If value is specified as a function that accepts a single parameter, that parameter will be a context
|
||||
* object that can be used to derive the resulting value. This clones the object however, which incurs some
|
||||
* overhead so if you don't need access to the context define your method so that it does not accept any
|
||||
* parameters.
|
||||
* Without any value, default has no effect, except for object that will then create nested defaults
|
||||
* (applying inner defaults of that object).
|
||||
*
|
||||
* Note that if value is an object, any changes to the object after default() is called will change the
|
||||
* reference and any future assignment.
|
||||
*
|
||||
* Additionally, when specifying a method you must either have a description property on your method or the
|
||||
* second parameter is required.
|
||||
*/
|
||||
default(value: any, description?: string): T;
|
||||
default(): T;
|
||||
|
||||
/**
|
||||
* Returns a new type that is the result of adding the rules of one type to another.
|
||||
*/
|
||||
concat(schema: T): T;
|
||||
|
||||
/**
|
||||
* Converts the type into an alternatives type where the conditions are merged into the type definition where:
|
||||
*/
|
||||
when<U>(ref: string, options: WhenOptions<U>): AlternativesSchema;
|
||||
when<U>(ref: Reference, options: WhenOptions<U>): AlternativesSchema;
|
||||
|
||||
/**
|
||||
* Overrides the key name in error messages.
|
||||
*/
|
||||
label(name: string): T;
|
||||
|
||||
/**
|
||||
* Outputs the original untouched value instead of the casted value.
|
||||
*/
|
||||
raw(isRaw?: boolean): T;
|
||||
|
||||
/**
|
||||
* Considers anything that matches the schema to be empty (undefined).
|
||||
* @param schema - any object or joi schema to match. An undefined schema unsets that rule.
|
||||
*/
|
||||
empty(schema?: any) : T;
|
||||
}
|
||||
|
||||
export interface BooleanSchema extends AnySchema<BooleanSchema> {
|
||||
|
||||
}
|
||||
|
||||
export interface NumberSchema extends AnySchema<NumberSchema> {
|
||||
/**
|
||||
* Specifies the minimum value.
|
||||
* It can also be a reference to another field.
|
||||
*/
|
||||
min(limit: number): NumberSchema;
|
||||
min(limit: Reference): NumberSchema;
|
||||
|
||||
/**
|
||||
* Specifies the maximum value.
|
||||
* It can also be a reference to another field.
|
||||
*/
|
||||
max(limit: number): NumberSchema;
|
||||
max(limit: Reference): NumberSchema;
|
||||
|
||||
/**
|
||||
* Specifies that the value must be greater than limit.
|
||||
* It can also be a reference to another field.
|
||||
*/
|
||||
greater(limit: number): NumberSchema;
|
||||
greater(limit: Reference): NumberSchema;
|
||||
|
||||
/**
|
||||
* Specifies that the value must be less than limit.
|
||||
* It can also be a reference to another field.
|
||||
*/
|
||||
less(limit: number): NumberSchema;
|
||||
less(limit: Reference): NumberSchema;
|
||||
|
||||
/**
|
||||
* Requires the number to be an integer (no floating point).
|
||||
*/
|
||||
integer(): NumberSchema;
|
||||
|
||||
/**
|
||||
* Specifies the maximum number of decimal places where:
|
||||
* limit - the maximum number of decimal places allowed.
|
||||
*/
|
||||
precision(limit: number): NumberSchema;
|
||||
|
||||
/**
|
||||
* Specifies that the value must be a multiple of base.
|
||||
*/
|
||||
multiple(base: number): NumberSchema;
|
||||
|
||||
/**
|
||||
* Requires the number to be positive.
|
||||
*/
|
||||
positive(): NumberSchema;
|
||||
|
||||
/**
|
||||
* Requires the number to be negative.
|
||||
*/
|
||||
negative(): NumberSchema;
|
||||
}
|
||||
|
||||
export interface StringSchema extends AnySchema<StringSchema> {
|
||||
/**
|
||||
* Allows the value to match any whitelist of blacklist item in a case insensitive comparison.
|
||||
*/
|
||||
insensitive(): StringSchema;
|
||||
|
||||
/**
|
||||
* Specifies the minimum number string characters.
|
||||
* @param limit - the minimum number of string characters required. It can also be a reference to another field.
|
||||
* @param encoding - if specified, the string length is calculated in bytes using the provided encoding.
|
||||
*/
|
||||
min(limit: number, encoding?: string): StringSchema;
|
||||
min(limit: Reference, encoding?: string): StringSchema;
|
||||
|
||||
/**
|
||||
* Specifies the maximum number of string characters.
|
||||
* @param limit - the maximum number of string characters allowed. It can also be a reference to another field.
|
||||
* @param encoding - if specified, the string length is calculated in bytes using the provided encoding.
|
||||
*/
|
||||
max(limit: number, encoding?: string): StringSchema;
|
||||
max(limit: Reference, encoding?: string): StringSchema;
|
||||
|
||||
/**
|
||||
* Requires the number to be a credit card number (Using Lunh Algorithm).
|
||||
*/
|
||||
creditCard(): StringSchema;
|
||||
|
||||
/**
|
||||
* Specifies the exact string length required
|
||||
* @param limit - the required string length. It can also be a reference to another field.
|
||||
* @param encoding - if specified, the string length is calculated in bytes using the provided encoding.
|
||||
*/
|
||||
length(limit: number, encoding?: string): StringSchema;
|
||||
length(limit: Reference, encoding?: string): StringSchema;
|
||||
|
||||
/**
|
||||
* Defines a regular expression rule.
|
||||
* @param pattern - a regular expression object the string value must match against.
|
||||
* @param name - optional name for patterns (useful with multiple patterns). Defaults to 'required'.
|
||||
*/
|
||||
regex(pattern: RegExp, name?: string): StringSchema;
|
||||
|
||||
/**
|
||||
* Replace characters matching the given pattern with the specified replacement string where:
|
||||
* @param pattern - a regular expression object to match against, or a string of which all occurrences will be replaced.
|
||||
* @param replacement - the string that will replace the pattern.
|
||||
*/
|
||||
replace(pattern: RegExp, replacement: string): StringSchema;
|
||||
replace(pattern: string, replacement: string): StringSchema;
|
||||
|
||||
/**
|
||||
* Requires the string value to only contain a-z, A-Z, and 0-9.
|
||||
*/
|
||||
alphanum(): StringSchema;
|
||||
|
||||
/**
|
||||
* Requires the string value to only contain a-z, A-Z, 0-9, and underscore _.
|
||||
*/
|
||||
token(): StringSchema;
|
||||
|
||||
/**
|
||||
* Requires the string value to be a valid email address.
|
||||
*/
|
||||
email(options?: EmailOptions): StringSchema;
|
||||
|
||||
/**
|
||||
* Requires the string value to be a valid ip address.
|
||||
*/
|
||||
ip(options?: IpOptions): StringSchema;
|
||||
|
||||
/**
|
||||
* Requires the string value to be a valid RFC 3986 URI.
|
||||
*/
|
||||
uri(options?: UriOptions): StringSchema;
|
||||
|
||||
/**
|
||||
* Requires the string value to be a valid GUID.
|
||||
*/
|
||||
guid(): StringSchema;
|
||||
|
||||
/**
|
||||
* Requires the string value to be a valid hexadecimal string.
|
||||
*/
|
||||
hex(): StringSchema;
|
||||
|
||||
/**
|
||||
* Requires the string value to be a valid hostname as per RFC1123.
|
||||
*/
|
||||
hostname(): StringSchema;
|
||||
|
||||
/**
|
||||
* Requires the string value to be in valid ISO 8601 date format.
|
||||
*/
|
||||
isoDate(): StringSchema;
|
||||
|
||||
/**
|
||||
* Requires the string value to be all lowercase. If the validation convert option is on (enabled by default), the string will be forced to lowercase.
|
||||
*/
|
||||
lowercase(): StringSchema;
|
||||
|
||||
/**
|
||||
* Requires the string value to be all uppercase. If the validation convert option is on (enabled by default), the string will be forced to uppercase.
|
||||
*/
|
||||
uppercase(): StringSchema;
|
||||
|
||||
/**
|
||||
* Requires the string value to contain no whitespace before or after. If the validation convert option is on (enabled by default), the string will be trimmed.
|
||||
*/
|
||||
trim(): StringSchema;
|
||||
}
|
||||
|
||||
export interface ArraySchema extends AnySchema<ArraySchema> {
|
||||
/**
|
||||
* Allow this array to be sparse.
|
||||
* enabled can be used with a falsy value to go back to the default behavior.
|
||||
*/
|
||||
sparse(enabled?: any): ArraySchema;
|
||||
|
||||
/**
|
||||
* Allow single values to be checked against rules as if it were provided as an array.
|
||||
* enabled can be used with a falsy value to go back to the default behavior.
|
||||
*/
|
||||
single(enabled?: any): ArraySchema;
|
||||
|
||||
/**
|
||||
* List the types allowed for the array values.
|
||||
* type can be an array of values, or multiple values can be passed as individual arguments.
|
||||
* If a given type is .required() then there must be a matching item in the array.
|
||||
* If a type is .forbidden() then it cannot appear in the array.
|
||||
* Required items can be added multiple times to signify that multiple items must be found.
|
||||
* Errors will contain the number of items that didn't match.
|
||||
* Any unmatched item having a label will be mentioned explicitly.
|
||||
*
|
||||
* @param type - a joi schema object to validate each array item against.
|
||||
*/
|
||||
items(type: Schema, ...types: Schema[]): ArraySchema;
|
||||
items(types: Schema[]): ArraySchema;
|
||||
|
||||
/**
|
||||
* Specifies the minimum number of items in the array.
|
||||
*/
|
||||
min(limit: number): ArraySchema;
|
||||
|
||||
/**
|
||||
* Specifies the maximum number of items in the array.
|
||||
*/
|
||||
max(limit: number): ArraySchema;
|
||||
|
||||
/**
|
||||
* Specifies the exact number of items in the array.
|
||||
*/
|
||||
length(limit: number): ArraySchema;
|
||||
|
||||
/**
|
||||
* Requires the array values to be unique.
|
||||
* Be aware that a deep equality is performed on elements of the array having a type of object,
|
||||
* a performance penalty is to be expected for this kind of operation.
|
||||
*/
|
||||
unique(): ArraySchema;
|
||||
}
|
||||
|
||||
export interface ObjectSchema extends AnySchema<ObjectSchema> {
|
||||
/**
|
||||
* Sets the allowed object keys.
|
||||
*/
|
||||
keys(schema?: SchemaMap): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Specifies the minimum number of keys in the object.
|
||||
*/
|
||||
min(limit: number): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Specifies the maximum number of keys in the object.
|
||||
*/
|
||||
max(limit: number): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Specifies the exact number of keys in the object.
|
||||
*/
|
||||
length(limit: number): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Specify validation rules for unknown keys matching a pattern.
|
||||
*/
|
||||
pattern(regex: RegExp, schema: Schema): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Defines an all-or-nothing relationship between keys where if one of the peers is present, all of them are required as well.
|
||||
* @param peers - the key names of which if one present, all are required. peers can be a single string value,
|
||||
* an array of string values, or each peer provided as an argument.
|
||||
*/
|
||||
and(peer1: string, ...peers: string[]): ObjectSchema;
|
||||
and(peers: string[]): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Defines a relationship between keys where not all peers can be present at the same time.
|
||||
* @param peers - the key names of which if one present, the others may not all be present.
|
||||
* peers can be a single string value, an array of string values, or each peer provided as an argument.
|
||||
*/
|
||||
nand(peer1: string, ...peers: string[]): ObjectSchema;
|
||||
nand(peers: string[]): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Defines a relationship between keys where one of the peers is required (and more than one is allowed).
|
||||
*/
|
||||
or(peer1: string, ...peers: string[]): ObjectSchema;
|
||||
or(peers: string[]): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Defines an exclusive relationship between a set of keys. one of them is required but not at the same time where:
|
||||
*/
|
||||
xor(peer1: string, ...peers: string[]): ObjectSchema;
|
||||
xor(peers: string[]): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Requires the presence of other keys whenever the specified key is present.
|
||||
*/
|
||||
with(key: string, peers: string): ObjectSchema;
|
||||
with(key: string, peers: string[]): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Forbids the presence of other keys whenever the specified is present.
|
||||
*/
|
||||
without(key: string, peers: string): ObjectSchema;
|
||||
without(key: string, peers: string[]): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Renames a key to another name (deletes the renamed key).
|
||||
*/
|
||||
rename(from: string, to: string, options?: RenameOptions): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Verifies an assertion where.
|
||||
*/
|
||||
assert(ref: string, schema: Schema, message?: string): ObjectSchema;
|
||||
assert(ref: Reference, schema: Schema, message?: string): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Overrides the handling of unknown keys for the scope of the current object only (does not apply to children).
|
||||
*/
|
||||
unknown(allow?: boolean): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Requires the object to be an instance of a given constructor.
|
||||
*
|
||||
* @param constructor - the constructor function that the object must be an instance of.
|
||||
* @param name - an alternate name to use in validation errors. This is useful when the constructor function does not have a name.
|
||||
*/
|
||||
type(constructor: Function, name?: string): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Sets the specified children to required.
|
||||
*
|
||||
* @param children - can be a single string value, an array of string values, or each child provided as an argument.
|
||||
*
|
||||
* var schema = Joi.object().keys({ a: { b: Joi.number() }, c: { d: Joi.string() } });
|
||||
* var requiredSchema = schema.requiredKeys('', 'a.b', 'c', 'c.d');
|
||||
*
|
||||
* Note that in this example '' means the current object, a is not required but b is, as well as c and d.
|
||||
*/
|
||||
requiredKeys(children: string): ObjectSchema;
|
||||
requiredKeys(children: string[]): ObjectSchema;
|
||||
requiredKeys(child:string, ...children: string[]): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Sets the specified children to optional.
|
||||
*
|
||||
* @param children - can be a single string value, an array of string values, or each child provided as an argument.
|
||||
*
|
||||
* The behavior is exactly the same as requiredKeys.
|
||||
*/
|
||||
optionalKeys(children: string): ObjectSchema;
|
||||
optionalKeys(children: string[]): ObjectSchema;
|
||||
optionalKeys(child:string, ...children: string[]): ObjectSchema;
|
||||
}
|
||||
|
||||
export interface BinarySchema extends AnySchema<BinarySchema> {
|
||||
/**
|
||||
* Sets the string encoding format if a string input is converted to a buffer.
|
||||
*/
|
||||
encoding(encoding: string): BinarySchema;
|
||||
|
||||
/**
|
||||
* Specifies the minimum length of the buffer.
|
||||
*/
|
||||
min(limit: number): BinarySchema;
|
||||
|
||||
/**
|
||||
* Specifies the maximum length of the buffer.
|
||||
*/
|
||||
max(limit: number): BinarySchema;
|
||||
|
||||
/**
|
||||
* Specifies the exact length of the buffer:
|
||||
*/
|
||||
length(limit: number): BinarySchema;
|
||||
}
|
||||
|
||||
export interface DateSchema extends AnySchema<DateSchema> {
|
||||
|
||||
/**
|
||||
* Specifies the oldest date allowed.
|
||||
* Notes: 'now' can be passed in lieu of date so as to always compare relatively to the current date,
|
||||
* allowing to explicitly ensure a date is either in the past or in the future.
|
||||
* It can also be a reference to another field.
|
||||
*/
|
||||
min(date: Date): DateSchema;
|
||||
min(date: number): DateSchema;
|
||||
min(date: string): DateSchema;
|
||||
min(date: Reference): DateSchema;
|
||||
|
||||
/**
|
||||
* Specifies the latest date allowed.
|
||||
* Notes: 'now' can be passed in lieu of date so as to always compare relatively to the current date,
|
||||
* allowing to explicitly ensure a date is either in the past or in the future.
|
||||
* It can also be a reference to another field.
|
||||
*/
|
||||
max(date: Date): DateSchema;
|
||||
max(date: number): DateSchema;
|
||||
max(date: string): DateSchema;
|
||||
max(date: Reference): DateSchema;
|
||||
|
||||
/**
|
||||
* Specifies the allowed date format:
|
||||
* @param format - string or array of strings that follow the moment.js format.
|
||||
*/
|
||||
format(format: string): DateSchema;
|
||||
format(format: string[]): DateSchema;
|
||||
|
||||
/**
|
||||
* Requires the string value to be in valid ISO 8601 date format.
|
||||
*/
|
||||
iso(): DateSchema;
|
||||
}
|
||||
|
||||
export interface FunctionSchema extends AnySchema<FunctionSchema> {
|
||||
|
||||
}
|
||||
|
||||
export interface AlternativesSchema extends AnySchema<FunctionSchema> {
|
||||
try(schemas: Schema[]): AlternativesSchema;
|
||||
when<T>(ref: string, options: WhenOptions<T>): AlternativesSchema;
|
||||
when<T>(ref: Reference, options: WhenOptions<T>): AlternativesSchema;
|
||||
}
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
/**
|
||||
* Generates a schema object that matches any data type.
|
||||
*/
|
||||
export function any(): Schema;
|
||||
|
||||
/**
|
||||
* Generates a schema object that matches an array data type.
|
||||
*/
|
||||
export function array(): ArraySchema;
|
||||
|
||||
/**
|
||||
* Generates a schema object that matches a boolean data type (as well as the strings 'true', 'false', 'yes', and 'no'). Can also be called via bool().
|
||||
*/
|
||||
export function bool(): BooleanSchema;
|
||||
|
||||
export function boolean(): BooleanSchema;
|
||||
|
||||
/**
|
||||
* Generates a schema object that matches a Buffer data type (as well as the strings which will be converted to Buffers).
|
||||
*/
|
||||
export function binary(): BinarySchema;
|
||||
|
||||
/**
|
||||
* Generates a schema object that matches a date type (as well as a JavaScript date string or number of milliseconds).
|
||||
*/
|
||||
export function date(): DateSchema;
|
||||
|
||||
/**
|
||||
* Generates a schema object that matches a function type.
|
||||
*/
|
||||
export function func(): FunctionSchema;
|
||||
|
||||
/**
|
||||
* Generates a schema object that matches a number data type (as well as strings that can be converted to numbers).
|
||||
*/
|
||||
export function number(): NumberSchema;
|
||||
|
||||
/**
|
||||
* Generates a schema object that matches an object data type (as well as JSON strings that parsed into objects).
|
||||
*/
|
||||
export function object(schema?: SchemaMap): ObjectSchema;
|
||||
|
||||
/**
|
||||
* Generates a schema object that matches a string data type. Note that empty strings are not allowed by default and must be enabled with allow('').
|
||||
*/
|
||||
export function string(): StringSchema;
|
||||
|
||||
/**
|
||||
* Generates a type that will match one of the provided alternative schemas
|
||||
*/
|
||||
export function alternatives(types: Schema[]): Schema;
|
||||
export function alternatives(type1: Schema, type2: Schema, ...types: Schema[]): Schema;
|
||||
|
||||
/**
|
||||
* Validates a value using the given schema and options.
|
||||
*/
|
||||
export function validate<T>(value: T, schema: Schema, callback: (err: ValidationError, value: T) => void): void;
|
||||
export function validate<T>(value: T, schema: Object, callback: (err: ValidationError, value: T) => void): void;
|
||||
export function validate<T>(value: T, schema: Object, options?: ValidationOptions, callback?: (err: ValidationError, value: T) => void): ValidationResult<T>;
|
||||
|
||||
/**
|
||||
* Converts literal schema definition to joi schema object (or returns the same back if already a joi schema object).
|
||||
*/
|
||||
export function compile(schema: Object): Schema;
|
||||
|
||||
/**
|
||||
* Validates a value against a schema and throws if validation fails.
|
||||
*
|
||||
* @param value - the value to validate.
|
||||
* @param schema - the schema object.
|
||||
* @param message - optional message string prefix added in front of the error message. may also be an Error object.
|
||||
*/
|
||||
export function assert(value: any, schema: Schema, message?: string | Error): void;
|
||||
|
||||
/**
|
||||
* Generates a reference to the value of the named key.
|
||||
*/
|
||||
export function ref(key: string, options?: ReferenceOptions): Reference;
|
||||
}
|
||||
@@ -231,16 +231,18 @@ arrSchema = arrSchema.sparse();
|
||||
arrSchema = arrSchema.sparse(bool);
|
||||
arrSchema = arrSchema.single();
|
||||
arrSchema = arrSchema.single(bool);
|
||||
arrSchema = arrSchema.ordered(anySchema);
|
||||
arrSchema = arrSchema.ordered(anySchema, numSchema, strSchema, arrSchema, boolSchema, binSchema, dateSchema, funcSchema, objSchema);
|
||||
arrSchema = arrSchema.min(num);
|
||||
arrSchema = arrSchema.max(num);
|
||||
arrSchema = arrSchema.length(num);
|
||||
arrSchema = arrSchema.unique();
|
||||
|
||||
|
||||
arrSchema = arrSchema.items(numSchema);
|
||||
arrSchema = arrSchema.items(numSchema, strSchema);
|
||||
arrSchema = arrSchema.items([numSchema, strSchema]);
|
||||
|
||||
|
||||
// - - - - - - - -
|
||||
|
||||
namespace common_copy_paste {
|
||||
@@ -420,6 +422,10 @@ dateSchema = dateSchema.format(strArr);
|
||||
|
||||
dateSchema = dateSchema.iso();
|
||||
|
||||
dateSchema = dateSchema.timestamp();
|
||||
dateSchema = dateSchema.timestamp('javascript');
|
||||
dateSchema = dateSchema.timestamp('unix');
|
||||
|
||||
namespace common {
|
||||
dateSchema = dateSchema.allow(x);
|
||||
dateSchema = dateSchema.allow(x, x);
|
||||
@@ -471,6 +477,11 @@ namespace common {
|
||||
|
||||
funcSchema = Joi.func();
|
||||
|
||||
funcSchema = funcSchema.arity(num);
|
||||
funcSchema = funcSchema.minArity(num);
|
||||
funcSchema = funcSchema.maxArity(num);
|
||||
funcSchema = funcSchema.ref();
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
numSchema = Joi.number();
|
||||
@@ -770,5 +781,15 @@ Joi.assert(obj, schema);
|
||||
Joi.assert(obj, schema, str);
|
||||
Joi.assert(obj, schema, err);
|
||||
|
||||
Joi.attempt(obj, schema);
|
||||
Joi.attempt(obj, schema, str);
|
||||
Joi.attempt(obj, schema, err);
|
||||
|
||||
ref = Joi.ref(str, refOpts);
|
||||
ref = Joi.ref(str);
|
||||
|
||||
Joi.isRef(ref);
|
||||
|
||||
schema = Joi.reach(schema, '');
|
||||
|
||||
const Joi2 = Joi.extend({ name: '', base: schema });
|
||||
|
||||
101
joi/joi.d.ts
vendored
101
joi/joi.d.ts
vendored
@@ -1,6 +1,6 @@
|
||||
// Type definitions for joi v6.5.0
|
||||
// Project: https://github.com/spumko/joi
|
||||
// Definitions by: Bart van der Schoor <https://github.com/Bartvds>, Laurence Dougal Myers <https://github.com/laurence-myers>, Christopher Glantschnig <https://github.com/cglantschnig>, David Broder-Rodgers <https://github.com/DavidBR-SW>
|
||||
// Type definitions for joi v9.0.0
|
||||
// Project: https://github.com/hapijs/joi
|
||||
// Definitions by: Bart van der Schoor <https://github.com/Bartvds>, Laurence Dougal Myers <https://github.com/laurence-myers>, Christopher Glantschnig <https://github.com/cglantschnig>, David Broder-Rodgers <https://github.com/DavidBR-SW>, Gael Magnan de Bornier <hhttps://github.com/GaelMagnan>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
|
||||
// TODO express type of Schema in a type-parameter (.default, .valid, .example etc)
|
||||
@@ -487,6 +487,13 @@ declare module 'joi' {
|
||||
items(type: Schema, ...types: Schema[]): ArraySchema;
|
||||
items(types: Schema[]): ArraySchema;
|
||||
|
||||
/**
|
||||
* Lists the types in sequence order for the array values where:
|
||||
* @param type - a joi schema object to validate against each array item in sequence order. type can be an array of values, or multiple values can be passed as individual arguments.
|
||||
* If a given type is .required() then there must be a matching item with the same index position in the array. Errors will contain the number of items that didn't match. Any unmatched item having a label will be mentioned explicitly.
|
||||
*/
|
||||
ordered(type: Schema, ...types: Schema[]): ArraySchema;
|
||||
|
||||
/**
|
||||
* Specifies the minimum number of items in the array.
|
||||
*/
|
||||
@@ -683,10 +690,41 @@ declare module 'joi' {
|
||||
* Requires the string value to be in valid ISO 8601 date format.
|
||||
*/
|
||||
iso(): DateSchema;
|
||||
|
||||
|
||||
/**
|
||||
* Requires the value to be a timestamp interval from Unix Time.
|
||||
* @param type - the type of timestamp (allowed values are unix or javascript [default])
|
||||
*/
|
||||
timestamp(type?: 'javascript' | 'unix'): DateSchema;
|
||||
}
|
||||
|
||||
export interface FunctionSchema extends AnySchema<FunctionSchema> {
|
||||
|
||||
/**
|
||||
* Specifies the arity of the function where:
|
||||
* @param n - the arity expected.
|
||||
*/
|
||||
arity(n: number): FunctionSchema;
|
||||
|
||||
|
||||
/**
|
||||
* Specifies the minimal arity of the function where:
|
||||
* @param n - the minimal arity expected.
|
||||
*/
|
||||
minArity(n: number): FunctionSchema;
|
||||
|
||||
|
||||
/**
|
||||
* Specifies the minimal arity of the function where:
|
||||
* @param n - the minimal arity expected.
|
||||
*/
|
||||
maxArity(n: number): FunctionSchema;
|
||||
|
||||
/**
|
||||
* Requires the function to be a Joi reference.
|
||||
*/
|
||||
ref(): FunctionSchema;
|
||||
}
|
||||
|
||||
export interface AlternativesSchema extends AnySchema<FunctionSchema> {
|
||||
@@ -695,6 +733,33 @@ declare module 'joi' {
|
||||
when<T>(ref: Reference, options: WhenOptions<T>): AlternativesSchema;
|
||||
}
|
||||
|
||||
export interface Terms {
|
||||
value: any;
|
||||
state: {
|
||||
key: string,
|
||||
path: string,
|
||||
parent: any
|
||||
};
|
||||
options: ValidationOptions;
|
||||
}
|
||||
|
||||
export interface Rules {
|
||||
name: string;
|
||||
params?: ObjectSchema | { [key: string]: Schema };
|
||||
setup?: Function;
|
||||
validate?: Function;
|
||||
description: string | Function;
|
||||
}
|
||||
|
||||
export interface Extension {
|
||||
name: string;
|
||||
base?: Schema;
|
||||
pre?: Function;
|
||||
language?: {};
|
||||
describe?: Function;
|
||||
rules?: Rules[];
|
||||
}
|
||||
|
||||
// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
|
||||
|
||||
/**
|
||||
@@ -771,8 +836,38 @@ declare module 'joi' {
|
||||
*/
|
||||
export function assert(value: any, schema: Schema, message?: string | Error): void;
|
||||
|
||||
|
||||
/**
|
||||
* Validates a value against a schema, returns valid object, and throws if validation fails where:
|
||||
*
|
||||
* @param value - the value to validate.
|
||||
* @param schema - the schema object.
|
||||
* @param message - optional message string prefix added in front of the error message. may also be an Error object.
|
||||
*/
|
||||
export function attempt(value: any, schema: Schema, message?: string | Error): void;
|
||||
|
||||
|
||||
/**
|
||||
* Generates a reference to the value of the named key.
|
||||
*/
|
||||
export function ref(key: string, options?: ReferenceOptions): Reference;
|
||||
|
||||
|
||||
/**
|
||||
* Checks whether or not the provided argument is a reference. It's especially useful if you want to post-process error messages.
|
||||
*/
|
||||
export function isRef(ref: any): boolean;
|
||||
|
||||
|
||||
/**
|
||||
* Get a sub-schema of an existing schema based on a path. Path separator is a dot (.).
|
||||
*/
|
||||
export function reach(schema: Schema, path: string): Schema;
|
||||
|
||||
|
||||
/**
|
||||
* Creates a new Joi instance customized with the extension(s) you provide included.
|
||||
*/
|
||||
export function extend(extention: Extension): any;
|
||||
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user