(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/mongoose/index.d.ts b/types/mongoose/index.d.ts
index 58522f752c..7d31585d32 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.
diff --git a/types/n3/index.d.ts b/types/n3/index.d.ts
index 75a8c4efef..0c8c992030 100644
--- a/types/n3/index.d.ts
+++ b/types/n3/index.d.ts
@@ -2,6 +2,7 @@
// Project: https://github.com/RubenVerborgh/N3.js
// Definitions by: Fred Eisele
// Ruben Taelman
+// Laurens Rietveld
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
@@ -16,91 +17,119 @@ export interface Prefixes {
[key: string]: I;
}
+export type Term = NamedNode | BlankNode | Literal | Variable | DefaultGraph;
export type PrefixedToIri = (suffix: string) => RDF.NamedNode;
-export class Term implements RDF.Term {
- termType: "NamedNode" | "BlankNode" | "Literal" | "Variable" | "DefaultGraph";
- id: string;
+export class NamedNode implements RDF.NamedNode {
+ termType: "NamedNode";
value: string;
constructor(iri: string);
- toJSON(): string;
+ id: string;
+ toJSON(): {};
equals(other: RDF.Term): boolean;
static subclass(type: any): void;
}
-export class NamedNode extends Term implements RDF.NamedNode {
- termType: "NamedNode";
- value: string;
- constructor(iri: string);
-}
-
-export class BlankNode extends Term implements RDF.BlankNode {
+export class BlankNode implements RDF.BlankNode {
static nextId: number;
termType: "BlankNode";
value: string;
constructor(name: string);
+ id: string;
+ toJSON(): {};
+ equals(other: RDF.Term): boolean;
+ static subclass(type: any): void;
}
-export class Variable extends Term implements RDF.Variable {
+export class Variable implements RDF.Variable {
termType: "Variable";
value: string;
constructor(name: string);
+ id: string;
+ toJSON(): {};
+ equals(other: RDF.Term): boolean;
+ static subclass(type: any): void;
}
-export class Literal extends Term implements RDF.Literal {
+export class Literal implements RDF.Literal {
static readonly langStringDatatype: NamedNode;
termType: "Literal";
value: string;
+ id: string;
+ toJSON(): {};
+ equals(other: RDF.Term): boolean;
+ static subclass(type: any): void;
language: string;
- datatype: RDF.NamedNode;
+ datatype: NamedNode;
datatypeString: string;
constructor(id: string);
}
-export class DefaultGraph extends Term implements RDF.DefaultGraph {
+export class DefaultGraph implements RDF.DefaultGraph {
termType: "DefaultGraph";
value: "";
constructor();
+ id: string;
+ toJSON(): {};
+ equals(other: RDF.Term): boolean;
+ static subclass(type: any): void;
}
-export class Quad implements RDF.Quad {
- constructor(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, graph?: RDF.Term);
- subject: RDF.Term;
- predicate: RDF.Term;
- object: RDF.Term;
- graph: RDF.Term;
- equals(other: RDF.Quad): boolean;
+export type Quad_Subject = NamedNode | BlankNode | Variable;
+export type Quad_Predicate = NamedNode | Variable;
+export type Quad_Object = NamedNode | Literal | BlankNode | Variable;
+export type Quad_Graph = DefaultGraph | NamedNode | BlankNode | Variable;
+
+export class BaseQuad implements RDF.BaseQuad {
+ constructor(subject: Term, predicate: Term, object: Term, graph?: Term);
+ subject: Term;
+ predicate: Term;
+ object: Term;
+ graph: Term;
+ equals(other: RDF.BaseQuad): boolean;
+ toJSON(): string;
+}
+
+export class Quad extends BaseQuad implements RDF.Quad {
+ constructor(subject: Term, predicate: Term, object: Term, graph?: Term);
+ subject: Quad_Subject;
+ predicate: Quad_Predicate;
+ object: Quad_Object;
+ graph: Quad_Graph;
+ equals(other: RDF.BaseQuad): boolean;
toJSON(): string;
}
export class Triple extends Quad implements RDF.Triple {}
export namespace DataFactory {
- function namedNode(value: string): RDF.NamedNode;
- function blankNode(value?: string): RDF.BlankNode;
- function literal(value: string | number, languageOrDatatype?: string | RDF.NamedNode): RDF.Literal;
- function variable(value: string): RDF.Variable;
- function defaultGraph(): RDF.DefaultGraph;
- function triple(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term): RDF.Quad;
- function quad(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, graph?: RDF.Term): RDF.Quad;
+ function namedNode(value: string): NamedNode;
+ function blankNode(value?: string): BlankNode;
+ function literal(value: string | number, languageOrDatatype?: string | RDF.NamedNode): Literal;
+ function variable(value: string): Variable;
+ function defaultGraph(): DefaultGraph;
+ function quad(subject: RDF.Quad_Subject, predicate: RDF.Quad_Predicate, object: RDF.Quad_Object, graph?: RDF.Quad_Graph): Quad;
+ function quad(subject: Q_In['subject'], predicate: Q_In['predicate'], object: Q_In['object'], graph?: Q_In['graph']): Q_Out;
+ function triple(subject: RDF.Quad_Subject, predicate: RDF.Quad_Predicate, object: RDF.Quad_Object): Quad;
+ function triple(subject: Q_In['subject'], predicate: Q_In['predicate'], object: Q_In['object']): Q_Out;
}
export type ErrorCallback = (err: Error, result: any) => void;
-export type QuadCallback = (result: Quad) => void;
-export type QuadPredicate = (result: Quad) => boolean;
+export type QuadCallback = (result: Q) => void;
+export type QuadPredicate = (result: Q) => boolean;
export type OTerm = RDF.Term | string | null;
export type Logger = (message?: any, ...optionalParams: any[]) => void;
-export interface BlankTriple {
- predicate: RDF.Term;
- object: RDF.Term;
+export interface BlankTriple {
+ predicate: Q['predicate'];
+ object: Q['object'];
}
export interface ParserConstructor {
- new (options?: ParserOptions): N3Parser;
- (options?: ParserOptions): N3Parser;
+ new (options?: ParserOptions): N3Parser;
+ (options?: ParserOptions): N3Parser;
}
export const Parser: ParserConstructor;
@@ -111,19 +140,19 @@ export interface ParserOptions {
baseIRI?: string;
}
-export type ParseCallback = (error: Error, quad: Quad, prefixes: Prefixes) => void;
+export type ParseCallback = (error: Error, quad: Q, prefixes: Prefixes) => void;
-export interface N3Parser {
- parse(input: string, callback: ParseCallback): void;
+export interface N3Parser {
+ parse(input: string, callback: ParseCallback): void;
}
export interface StreamParserConstructor {
- new (options?: ParserOptions): N3StreamParser;
- (options?: ParserOptions): N3StreamParser;
+ new (options?: ParserOptions): N3StreamParser;
+ (options?: ParserOptions): N3StreamParser;
}
export const StreamParser: StreamParserConstructor;
-export interface N3StreamParser extends RDF.Stream, NodeJS.WritableStream, RDF.Sink {
+export interface N3StreamParser extends RDF.Stream, NodeJS.WritableStream, RDF.Sink {
// Below are the NodeJS.ReadableStream methods,
// we can not extend the interface directly,
// as `read` clashes with RDF.Sink.
@@ -133,10 +162,10 @@ export interface N3StreamParser extends RDF.Stream, NodeJS.WritableStream, RDF.S
pause(): this;
resume(): this;
isPaused(): boolean;
- pipe(destination: T, options?: { end?: boolean; }): T;
- unpipe(destination?: NodeJS.WritableStream | RDF.Stream): void;
+ pipe>(destination: T, options?: { end?: boolean; }): T;
+ unpipe(destination?: NodeJS.WritableStream | RDF.Stream): void;
unshift(chunk: string | Buffer): void;
- wrap(oldStream: NodeJS.ReadableStream | RDF.Stream): NodeJS.ReadableStream;
+ wrap(oldStream: NodeJS.ReadableStream | RDF.Stream): NodeJS.ReadableStream;
}
export interface WriterOptions {
@@ -146,66 +175,66 @@ export interface WriterOptions {
}
export interface WriterConstructor {
- new (options?: WriterOptions): N3Writer;
- new (fd: any, options?: WriterOptions): N3Writer;
- (options?: WriterOptions): N3Writer;
- (fd: any, options?: WriterOptions): N3Writer;
+ new (options?: WriterOptions): N3Writer;
+ new (fd: any, options?: WriterOptions): N3Writer;
+ (options?: WriterOptions): N3Writer;
+ (fd: any, options?: WriterOptions): N3Writer;
}
export const Writer: WriterConstructor;
-export interface N3Writer {
- quadToString(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, graph?: RDF.Term): string;
+export interface N3Writer {
+ quadToString(subject: Q['subject'], predicate: Q['predicate'], object: Q['object'], graph?: Q['graph']): string;
quadsToString(quads: RDF.Quad[]): string;
- addQuad(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term | RDF.Term[], graph?: RDF.Term, done?: () => void): void;
+ addQuad(subject: Q['subject'], predicate: Q['predicate'], object: Q['object'] | Array, graph?: Q['graph'], done?: () => void): void;
addQuad(quad: RDF.Quad): void;
addQuads(quads: RDF.Quad[]): void;
addPrefix(prefix: string, iri: RDF.NamedNode | string , done?: () => void): void;
addPrefixes(prefixes: Prefixes, done?: () => void): void;
end(err?: ErrorCallback, result?: string): void;
- blank(predicate: RDF.Term, object: RDF.Term): RDF.Term;
- blank(triple: BlankTriple | RDF.Quad | BlankTriple[] | RDF.Quad[]): RDF.Term;
- list(triple: RDF.Term[]): RDF.Term[];
+ blank(predicate: Q['predicate'], object: Q['object']): BlankNode;
+ blank(triple: BlankTriple | RDF.Quad | BlankTriple[] | RDF.Quad[]): BlankNode;
+ list(triple: Array): Quad_Object[];
}
export interface StreamWriterConstructor {
- new (options?: WriterOptions): N3StreamWriter;
- new (fd: any, options?: WriterOptions): N3StreamWriter;
- (options?: WriterOptions): N3StreamWriter;
- (fd: any, options?: WriterOptions): N3StreamWriter;
+ new (options?: WriterOptions): N3StreamWriter;
+ new (fd: any, options?: WriterOptions): N3StreamWriter;
+ (options?: WriterOptions): N3StreamWriter;
+ (fd: any, options?: WriterOptions): N3StreamWriter;
}
export const StreamWriter: StreamWriterConstructor;
-export interface N3StreamWriter extends NodeJS.ReadWriteStream, RDF.Source {}
+export interface N3StreamWriter extends NodeJS.ReadWriteStream, RDF.Source {}
-export interface N3Store extends RDF.Sink {
+export interface N3Store extends RDF.Sink {
readonly size: number;
- addQuad(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term | RDF.Term[], graph?: RDF.Term, done?: () => void): void;
- addQuad(quad: RDF.Quad): void;
- addQuads(quads: RDF.Quad[]): void;
- removeQuad(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term | RDF.Term[], graph?: RDF.Term, done?: () => void): void;
- removeQuad(quad: RDF.Quad): void;
- removeQuads(quads: RDF.Quad[]): void;
+ addQuad(subject: Q_RDF['subject'], predicate: Q_RDF['predicate'], object: Q_RDF['object'] | Array, graph?: Q_RDF['graph'], done?: () => void): void;
+ addQuad(quad: Q_RDF): void;
+ addQuads(quads: Q_RDF[]): void;
+ removeQuad(subject: Q_RDF['subject'], predicate: Q_RDF['predicate'], object: Q_RDF['object'] | Array, graph?: Q_RDF['graph'], done?: () => void): void;
+ removeQuad(quad: Q_RDF): void;
+ removeQuads(quads: Q_RDF[]): void;
getQuads(subject: OTerm, predicate: OTerm, object: OTerm | OTerm[], graph: OTerm): Quad[];
countQuads(subject: OTerm, predicate: OTerm, object: OTerm, graph: OTerm): number;
- forEach(callback: QuadCallback, subject: OTerm, predicate: OTerm, object: OTerm, graph: OTerm): void;
- every(callback: QuadPredicate, subject: OTerm, predicate: OTerm, object: OTerm, graph: OTerm): boolean;
- some(callback: QuadPredicate, subject: OTerm, predicate: OTerm, object: OTerm, graph: OTerm): boolean;
- getSubjects(predicate: OTerm, object: OTerm, graph: OTerm): RDF.Term[];
- forSubjects(callback: QuadCallback, predicate: OTerm, object: OTerm, graph: OTerm): void;
- getPredicates(subject: OTerm, object: OTerm, graph: OTerm): RDF.Term[];
- forPredicates(callback: QuadCallback, subject: OTerm, object: OTerm, graph: OTerm): void;
- getObjects(subject: OTerm, predicate: OTerm, graph: OTerm): RDF.Term[];
- forObjects(callback: QuadCallback, subject: OTerm, predicate: OTerm, graph: OTerm): void;
- getGraphs(subject: OTerm, predicate: OTerm, object: OTerm): RDF.Term[];
- forGraphs(callback: QuadCallback, subject: OTerm, predicate: OTerm, object: OTerm): void;
+ forEach(callback: QuadCallback, subject: OTerm, predicate: OTerm, object: OTerm, graph: OTerm): void;
+ every(callback: QuadPredicate, subject: OTerm, predicate: OTerm, object: OTerm, graph: OTerm): boolean;
+ some(callback: QuadPredicate, subject: OTerm, predicate: OTerm, object: OTerm, graph: OTerm): boolean;
+ getSubjects(predicate: OTerm, object: OTerm, graph: OTerm): Array;
+ forSubjects(callback: QuadCallback, predicate: OTerm, object: OTerm, graph: OTerm): void;
+ getPredicates(subject: OTerm, object: OTerm, graph: OTerm): Array;
+ forPredicates(callback: QuadCallback, subject: OTerm, object: OTerm, graph: OTerm): void;
+ getObjects(subject: OTerm, predicate: OTerm, graph: OTerm): Array;
+ forObjects(callback: QuadCallback, subject: OTerm, predicate: OTerm, graph: OTerm): void;
+ getGraphs(subject: OTerm, predicate: OTerm, object: OTerm): Array;
+ forGraphs(callback: QuadCallback, subject: OTerm, predicate: OTerm, object: OTerm): void;
createBlankNode(suggestedName?: string): BlankNode;
// match, removeMatches and deleteGraph are missing for full RDF.Store adherence
remove(stream: stream.Stream): EventEmitter;
}
export interface StoreConstructor {
- new (triples?: RDF.Quad[], options?: StoreOptions): N3Store;
- (triples?: RDF.Quad[], options?: StoreOptions): N3Store;
+ new (triples?: Q_RDF[], options?: StoreOptions): N3Store;
+ (triples?: Q_RDF[], options?: StoreOptions): N3Store;
}
export const Store: StoreConstructor;
diff --git a/types/n3/n3-tests.ts b/types/n3/n3-tests.ts
index f7b2db2409..58d10892da 100644
--- a/types/n3/n3-tests.ts
+++ b/types/n3/n3-tests.ts
@@ -77,7 +77,13 @@ function test_doc_rdf_to_triples_2() {
}
function test_doc_rdf_stream_to_triples_1() {
- const parser: N3.N3Parser = new N3.Parser();
+ interface QuadBnode extends N3.BaseQuad {
+ subject: N3.BlankNode;
+ predicate: N3.BlankNode;
+ object: N3.BlankNode;
+ graph: N3.BlankNode;
+ }
+ const parser: N3.N3Parser = new N3.Parser({factory: N3.DataFactory});
parser.parse('abc', console.log);
const streamParser: N3.N3StreamParser = N3.StreamParser();
@@ -178,7 +184,26 @@ function test_doc_storing() {
const bnode2: RDF.BlankNode = store.createBlankNode('abc');
const mickey: RDF.Quad = store.getQuads(N3.DataFactory.namedNode('http://ex.org/Mickey'), null, null, null)[0];
+ if (mickey.object.termType === "Literal") {
+ console.log(mickey.object.datatype);
+ }
console.log(mickey.subject, mickey.predicate, mickey.object, '.');
+
+ interface N3QuadGeneralized extends N3.BaseQuad {
+ subject: N3.Quad_Subject | N3.BlankNode | N3.Literal;
+ predicate: N3.Quad_Predicate | N3.BlankNode | N3.Literal;
+ object: N3.Quad_Object | N3.BlankNode | N3.Literal;
+ graph: N3.Quad_Graph | N3.BlankNode | N3.Literal;
+ }
+ interface RDFQuadGeneralized extends RDF.BaseQuad {
+ subject: RDF.Quad_Subject | RDF.BlankNode | RDF.Literal;
+ predicate: RDF.Quad_Predicate | RDF.BlankNode | RDF.Literal;
+ object: RDF.Quad_Object | RDF.BlankNode | RDF.Literal;
+ graph: RDF.Quad_Graph | RDF.BlankNode | RDF.Literal;
+ }
+ const storeGeneralized = new N3.Store