mirror of
https://github.com/zhigang1992/DefinitelyTyped.git
synced 2026-05-24 13:59:25 +08:00
773 lines
22 KiB
TypeScript
773 lines
22 KiB
TypeScript
/// <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 = null;
|
|
|
|
whenOpts = {is: schema};
|
|
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();
|
|
|
|
module 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]);
|
|
|
|
|
|
// - - - - - - - -
|
|
|
|
module 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();
|
|
|
|
module 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);
|
|
|
|
module 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();
|
|
|
|
module 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();
|
|
|
|
module 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, str);
|
|
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);
|
|
|
|
module 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();
|
|
|
|
module 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);
|