(comparator?: (a: T, b: T) => boolean): this;
+}
+
+export interface ObjectSchema extends AnySchema {
+ /**
+ * Sets or extends the allowed object keys.
+ */
+ keys(schema?: SchemaMap): this;
+
+ /**
+ * Appends the allowed object keys. If schema is null, undefined, or {}, no changes will be applied.
+ */
+ append(schema?: SchemaMap): this;
+
+ /**
+ * Specifies the minimum number of keys in the object.
+ */
+ min(limit: number): this;
+
+ /**
+ * Specifies the maximum number of keys in the object.
+ */
+ max(limit: number): this;
+
+ /**
+ * Specifies the exact number of keys in the object.
+ */
+ length(limit: number): this;
+
+ /**
+ * Specify validation rules for unknown keys matching a pattern.
+ *
+ * @param pattern - a pattern that can be either a regular expression or a joi schema that will be tested against the unknown key names
+ * @param schema - the schema object matching keys must validate against
+ */
+ pattern(pattern: RegExp | SchemaLike, schema: SchemaLike): this;
+
+ /**
+ * 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(...peers: string[]): this;
+ and(peers: string[]): this;
+
+ /**
+ * 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(...peers: string[]): this;
+ nand(peers: string[]): this;
+
+ /**
+ * Defines a relationship between keys where one of the peers is required (and more than one is allowed).
+ */
+ or(...peers: string[]): this;
+ or(peers: string[]): this;
+
+ /**
+ * Defines an exclusive relationship between a set of keys. one of them is required but not at the same time where:
+ */
+ xor(...peers: string[]): this;
+ xor(peers: string[]): this;
+
+ /**
+ * Requires the presence of other keys whenever the specified key is present.
+ */
+ with(key: string, peers: string): this;
+ with(key: string, peers: string[]): this;
+
+ /**
+ * Forbids the presence of other keys whenever the specified is present.
+ */
+ without(key: string, peers: string): this;
+ without(key: string, peers: string[]): this;
+
+ /**
+ * Renames a key to another name (deletes the renamed key).
+ */
+ rename(from: string, to: string, options?: RenameOptions): this;
+
+ /**
+ * Verifies an assertion where.
+ */
+ assert(ref: string, schema: SchemaLike, message?: string): this;
+ assert(ref: Reference, schema: SchemaLike, message?: string): this;
+
+ /**
+ * Overrides the handling of unknown keys for the scope of the current object only (does not apply to children).
+ */
+ unknown(allow?: boolean): this;
+
+ /**
+ * 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): this;
+
+ /**
+ * 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[]): this;
+ requiredKeys(...children: string[]): this;
+
+ /**
+ * 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[]): this;
+ optionalKeys(...children: string[]): this;
+
+ /**
+ * Sets the specified children to forbidden.
+ *
+ * @param children - can be a single string value, an array of string values, or each child provided as an argument.
+ *
+ * const schema = Joi.object().keys({ a: { b: Joi.number().required() }, c: { d: Joi.string().required() } });
+ * const optionalSchema = schema.forbiddenKeys('a.b', 'c.d');
+ *
+ * The behavior is exactly the same as requiredKeys.
+ */
+ forbiddenKeys(children: string[]): this;
+ forbiddenKeys(...children: string[]): this;
+}
+
+export interface BinarySchema extends AnySchema {
+ /**
+ * Sets the string encoding format if a string input is converted to a buffer.
+ */
+ encoding(encoding: string): this;
+
+ /**
+ * Specifies the minimum length of the buffer.
+ */
+ min(limit: number): this;
+
+ /**
+ * Specifies the maximum length of the buffer.
+ */
+ max(limit: number): this;
+
+ /**
+ * Specifies the exact length of the buffer:
+ */
+ length(limit: number): this;
+}
+
+export interface DateSchema extends AnySchema {
+ /**
+ * 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): this;
+ min(date: number): this;
+ min(date: string): this;
+ min(date: Reference): this;
+
+ /**
+ * 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): this;
+ max(date: number): this;
+ max(date: string): this;
+ max(date: Reference): this;
+
+ /**
+ * Specifies the allowed date format:
+ * @param format - string or array of strings that follow the moment.js format.
+ */
+ format(format: string): this;
+ format(format: string[]): this;
+
+ /**
+ * Requires the string value to be in valid ISO 8601 date format.
+ */
+ iso(): this;
+
+ /**
+ * 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'): this;
+}
+
+export interface FunctionSchema extends AnySchema {
+ /**
+ * Specifies the arity of the function where:
+ * @param n - the arity expected.
+ */
+ arity(n: number): this;
+
+ /**
+ * Specifies the minimal arity of the function where:
+ * @param n - the minimal arity expected.
+ */
+ minArity(n: number): this;
+
+ /**
+ * Specifies the minimal arity of the function where:
+ * @param n - the minimal arity expected.
+ */
+ maxArity(n: number): this;
+
+ /**
+ * Requires the function to be a Joi reference.
+ */
+ ref(): this;
+}
+
+export interface AlternativesSchema extends AnySchema {
+ try(types: SchemaLike[]): this;
+ try(...types: SchemaLike[]): this;
+ when(ref: string, options: WhenOptions): this;
+ when(ref: Reference, options: WhenOptions): this;
+ when(ref: Schema, options: WhenSchemaOptions): this;
+}
+
+export interface LazySchema extends AnySchema {
+}
+
+export interface Reference extends JoiObject {
+ (value: any, validationOptions: ValidationOptions): any;
+ isContext: boolean;
+ key: string;
+ path: string;
+ toString(): string;
+}
+
+export type ExtensionBoundSchema = Schema & {
+ /**
+ * Creates a joi error object.
+ * Used in conjunction with custom rules.
+ * @param type - the type of rule to create the error for.
+ * @param context - provide properties that will be available in the `language` templates.
+ * @param state - should the context passed into the `validate` function in a custom rule
+ * @param options - should the context passed into the `validate` function in a custom rule
+ */
+ createError(type: string, context: Context, state: State, options: ValidationOptions): Err;
+};
+
+export interface Rules {
+ name: string;
+ params?: ObjectSchema | {[key in keyof P]: SchemaLike; };
+ setup?(this: ExtensionBoundSchema, params: P): Schema | void;
+ validate?(this: ExtensionBoundSchema, params: P, value: any, state: State, options: ValidationOptions): any;
+ description?: string | ((params: P) => string);
+}
+
+export interface Extension {
+ name: string;
+ base?: Schema;
+ language?: LanguageOptions;
+ coerce?(this: ExtensionBoundSchema, value: any, state: State, options: ValidationOptions): any;
+ pre?(this: ExtensionBoundSchema, value: any, state: State, options: ValidationOptions): any;
+ describe?(this: Schema, description: Description): Description;
+ rules?: Rules[];
+}
+
+export interface Err extends JoiObject {
+ toString(): string;
+}
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+/**
+ * Current version of the joi package.
+ */
+export const version: string;
+
+/**
+ * Generates a schema object that matches any data type.
+ */
+export function any(): AnySchema;
+
+/**
+ * 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 have been 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 schema object that matches any symbol.
+ */
+export function symbol(): SymbolSchema;
+
+/**
+ * Generates a type that will match one of the provided alternative schemas
+ */
+export function alternatives(types: SchemaLike[]): AlternativesSchema;
+export function alternatives(...types: SchemaLike[]): AlternativesSchema;
+
+/**
+ * Alias for `alternatives`
+ */
+export function alt(types: SchemaLike[]): AlternativesSchema;
+export function alt(...types: SchemaLike[]): AlternativesSchema;
+
+/**
+ * Generates a placeholder schema for a schema that you would provide with the fn.
+ * Supports the same methods of the any() type.
+ * This is mostly useful for recursive schemas
+ */
+export function lazy(cb: () => Schema): LazySchema;
+
+/**
+ * Validates a value using the given schema and options.
+ */
+export function validate(value: T, schema: SchemaLike): ValidationResult;
+export function validate(value: T, schema: SchemaLike, callback: (err: ValidationError, value: T) => R): R;
+
+export function validate(value: T, schema: SchemaLike, options: ValidationOptions): ValidationResult;
+export function validate(value: T, schema: SchemaLike, options: ValidationOptions, callback: (err: ValidationError, value: T) => R): R;
+
+/**
+ * Converts literal schema definition to joi schema object (or returns the same back if already a joi schema object).
+ */
+export function compile(schema: SchemaLike): 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: SchemaLike, 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: T, schema: SchemaLike, message?: string | Error): T;
+
+/**
+ * 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): ref is Reference;
+
+/**
+ * Get a sub-schema of an existing schema based on a `path` that can be either a string or an array
+ * of strings For string values path separator is a dot (`.`)
+ */
+export function reach(schema: ObjectSchema, path: string): Schema;
+export function reach(schema: ObjectSchema, path: string[]): Schema;
+
+/**
+ * Creates a new Joi instance customized with the extension(s) you provide included.
+ */
+export function extend(extension: Extension|Extension[], ...extensions: Array): any;
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+import * as Module from 'joi';
+export type Root = typeof Module;
+export type DefaultsFunction = (root: Schema) => Schema;
+
+/**
+ * Creates a new Joi instance that will apply defaults onto newly created schemas
+ * through the use of the fn function that takes exactly one argument, the schema being created.
+ *
+ * @param fn - The function must always return a schema, even if untransformed.
+ */
+export function defaults(fn: DefaultsFunction): Root;
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+// Below are undocumented APIs. use at your own risk
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+/**
+ * Returns a plain object representing the schema's rules and properties
+ */
+export function describe(schema: Schema): Description;
+
+/**
+ * Whitelists a value
+ */
+export function allow(value: any, ...values: any[]): Schema;
+export function allow(values: any[]): Schema;
+
+/**
+ * Adds the provided values into the allowed whitelist and marks them as the only valid values allowed.
+ */
+export function valid(value: any, ...values: any[]): Schema;
+export function valid(values: any[]): Schema;
+export function only(value: any, ...values: any[]): Schema;
+export function only(values: any[]): Schema;
+export function equal(value: any, ...values: any[]): Schema;
+export function equal(values: any[]): Schema;
+
+/**
+ * Blacklists a value
+ */
+export function invalid(value: any, ...values: any[]): Schema;
+export function invalid(values: any[]): Schema;
+export function disallow(value: any, ...values: any[]): Schema;
+export function disallow(values: any[]): Schema;
+export function not(value: any, ...values: any[]): Schema;
+export function not(values: any[]): Schema;
+
+/**
+ * Marks a key as required which will not allow undefined as value. All keys are optional by default.
+ */
+export function required(): Schema;
+
+/**
+ * Alias of `required`.
+ */
+export function exist(): Schema;
+
+/**
+ * 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.
+ */
+export function optional(): Schema;
+
+/**
+ * Marks a key as forbidden which will not allow any value except undefined. Used to explicitly forbid keys.
+ */
+export function forbidden(): Schema;
+
+/**
+ * Marks a key to be removed from a resulting object or array after validation. Used to sanitize output.
+ */
+export function strip(): Schema;
+
+/**
+ * Annotates the key
+ */
+export function description(desc: string): Schema;
+
+/**
+ * Annotates the key
+ */
+export function notes(notes: string): Schema;
+export function notes(notes: string[]): Schema;
+
+/**
+ * Annotates the key
+ */
+export function tags(notes: string): Schema;
+export function tags(notes: string[]): Schema;
+
+/**
+ * Attaches metadata to the key.
+ */
+export function meta(meta: object): Schema;
+
+/**
+ * Annotates the key with an example value, must be valid.
+ */
+export function example(value: any): Schema;
+
+/**
+ * Annotates the key with an unit name.
+ */
+export function unit(name: string): Schema;
+
+/**
+ * Overrides the global validate() options for the current key and any sub-key.
+ */
+export function options(options: ValidationOptions): Schema;
+
+/**
+ * Sets the options.convert options to false which prevent type casting for the current key and any child keys.
+ */
+export function strict(isStrict?: boolean): Schema;
+
+/**
+ * Returns a new type that is the result of adding the rules of one type to another.
+ */
+export function concat(schema: T): T;
+
+/**
+ * Converts the type into an alternatives type where the conditions are merged into the type definition where:
+ */
+export function when(ref: string, options: WhenOptions): AlternativesSchema;
+export function when(ref: Reference, options: WhenOptions): AlternativesSchema;
+export function when(ref: Schema, options: WhenSchemaOptions): AlternativesSchema;
+
+/**
+ * Overrides the key name in error messages.
+ */
+export function label(name: string): Schema;
+
+/**
+ * Outputs the original untouched value instead of the casted value.
+ */
+export function raw(isRaw?: boolean): Schema;
+
+/**
+ * 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.
+ */
+export function empty(schema?: any): Schema;
diff --git a/types/joi/v13/joi-tests.ts b/types/joi/v13/joi-tests.ts
new file mode 100644
index 0000000000..832858c7e9
--- /dev/null
+++ b/types/joi/v13/joi-tests.ts
@@ -0,0 +1,1150 @@
+import Joi = require('joi');
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let x: any = null;
+declare const value: any;
+let num = 0;
+let str = '';
+declare const bool: boolean;
+declare const exp: RegExp;
+declare const obj: object;
+declare const date: Date;
+declare const err: Error;
+declare const func: Function;
+
+declare const numArr: number[];
+declare const strArr: string[];
+declare const expArr: RegExp[];
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let schema: Joi.Schema = null;
+declare const schemaLike: Joi.SchemaLike;
+
+let anySchema: Joi.AnySchema = null;
+let numSchema: Joi.NumberSchema = null;
+let strSchema: Joi.StringSchema = null;
+let arrSchema: Joi.ArraySchema = null;
+let boolSchema: Joi.BooleanSchema = null;
+let binSchema: Joi.BinarySchema = null;
+let dateSchema: Joi.DateSchema = null;
+let funcSchema: Joi.FunctionSchema = null;
+let objSchema: Joi.ObjectSchema = null;
+let altSchema: Joi.AlternativesSchema = null;
+
+declare const schemaArr: Joi.Schema[];
+
+let ref: Joi.Reference = null;
+let description: Joi.Description = null;
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let validOpts: Joi.ValidationOptions = null;
+
+validOpts = { abortEarly: bool };
+validOpts = { convert: bool };
+validOpts = { allowUnknown: bool };
+validOpts = { skipFunctions: bool };
+validOpts = { stripUnknown: bool };
+validOpts = { stripUnknown: { arrays: bool } };
+validOpts = { stripUnknown: { objects: bool } };
+validOpts = { stripUnknown: { arrays: bool, objects: bool } };
+validOpts = { presence: 'optional' || 'required' || 'forbidden' };
+validOpts = { context: obj };
+validOpts = { noDefaults: bool };
+validOpts = {
+ language: {
+ root: str,
+ key: str,
+ messages: { wrapArrays: bool },
+ string: { base: str },
+ number: { base: str },
+ object: {
+ base: false,
+ children: { childRule: str }
+ },
+ customType: {
+ customRule: str
+ }
+ }
+};
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let renOpts: Joi.RenameOptions = null;
+
+renOpts = { alias: bool };
+renOpts = { multiple: bool };
+renOpts = { override: bool };
+renOpts = { ignoreUndefined: bool };
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let emailOpts: Joi.EmailOptions = null;
+
+emailOpts = { errorLevel: num };
+emailOpts = { errorLevel: bool };
+emailOpts = { tldWhitelist: strArr };
+emailOpts = { tldWhitelist: obj };
+emailOpts = { minDomainAtoms: num };
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let hexOpts: Joi.HexOptions = null;
+
+hexOpts = { byteAligned: bool };
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let ipOpts: Joi.IpOptions = null;
+
+ipOpts = { version: str };
+ipOpts = { version: strArr };
+ipOpts = { cidr: str };
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let uriOpts: Joi.UriOptions = null;
+
+uriOpts = { scheme: str };
+uriOpts = { scheme: exp };
+uriOpts = { scheme: strArr };
+uriOpts = { scheme: expArr };
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let base64Opts: Joi.Base64Options = null;
+
+base64Opts = { paddingRequired: bool };
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let dataUriOpts: Joi.DataUriOptions = null;
+
+dataUriOpts = { paddingRequired: bool };
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let whenOpts: Joi.WhenOptions = null;
+
+whenOpts = { is: x };
+whenOpts = { is: schema, then: schema };
+whenOpts = { is: schema, otherwise: schema };
+whenOpts = { is: schemaLike, then: schemaLike, otherwise: schemaLike };
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let whenSchemaOpts: Joi.WhenSchemaOptions = null;
+
+whenSchemaOpts = { then: schema };
+whenSchemaOpts = { otherwise: schema };
+whenSchemaOpts = { then: schemaLike, otherwise: schemaLike };
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let refOpts: Joi.ReferenceOptions = null;
+
+refOpts = { separator: str };
+refOpts = { contextPrefix: str };
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let stringRegexOpts: Joi.StringRegexOptions = null;
+
+stringRegexOpts = { name: str };
+stringRegexOpts = { invert: bool };
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+declare const validErr: Joi.ValidationError;
+let validErrItem: Joi.ValidationErrorItem;
+let validErrFunc: Joi.ValidationErrorFunction;
+
+validErrItem = {
+ message: str,
+ type: str,
+ path: [str]
+};
+
+validErrItem = {
+ message: str,
+ type: str,
+ path: [str],
+ options: validOpts,
+ context: obj
+};
+
+validErrFunc = errs => errs;
+validErrFunc = errs => errs[0];
+validErrFunc = errs => 'Some error';
+validErrFunc = errs => err;
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+schema = anySchema;
+schema = numSchema;
+schema = strSchema;
+schema = arrSchema;
+schema = boolSchema;
+schema = binSchema;
+schema = dateSchema;
+schema = funcSchema;
+schema = objSchema;
+
+anySchema = anySchema;
+anySchema = numSchema;
+anySchema = strSchema;
+anySchema = arrSchema;
+anySchema = boolSchema;
+anySchema = binSchema;
+anySchema = dateSchema;
+anySchema = funcSchema;
+anySchema = objSchema;
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+let schemaMap: Joi.SchemaMap = null;
+
+schemaMap = {
+ a: numSchema,
+ b: strSchema
+};
+schemaMap = {
+ a: numSchema,
+ b: {
+ b1: strSchema,
+ b2: anySchema
+ }
+};
+schemaMap = {
+ a: numSchema,
+ b: [
+ { b1: strSchema },
+ { b2: anySchema }
+ ],
+ c: arrSchema,
+ d: schemaLike
+};
+schemaMap = {
+ a: 1,
+ b: {
+ b1: '1',
+ b2: 2
+ },
+ c: [
+ { c1: true },
+ { c2: null }
+ ]
+};
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+anySchema = Joi.any();
+
+{ // 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);
+ altSchema = anySchema.when(schema, whenSchemaOpts);
+
+ anySchema = anySchema.label(str);
+ anySchema = anySchema.raw();
+ anySchema = anySchema.raw(bool);
+ anySchema = anySchema.empty();
+ anySchema = anySchema.empty(str);
+ anySchema = anySchema.empty(anySchema);
+
+ anySchema = anySchema.error(err);
+ anySchema = anySchema.error(validErrFunc);
+}
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+arrSchema = Joi.array();
+
+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, schemaLike);
+arrSchema = arrSchema.ordered(schemaMap);
+arrSchema = arrSchema.ordered([schemaMap, schemaMap, schemaLike]);
+arrSchema = arrSchema.min(num);
+arrSchema = arrSchema.max(num);
+arrSchema = arrSchema.length(num);
+arrSchema = arrSchema.length(ref);
+arrSchema = arrSchema.unique();
+arrSchema = arrSchema.unique((a, b) => a.test === b.test);
+arrSchema = arrSchema.unique('customer.id');
+
+arrSchema = arrSchema.items(numSchema);
+arrSchema = arrSchema.items(numSchema, strSchema, schemaLike);
+arrSchema = arrSchema.items([numSchema, strSchema, schemaLike]);
+arrSchema = arrSchema.items(schemaMap);
+arrSchema = arrSchema.items(schemaMap, schemaMap, schemaLike);
+arrSchema = arrSchema.items([schemaMap, schemaMap, schemaLike]);
+
+// - - - - - - - -
+
+{ // 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);
+ altSchema = arrSchema.when(schema, whenSchemaOpts);
+}
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+boolSchema = Joi.bool();
+boolSchema = Joi.boolean();
+
+{ // 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);
+
+ boolSchema = boolSchema.truthy(str);
+ boolSchema = boolSchema.truthy(num);
+ boolSchema = boolSchema.truthy(strArr);
+ boolSchema = boolSchema.truthy(numArr);
+ boolSchema = boolSchema.truthy(str, str);
+ boolSchema = boolSchema.truthy(strArr, str);
+ boolSchema = boolSchema.truthy(str, strArr);
+ boolSchema = boolSchema.truthy(strArr, strArr);
+ boolSchema = boolSchema.falsy(str);
+ boolSchema = boolSchema.falsy(num);
+ boolSchema = boolSchema.falsy(strArr);
+ boolSchema = boolSchema.falsy(numArr);
+ boolSchema = boolSchema.falsy(str, str);
+ boolSchema = boolSchema.falsy(strArr, str);
+ boolSchema = boolSchema.falsy(str, strArr);
+ boolSchema = boolSchema.falsy(strArr, strArr);
+ boolSchema = boolSchema.insensitive(bool);
+
+ altSchema = boolSchema.when(str, whenOpts);
+ altSchema = boolSchema.when(ref, whenOpts);
+ altSchema = boolSchema.when(schema, whenSchemaOpts);
+}
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+binSchema = Joi.binary();
+
+binSchema = binSchema.encoding(str);
+binSchema = binSchema.min(num);
+binSchema = binSchema.max(num);
+binSchema = binSchema.length(num);
+
+{ // 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);
+ altSchema = binSchema.when(schema, whenSchemaOpts);
+}
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+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();
+
+dateSchema = dateSchema.timestamp();
+dateSchema = dateSchema.timestamp('javascript');
+dateSchema = dateSchema.timestamp('unix');
+
+{ // 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);
+ altSchema = dateSchema.when(schema, whenSchemaOpts);
+}
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+funcSchema = Joi.func();
+
+funcSchema = funcSchema.arity(num);
+funcSchema = funcSchema.minArity(num);
+funcSchema = funcSchema.maxArity(num);
+funcSchema = funcSchema.ref();
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+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();
+numSchema = numSchema.port();
+
+{ // 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);
+ altSchema = numSchema.when(schema, whenSchemaOpts);
+}
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+objSchema = Joi.object();
+objSchema = Joi.object(schemaMap);
+
+objSchema = objSchema.keys();
+objSchema = objSchema.keys(schemaMap);
+
+objSchema = objSchema.append();
+objSchema = objSchema.append(schemaMap);
+
+objSchema = objSchema.min(num);
+objSchema = objSchema.max(num);
+objSchema = objSchema.length(num);
+
+objSchema = objSchema.pattern(exp, schema);
+objSchema = objSchema.pattern(exp, schemaLike);
+
+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);
+
+objSchema = objSchema.forbiddenKeys(str);
+objSchema = objSchema.forbiddenKeys(str, str);
+objSchema = objSchema.forbiddenKeys(strArr);
+
+{ // 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);
+ altSchema = objSchema.when(schema, whenSchemaOpts);
+}
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+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.regex(exp, stringRegexOpts);
+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.guid({ version: ['uuidv1', 'uuidv2', 'uuidv3', 'uuidv4', 'uuidv5'] });
+strSchema = strSchema.guid({ version: 'uuidv4' });
+strSchema = strSchema.hex();
+strSchema = strSchema.hex(hexOpts);
+strSchema = strSchema.hostname();
+strSchema = strSchema.isoDate();
+strSchema = strSchema.lowercase();
+strSchema = strSchema.uppercase();
+strSchema = strSchema.trim();
+strSchema = strSchema.truncate();
+strSchema = strSchema.truncate(false);
+strSchema = strSchema.normalize();
+strSchema = strSchema.normalize('NFKC');
+strSchema = strSchema.base64();
+strSchema = strSchema.base64(base64Opts);
+strSchema = strSchema.dataUri();
+strSchema = strSchema.dataUri(dataUriOpts);
+
+{ // 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);
+ altSchema = strSchema.when(schema, whenSchemaOpts);
+}
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+schema = Joi.alternatives();
+schema = Joi.alternatives().try(schemaArr);
+schema = Joi.alternatives().try(schema, schema);
+
+schema = Joi.alternatives(schemaArr);
+schema = Joi.alternatives(schema, anySchema, boolSchema);
+
+schema = Joi.alt();
+schema = Joi.alt().try(schemaArr);
+schema = Joi.alt().try(schema, schema);
+
+schema = Joi.alt(schemaArr);
+schema = Joi.alt(schema, anySchema, boolSchema);
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+schema = Joi.lazy(() => schema);
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+{ // validate tests
+ {
+ 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[0];
+ 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.join('.');
+ 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, {});
+ }
+
+ {
+ let value = { username: 'example', password: 'example' };
+ const schema = Joi.object().keys({
+ username: Joi.string().max(255).required(),
+ password: Joi.string().regex(/^[a-zA-Z0-9]{3,255}$/).required(),
+ });
+ let returnValue: Joi.ValidationResult;
+
+ returnValue = schema.validate(value);
+ value = schema.validate(value, (err, value) => value);
+
+ returnValue = Joi.validate(value, schema);
+ returnValue = Joi.validate(value, obj);
+ value = Joi.validate(value, obj, (err, value) => value);
+ value = Joi.validate(value, schema, (err, value) => value);
+
+ returnValue = Joi.validate(value, schema, validOpts);
+ returnValue = Joi.validate(value, obj, validOpts);
+ value = Joi.validate(value, obj, validOpts, (err, value) => value);
+ value = Joi.validate(value, schema, validOpts, (err, value) => value);
+
+ returnValue = schema.validate(value);
+ returnValue = schema.validate(value, validOpts);
+ value = schema.validate(value, (err, value) => value);
+ value = schema.validate(value, validOpts, (err, value) => value);
+
+ returnValue
+ .then(val => JSON.stringify(val, null, 2))
+ .then(val => { throw new Error('one error'); })
+ .catch(e => {});
+ }
+}
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+schema = Joi.compile(obj);
+schema = Joi.compile(schemaMap);
+
+Joi.assert(obj, schema);
+Joi.assert(obj, schema, str);
+Joi.assert(obj, schema, err);
+Joi.assert(obj, schemaLike);
+
+Joi.attempt(obj, schema);
+Joi.attempt(obj, schema, str);
+Joi.attempt(obj, schema, err);
+Joi.attempt(obj, schemaLike);
+
+ref = Joi.ref(str, refOpts);
+ref = Joi.ref(str);
+
+Joi.isRef(ref);
+
+description = Joi.describe(schema);
+description = schema.describe();
+
+schema = Joi.reach(objSchema, '');
+schema = Joi.reach(objSchema, []);
+
+const Joi2 = Joi.extend({ name: '', base: schema });
+
+const Joi3 = Joi.extend({
+ base: Joi.string(),
+ name: 'string',
+ language: {
+ asd: 'must be exactly asd(f)',
+ },
+ pre(value, state, options) {
+ return value;
+ },
+ describe(description) {
+ return description;
+ },
+ rules: [
+ {
+ name: 'asd',
+ params: {
+ allowFalse: Joi.boolean().default(false),
+ },
+ setup(params) {
+ const fIsAllowed = params.allowFalse;
+ },
+ validate(params, value: boolean, state, options) {
+ if (value || params.allowFalse && !value) {
+ return value;
+ }
+ return this.createError('asd', { v: value }, state, options);
+ },
+ },
+ ],
+});
+
+const Joi4 = Joi.extend([{ name: '', base: schema }, { name: '', base: schema }]);
+
+const Joi5 = Joi.extend({ name: '', base: schema }, { name: '', base: schema });
+
+const Joi6 = Joi.extend({ name: '', base: schema }, [{ name: '', base: schema }, { name: '', base: schema }]);
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+const defaultsJoi = Joi.defaults((schema) => {
+ switch (schema.schemaType) {
+ case 'string':
+ return schema.allow('');
+ case 'object':
+ return (schema as Joi.ObjectSchema).min(1);
+ default:
+ return schema;
+ }
+});
+
+schema = Joi.allow(x, x);
+schema = Joi.allow([x, x, x]);
+schema = Joi.valid(x);
+schema = Joi.valid(x, x);
+schema = Joi.valid([x, x, x]);
+schema = Joi.only(x);
+schema = Joi.only(x, x);
+schema = Joi.only([x, x, x]);
+schema = Joi.equal(x);
+schema = Joi.equal(x, x);
+schema = Joi.equal([x, x, x]);
+schema = Joi.invalid(x);
+schema = Joi.invalid(x, x);
+schema = Joi.invalid([x, x, x]);
+schema = Joi.disallow(x);
+schema = Joi.disallow(x, x);
+schema = Joi.disallow([x, x, x]);
+schema = Joi.not(x);
+schema = Joi.not(x, x);
+schema = Joi.not([x, x, x]);
+
+schema = Joi.required();
+schema = Joi.optional();
+schema = Joi.forbidden();
+schema = Joi.strip();
+
+schema = Joi.description(str);
+schema = Joi.notes(str);
+schema = Joi.notes(strArr);
+schema = Joi.tags(str);
+schema = Joi.tags(strArr);
+
+schema = Joi.meta(obj);
+schema = Joi.example(obj);
+schema = Joi.unit(str);
+
+schema = Joi.options(validOpts);
+schema = Joi.strict();
+schema = Joi.strict(bool);
+schema = Joi.concat(x);
+
+schema = Joi.when(str, whenOpts);
+schema = Joi.when(ref, whenOpts);
+schema = Joi.when(schema, whenSchemaOpts);
+
+schema = Joi.label(str);
+schema = Joi.raw();
+schema = Joi.raw(bool);
+schema = Joi.empty();
+schema = Joi.empty(str);
+schema = Joi.empty(anySchema);
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+schema = Joi.allow(x, x);
+schema = Joi.allow([x, x, x]);
+schema = Joi.valid(x);
+schema = Joi.valid(x, x);
+schema = Joi.valid([x, x, x]);
+schema = Joi.only(x);
+schema = Joi.only(x, x);
+schema = Joi.only([x, x, x]);
+schema = Joi.equal(x);
+schema = Joi.equal(x, x);
+schema = Joi.equal([x, x, x]);
+schema = Joi.invalid(x);
+schema = Joi.invalid(x, x);
+schema = Joi.invalid([x, x, x]);
+schema = Joi.disallow(x);
+schema = Joi.disallow(x, x);
+schema = Joi.disallow([x, x, x]);
+schema = Joi.not(x);
+schema = Joi.not(x, x);
+schema = Joi.not([x, x, x]);
+
+schema = Joi.required();
+schema = Joi.exist();
+schema = Joi.optional();
+schema = Joi.forbidden();
+schema = Joi.strip();
+
+schema = Joi.description(str);
+schema = Joi.notes(str);
+schema = Joi.notes(strArr);
+schema = Joi.tags(str);
+schema = Joi.tags(strArr);
+
+schema = Joi.meta(obj);
+schema = Joi.example(obj);
+schema = Joi.unit(str);
+
+schema = Joi.options(validOpts);
+schema = Joi.strict();
+schema = Joi.strict(bool);
+schema = Joi.concat(x);
+
+schema = Joi.when(str, whenOpts);
+schema = Joi.when(ref, whenOpts);
+schema = Joi.when(schema, whenSchemaOpts);
+
+schema = Joi.label(str);
+schema = Joi.raw();
+schema = Joi.raw(bool);
+schema = Joi.empty();
+schema = Joi.empty(str);
+schema = Joi.empty(anySchema);
+
+schema = Joi.symbol();
+schema = Joi.symbol().map(new Map());
+schema = Joi.symbol().map({
+ key: Symbol('asd'),
+});
diff --git a/types/joi/v13/tsconfig.json b/types/joi/v13/tsconfig.json
new file mode 100644
index 0000000000..30da076bfb
--- /dev/null
+++ b/types/joi/v13/tsconfig.json
@@ -0,0 +1,28 @@
+{
+ "compilerOptions": {
+ "module": "commonjs",
+ "lib": [
+ "es6"
+ ],
+ "noImplicitAny": true,
+ "noImplicitThis": true,
+ "strictNullChecks": false,
+ "strictFunctionTypes": true,
+ "baseUrl": "../../",
+ "typeRoots": [
+ "../../"
+ ],
+ "types": [],
+ "paths": {
+ "joi": [
+ "joi/v13"
+ ]
+ },
+ "noEmit": true,
+ "forceConsistentCasingInFileNames": true
+ },
+ "files": [
+ "index.d.ts",
+ "joi-tests.ts"
+ ]
+}
diff --git a/types/joi/v13/tslint.json b/types/joi/v13/tslint.json
new file mode 100644
index 0000000000..c6e5f080fb
--- /dev/null
+++ b/types/joi/v13/tslint.json
@@ -0,0 +1,10 @@
+{
+ "extends": "dtslint/dt.json",
+ "rules": {
+ // All are TODOs
+ "ban-types": false,
+ "no-empty-interface": false,
+ "no-self-import": false,
+ "unified-signatures": false
+ }
+}
diff --git a/types/makeup-expander/index.d.ts b/types/makeup-expander/index.d.ts
new file mode 100644
index 0000000000..90bd660581
--- /dev/null
+++ b/types/makeup-expander/index.d.ts
@@ -0,0 +1,46 @@
+// Type definitions for makeup-expander 0.4
+// Project: https://github.com/makeup-js/makeup-expander
+// Definitions by: Timur Manyanov
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.6
+
+declare namespace Expander {
+ interface Options {
+ autoCollapse?: boolean;
+ collapseOnClickOut?: boolean;
+ collapseOnFocusOut?: boolean;
+ collapseOnMouseOut?: boolean;
+ contentSelector?: string;
+ expandOnClick?: boolean;
+ expandOnFocus?: boolean;
+ expandOnHover?: boolean;
+ focusManagement?: string | null;
+ hostSelector?: string;
+ }
+}
+
+declare class Expander {
+ constructor(el: HTMLElement, selectedOptions?: Expander.Options);
+
+ collapseOnClickOut: boolean;
+
+ collapseOnFocusOut: boolean;
+
+ collapseOnMouseOut: boolean;
+
+ expandOnClick: boolean;
+
+ expandOnFocus: boolean;
+
+ expandOnHover: boolean;
+
+ collapse(): void;
+
+ expand(isKeyboard: boolean): void;
+
+ isExpanded(): boolean;
+
+ toggle(): void;
+}
+
+export = Expander;
diff --git a/types/makeup-expander/makeup-expander-tests.ts b/types/makeup-expander/makeup-expander-tests.ts
new file mode 100644
index 0000000000..f35d7cd3bd
--- /dev/null
+++ b/types/makeup-expander/makeup-expander-tests.ts
@@ -0,0 +1,21 @@
+import Expander = require('makeup-expander');
+
+const widgetEl: HTMLElement | null = document.querySelector('.expander');
+
+const options: Expander.Options = {
+ expandOnClick: true
+};
+
+if (widgetEl) {
+ // $ExpectType Expander
+ new Expander(widgetEl);
+
+ // $ExpectType Expander
+ const widget = new Expander(widgetEl, options);
+
+ // $ExpectType void
+ widget.expand(true);
+
+ // $ExpectType boolean
+ const expanded = widget.isExpanded();
+}
diff --git a/types/makeup-expander/tsconfig.json b/types/makeup-expander/tsconfig.json
new file mode 100644
index 0000000000..f247e79d82
--- /dev/null
+++ b/types/makeup-expander/tsconfig.json
@@ -0,0 +1,22 @@
+{
+ "compilerOptions": {
+ "module": "commonjs",
+ "lib": [
+ "es6",
+ "dom"
+ ],
+ "noImplicitAny": true,
+ "noImplicitThis": true,
+ "strictNullChecks": true,
+ "strictFunctionTypes": true,
+ "baseUrl": "../",
+ "typeRoots": ["../"],
+ "types": [],
+ "noEmit": true,
+ "forceConsistentCasingInFileNames": true
+ },
+ "files": [
+ "index.d.ts",
+ "makeup-expander-tests.ts"
+ ]
+}
diff --git a/types/makeup-expander/tslint.json b/types/makeup-expander/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/makeup-expander/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/mongoose/index.d.ts b/types/mongoose/index.d.ts
index 58522f752c..79b5c553fb 100644
--- a/types/mongoose/index.d.ts
+++ b/types/mongoose/index.d.ts
@@ -1121,7 +1121,7 @@ declare module "mongoose" {
* Takes a populated field and returns it to its unpopulated state.
* If the path was not populated, this is a no-op.
*/
- depopulate(path: string): this;
+ depopulate(path?: string): this;
/**
* Returns true if the Document stores the same data as doc.
@@ -1556,7 +1556,7 @@ declare module "mongoose" {
* been using Query, we set it as an alias of DocumentQuery.
*/
class Query extends DocumentQuery { }
- class DocumentQuery extends mquery {
+ class DocumentQuery extends mquery {
/**
* Specifies a javascript function or expression to pass to MongoDBs query system.
* Only use $where when you have a condition that cannot be met using other MongoDB
@@ -1636,8 +1636,8 @@ declare module "mongoose" {
* Specifying this query as a count query. Passing a callback executes the query.
* @param criteria mongodb selector
*/
- count(callback?: (err: any, count: number) => void): Query;
- count(criteria: any, callback?: (err: any, count: number) => void): Query;
+ count(callback?: (err: any, count: number) => void): Query & QueryHelpers;
+ count(criteria: any, callback?: (err: any, count: number) => void): Query & QueryHelpers;
/**
* Specifies this query as a `countDocuments()` query. Behaves like `count()`,
@@ -1658,8 +1658,8 @@ declare module "mongoose" {
* @param {Function} [callback] optional params are (error, count)
* @return {Query} this
*/
- countDocuments(callback?: (err: any, count: number) => void): Query;
- countDocuments(criteria: any, callback?: (err: any, count: number) => void): Query;
+ countDocuments(callback?: (err: any, count: number) => void): Query & QueryHelpers;
+ countDocuments(criteria: any, callback?: (err: any, count: number) => void): Query & QueryHelpers;
/**
* Estimates the number of documents in the MongoDB collection. Faster than
@@ -1671,8 +1671,8 @@ declare module "mongoose" {
* @param {Function} [callback] optional params are (error, count)
* @return {Query} this
*/
- estimatedDocumentCount(callback?: (err: any, count: number) => void): Query;
- estimatedDocumentCount(options: any, callback?: (err: any, count: number) => void): Query;
+ estimatedDocumentCount(callback?: (err: any, count: number) => void): Query & QueryHelpers;
+ estimatedDocumentCount(options: any, callback?: (err: any, count: number) => void): Query & QueryHelpers;
/**
* Returns a wrapper around a mongodb driver cursor. A QueryCursor exposes a
@@ -1681,10 +1681,10 @@ declare module "mongoose" {
cursor(options?: any): QueryCursor;
/** Declares or executes a distict() operation. Passing a callback executes the query. */
- distinct(callback?: (err: any, res: any[]) => void): Query;
- distinct(field: string, callback?: (err: any, res: any[]) => void): Query;
+ distinct(callback?: (err: any, res: any[]) => void): Query & QueryHelpers;
+ distinct(field: string, callback?: (err: any, res: any[]) => void): Query & QueryHelpers;
distinct(field: string, criteria: any | Query,
- callback?: (err: any, res: any[]) => void): Query;
+ callback?: (err: any, res: any[]) => void): Query & QueryHelpers;
/** Specifies an $elemMatch condition */
elemMatch(criteria: (elem: Query) => void): this;
@@ -1708,9 +1708,9 @@ declare module "mongoose" {
* query is executed, the result will be an array of documents.
* @param criteria mongodb selector
*/
- find(callback?: (err: any, res: DocType[]) => void): DocumentQuery;
+ find(callback?: (err: any, res: DocType[]) => void): DocumentQuery & QueryHelpers;
find(criteria: any,
- callback?: (err: any, res: DocType[]) => void): DocumentQuery;
+ callback?: (err: any, res: DocType[]) => void): DocumentQuery & QueryHelpers;
/**
* Declares the query a findOne operation. When executed, the first found document is
@@ -1719,36 +1719,36 @@ declare module "mongoose" {
* @param criteria mongodb selector
* @param projection optional fields to return
*/
- findOne(callback?: (err: any, res: DocType | null) => void): DocumentQuery;
+ findOne(callback?: (err: any, res: DocType | null) => void): DocumentQuery & QueryHelpers;
findOne(criteria: any,
- callback?: (err: any, res: DocType | null) => void): DocumentQuery;
+ callback?: (err: any, res: DocType | null) => void): DocumentQuery & QueryHelpers;
/**
* Issues a mongodb findAndModify remove command.
* Finds a matching document, removes it, passing the found document (if any) to the
* callback. Executes immediately if callback is passed.
*/
- findOneAndRemove(callback?: (error: any, doc: DocType | null, result: any) => void): DocumentQuery;
+ findOneAndRemove(callback?: (error: any, doc: DocType | null, result: any) => void): DocumentQuery & QueryHelpers;
findOneAndRemove(conditions: any,
- callback?: (error: any, doc: DocType | null, result: any) => void): DocumentQuery;
+ callback?: (error: any, doc: DocType | null, result: any) => void): DocumentQuery & QueryHelpers;
findOneAndRemove(conditions: any, options: QueryFindOneAndRemoveOptions,
- callback?: (error: any, doc: DocType | null, result: any) => void): DocumentQuery;
+ callback?: (error: any, doc: DocType | null, result: any) => void): DocumentQuery & QueryHelpers;
/**
* Issues a mongodb findAndModify update command.
* Finds a matching document, updates it according to the update arg, passing any options, and returns
* the found document (if any) to the callback. The query executes immediately if callback is passed.
*/
- findOneAndUpdate(callback?: (err: any, doc: DocType | null) => void): DocumentQuery;
+ findOneAndUpdate(callback?: (err: any, doc: DocType | null) => void): DocumentQuery & QueryHelpers;
findOneAndUpdate(update: any,
- callback?: (err: any, doc: DocType | null, res: any) => void): DocumentQuery;
+ callback?: (err: any, doc: DocType | null, res: any) => void): DocumentQuery