SYMBOL INDEX (587 symbols across 36 files)

FILE: lib/base.js
  method constructor (line 24) | constructor(type) {
  method _reset (line 35) | _reset() {
  method describe (line 59) | describe() {
  method allow (line 67) | allow(...values) {
  method alter (line 73) | alter(targets) {
  method artifact (line 90) | artifact(id) {
  method cast (line 98) | cast(to) {
  method default (line 106) | default(value, options) {
  method description (line 111) | description(desc) {
  method empty (line 118) | empty(schema) {
  method error (line 129) | error(err) {
  method example (line 137) | example(example, options = {}) {
  method external (line 145) | external(method, description) {
  method failover (line 159) | failover(value, options) {
  method forbidden (line 164) | forbidden() {
  method id (line 169) | id(id) {
  method invalid (line 181) | invalid(...values) {
  method label (line 186) | label(name) {
  method meta (line 193) | meta(meta) {
  method note (line 200) | note(...notes) {
  method only (line 210) | only(mode = true) {
  method optional (line 217) | optional() {
  method prefs (line 222) | prefs(prefs) {
  method presence (line 237) | presence(mode) {
  method raw (line 244) | raw(enabled = true) {
  method result (line 249) | result(mode) {
  method required (line 256) | required() {
  method strict (line 261) | strict(enabled) {
  method strip (line 270) | strip(enabled = true) {
  method tag (line 275) | tag(...tags) {
  method unit (line 285) | unit(name) {
  method valid (line 292) | valid(...values) {
  method when (line 301) | when(condition, options) {
  method cache (line 325) | cache(cache) {
  method clone (line 337) | clone() {
  method concat (line 343) | concat(source) {
  method extend (line 444) | extend(options) {
  method extract (line 451) | extract(path) {
  method fork (line 457) | fork(paths, adjuster) {
  method isAsync (line 471) | isAsync() {
  method rule (line 504) | rule(options) {
  method ruleset (line 535) | get ruleset() {
  method $ (line 544) | get $() {
  method tailor (line 549) | tailor(targets) {
  method tracer (line 571) | tracer() {
  method validate (line 576) | validate(value, options) {
  method validateAsync (line 581) | validateAsync(value, options) {
  method $_addRule (line 588) | $_addRule(options) {
  method $_compile (line 674) | $_compile(schema, options) {
  method $_createError (line 679) | $_createError(code, value, local, state, prefs, options = {}) {
  method $_getFlag (line 686) | $_getFlag(name) {
  method $_getRule (line 691) | $_getRule(name) {
  method $_mapLabels (line 696) | $_mapLabels(path) {
  method $_match (line 702) | $_match(value, state, prefs, overrides) {
  method $_modify (line 715) | $_modify(options) {
  method $_mutateRebuild (line 721) | $_mutateRebuild() {
  method $_mutateRegister (line 746) | $_mutateRegister(schema, { family, key } = {}) {
  method $_property (line 752) | $_property(name) {
  method $_reach (line 757) | $_reach(path) {
  method $_rootReferences (line 762) | $_rootReferences() {
  method $_setFlag (line 767) | $_setFlag(name, value, options = {}) {
  method $_parent (line 797) | $_parent(method, ...args) {
  method $_validate (line 802) | $_validate(value, state, prefs) {
  method _assign (line 809) | _assign(target) {
  method _bare (line 843) | _bare() {
  method _default (line 857) | _default(flag, value, options = {}) {
  method _generate (line 877) | _generate(value, state, prefs) {
  method _inner (line 969) | _inner(type, values, options = {}) {
  method _inRuleset (line 991) | _inRuleset() {
  method _ruleRemove (line 996) | _ruleRemove(name, options = {}) {
  method _values (line 1028) | _values(values, key) {
  method '~standard' (line 1078) | get '~standard'() {

FILE: lib/cache.js
  method provision (line 16) | provision(options) {
  method constructor (line 27) | constructor(options = {}) {
  method length (line 38) | get length() {
  method set (line 43) | set(key, value) {
  method get (line 63) | get(key) {
  method _compact (line 72) | _compact() {
  method constructor (line 84) | constructor() {
  method unshift (line 90) | unshift(node) {
  method first (line 108) | first(node) {
  method pop (line 118) | pop() {
  method _remove (line 123) | _remove(node) {

FILE: lib/errors.js
  method constructor (line 13) | constructor(code, value, local, flags, messages, state, prefs) {
  method _setTemplate (line 43) | _setTemplate(template) {
  method toString (line 57) | toString() {
  method _template (line 87) | _template(messages, code) {
  method constructor (line 253) | constructor(message, details, original) {
  method isError (line 260) | static isError(err) {

FILE: lib/extend.js
  method method (line 213) | method(value, helpers) {

FILE: lib/index.d.ts
  type Types (line 14) | type Types =
  type BasicType (line 28) | type BasicType = boolean | number | string | any[] | object | null;
  type LanguageMessages (line 30) | type LanguageMessages = Record<string, string | Record<string, string>>;
  type PresenceMode (line 32) | type PresenceMode = "optional" | "required" | "forbidden";
  type ErrorFormattingOptions (line 34) | interface ErrorFormattingOptions {
  type BaseValidationOptions (line 96) | interface BaseValidationOptions {
  type ValidationOptions (line 188) | interface ValidationOptions extends BaseValidationOptions {
  type AsyncValidationOptions (line 199) | interface AsyncValidationOptions extends ValidationOptions {
  type LanguageMessageTemplate (line 214) | interface LanguageMessageTemplate {
  type ErrorValidationOptions (line 219) | interface ErrorValidationOptions extends BaseValidationOptions {
  type RenameOptions (line 223) | interface RenameOptions {
  type TopLevelDomainOptions (line 250) | interface TopLevelDomainOptions {
  type HierarchySeparatorOptions (line 263) | interface HierarchySeparatorOptions {
  type DependencyOptions (line 272) | interface DependencyOptions extends HierarchySeparatorOptions {
  type EmailOptions (line 281) | interface EmailOptions {
  type DomainOptions (line 338) | interface DomainOptions {
  type HexOptions (line 377) | interface HexOptions {
  type IpOptions (line 394) | interface IpOptions {
  type GuidVersions (line 405) | type GuidVersions =
  type GuidOptions (line 415) | interface GuidOptions {
  type UriOptions (line 428) | interface UriOptions {
  type DataUriOptions (line 465) | interface DataUriOptions {
  type Base64Options (line 474) | interface Base64Options extends Pick<DataUriOptions, "paddingRequired"> {
  type SwitchCases (line 483) | interface SwitchCases {
  type SwitchDefault (line 494) | interface SwitchDefault {
  type WhenOptions (line 502) | interface WhenOptions<ThenSchema = any, OtherwiseSchema = any> {
  type WhenSchemaOptions (line 535) | interface WhenSchemaOptions<ThenSchema = any, OtherwiseSchema = any> {
  type Cache (line 546) | interface Cache {
  type CacheProvisionOptions (line 561) | interface CacheProvisionOptions {
  type CacheConfiguration (line 570) | interface CacheConfiguration {
  type CompileOptions (line 577) | interface CompileOptions {
  type IsSchemaOptions (line 585) | interface IsSchemaOptions {
  type ReferenceOptions (line 594) | interface ReferenceOptions extends HierarchySeparatorOptions {
  type StringRegexOptions (line 661) | interface StringRegexOptions {
  type RuleOptions (line 675) | interface RuleOptions {
  type ErrorReport (line 699) | interface ErrorReport extends Error {
  type ValidationError (line 710) | interface ValidationError extends Error {
  type ValidationErrorItem (line 732) | interface ValidationErrorItem {
  type ValidationErrorFunction (line 739) | type ValidationErrorFunction = (
  type ValidationWarning (line 743) | interface ValidationWarning {
  type ValidationResult (line 749) | type ValidationResult<TSchema = any> =
  type CreateErrorOptions (line 761) | interface CreateErrorOptions {
  type ModifyOptions (line 766) | interface ModifyOptions {
  type MutateRegisterOptions (line 773) | interface MutateRegisterOptions {
  type SetFlagOptions (line 778) | interface SetFlagOptions {
  type CustomHelpers (line 782) | interface CustomHelpers<V = any> {
  type CustomValidator (line 792) | type CustomValidator<V = any, R = V> = (
  type ExternalHelpers (line 797) | interface ExternalHelpers<V = any> {
  type ExternalValidationFunction (line 808) | type ExternalValidationFunction<V = any, R = V> = (
  type Primitives (line 813) | type Primitives = string | number | boolean | bigint | symbol | null;
  type SchemaLikeWithoutArray (line 815) | type SchemaLikeWithoutArray<TSchema = any> = Exclude<
  type SchemaLike (line 819) | type SchemaLike<TSchema = any> = SchemaLikeWithoutArray<TSchema> | object;
  type NullableType (line 821) | type NullableType<T> = undefined | null | T;
  type IsPrimitiveSubset (line 823) | type IsPrimitiveSubset<T> = [T] extends [string]
  type IsUnion (line 839) | type IsUnion<T, U extends T = T> = T extends unknown
  type IsNonPrimitiveSubsetUnion (line 845) | type IsNonPrimitiveSubsetUnion<T> = true extends IsUnion<T>
  type ObjectPropertiesSchema (line 851) | type ObjectPropertiesSchema<T = any> = true extends IsNonPrimitiveSubset...
  type PartialSchemaMap (line 873) | type PartialSchemaMap<TSchema = any> = {
  type StrictSchemaMap (line 877) | type StrictSchemaMap<TSchema = any> = {
  type SchemaMap (line 881) | type SchemaMap<TSchema = any, isStrict = false> = isStrict extends true
  type Schema (line 885) | type Schema<P = any> =
  type SchemaFunction (line 899) | type SchemaFunction = (schema: Schema) => Schema;
  type AddRuleOptions (line 901) | interface AddRuleOptions {
  type GetRuleOptions (line 908) | interface GetRuleOptions {
  type SchemaInternals (line 915) | interface SchemaInternals {
  type AnySchema (line 1004) | interface AnySchema<TSchema = any>
  type Description (line 1393) | interface Description {
  type Context (line 1409) | interface Context {
  type State (line 1416) | interface State {
  type BooleanSchema (line 1425) | interface BooleanSchema<TSchema = boolean> extends AnySchema<TSchema> {
  type NumberSchema (line 1448) | interface NumberSchema<TSchema = number> extends AnySchema<TSchema> {
  type StringSchema (line 1515) | interface StringSchema<TSchema = string> extends AnySchema<TSchema> {
  type SymbolSchema (line 1680) | interface SymbolSchema<TSchema = Symbol> extends AnySchema<TSchema> {
  type ArraySortOptions (line 1689) | interface ArraySortOptions {
  type ArrayUniqueOptions (line 1697) | interface ArrayUniqueOptions extends HierarchySeparatorOptions {
  type ComparatorFunction (line 1706) | type ComparatorFunction = (a: any, b: any) => boolean;
  type UnwrapSchemaLikeWithoutArray (line 1708) | type UnwrapSchemaLikeWithoutArray<T> = T extends SchemaLikeWithoutArray<
  type NoNestedArrays (line 1714) | type NoNestedArrays<T extends readonly unknown[]> = Extract<
  type ArraySchema (line 1721) | interface ArraySchema<TSchema = any[]> extends AnySchema<TSchema> {
  type ObjectPatternOptions (line 1835) | interface ObjectPatternOptions {
  type ObjectSchema (line 1840) | interface ObjectSchema<TSchema = any> extends AnySchema<TSchema> {
  type BinarySchema (line 1974) | interface BinarySchema<TSchema = Buffer> extends AnySchema<TSchema> {
  type DateSchema (line 1996) | interface DateSchema<TSchema = Date> extends AnySchema<TSchema> {
  type FunctionSchema (line 2041) | interface FunctionSchema<TSchema = Function> extends ObjectSchema<TSchem...
  type AlternativesSchema (line 2066) | interface AlternativesSchema<TSchema = any> extends AnySchema<TSchema> {
  type LinkSchema (line 2122) | interface LinkSchema<TSchema = any> extends AnySchema<TSchema> {
  type Reference (line 2136) | interface Reference extends Exclude<ReferenceOptions, "prefix"> {
  type ExtensionBoundSchema (line 2146) | type ExtensionBoundSchema = Schema & SchemaInternals;
  type RuleArgs (line 2148) | interface RuleArgs {
  type RuleMethod (line 2160) | type RuleMethod = (...args: any[]) => any;
  type ExtensionRule (line 2162) | interface ExtensionRule {
  type CoerceResult (line 2200) | interface CoerceResult {
  type CoerceFunction (line 2205) | type CoerceFunction = (value: any, helpers: CustomHelpers) => CoerceResult;
  type CoerceObject (line 2207) | interface CoerceObject {
  type ExtensionFlag (line 2212) | interface ExtensionFlag {
  type ExtensionTermManifest (line 2217) | interface ExtensionTermManifest {
  type ExtensionTerm (line 2224) | interface ExtensionTerm {
  type Extension (line 2230) | interface Extension {
  type ExtensionFactory (line 2258) | type ExtensionFactory = (joi: Root) => Extension;
  type Err (line 2260) | interface Err {
  type Root (line 2266) | interface Root {

FILE: lib/index.js
  method assert (line 99) | assert(value, schema, ...args /* [message], [options] */) {
  method attempt (line 104) | attempt(value, schema, ...args /* [message], [options] */) {
  method build (line 109) | build(desc) {
  method checkPreferences (line 115) | checkPreferences(prefs) {
  method compile (line 120) | compile(schema, options) {
  method defaults (line 125) | defaults(modifier) {
  method expression (line 143) | expression(...args) {
  method extend (line 148) | extend(...extensions) {
  method in (line 190) | in(...args) {
  method ref (line 197) | ref(...args) {
  method types (line 202) | types() {

FILE: lib/manifest.js
  method constructor (line 247) | constructor(joi) {
  method parse (line 252) | parse(desc) {
  method build (line 381) | build(desc, options = {}) {

FILE: lib/modify.js
  method constructor (line 15) | constructor() {
  method clone (line 22) | clone() {
  method concat (line 31) | concat(source) {
  method fork (line 48) | fork(path, adjuster, root) {
  method labels (line 64) | labels(path, behind = []) {
  method reach (line 81) | reach(path, behind = []) {
  method register (line 95) | register(schema, { key } = {}) {
  method reset (line 126) | reset() {
  method _collect (line 133) | _collect(path, behind = [], nodes = []) {
  method _get (line 149) | _get(id) {

FILE: lib/ref.js
  method constructor (line 90) | constructor(options) {
  method resolve (line 118) | resolve(value, state, prefs, local, options = {}) {
  method _resolve (line 142) | _resolve(target, state, options) {
  method toString (line 175) | toString() {
  method absolute (line 180) | absolute(state) {
  method clone (line 185) | clone() {
  method describe (line 190) | describe() {
  method updateDisplay (line 227) | updateDisplay() {
  method constructor (line 338) | constructor() {
  method register (line 343) | register(source, target) {
  method length (line 391) | get length() {
  method clone (line 396) | clone() {
  method reset (line 403) | reset() {
  method roots (line 408) | roots() {

FILE: lib/state.js
  method constructor (line 15) | constructor(path, ancestors, state) {
  method localize (line 25) | localize(path, ancestors = null, schema = null) {
  method nest (line 38) | nest(schema, debug) {
  method shadow (line 46) | shadow(value, reason) {
  method snapshot (line 52) | snapshot() {
  method restore (line 61) | restore() {
  method commit (line 71) | commit() {
  method constructor (line 95) | constructor() {
  method set (line 100) | set(path, value, reason) {
  method get (line 129) | get(path) {
  method node (line 137) | node(path) {
  method override (line 146) | override(path, node) {

FILE: lib/template.js
  method constructor (line 29) | constructor(source, options) {
  method _parse (line 56) | _parse() {
  method date (line 118) | static date(date, prefs) {
  method describe (line 123) | describe(options = {}) {
  method build (line 143) | static build(desc) {
  method isDynamic (line 148) | isDynamic() {
  method isTemplate (line 153) | static isTemplate(template) {
  method refs (line 158) | refs() {
  method resolve (line 174) | resolve(value, state, prefs, local) {
  method _part (line 185) | _part(part, ...args) {
  method render (line 194) | render(value, state, prefs, local, options = {}) {
  method _ref (line 218) | _ref(content, { raw, wrapped }) {
  method toString (line 253) | toString() {
  method if (line 403) | if(condition, then, otherwise) {
  method length (line 408) | length(item) {
  method msg (line 425) | msg(code) {
  method number (line 441) | number(value) {

FILE: lib/trace.js
  method constructor (line 49) | constructor() {
  method _register (line 55) | _register(schema) {
  method _combine (line 68) | _combine(merged, sources) {
  method report (line 75) | report(file) {
  method constructor (line 178) | constructor(schema) {
  method debug (line 186) | debug(state, source, name, result) {
  method entry (line 191) | entry(schema, state) {
  method filter (line 201) | filter(schema, state, source, value) {
  method log (line 211) | log(schema, state, source, name, result) {
  method resolve (line 222) | resolve(state, ref, to) {
  method value (line 232) | value(state, by, from, to, name) {
  method _record (line 248) | _record(schema, each) {
  method _scan (line 262) | _scan(schema, _path) {
  method _combine (line 292) | _combine(merged, sources) {

FILE: lib/types/alternatives.js
  method args (line 29) | args(schema, ...schemas) {
  method validate (line 40) | validate(value, helpers) {
  method method (line 152) | method(condition, options) {
  method method (line 177) | method(mode) {
  method method (line 192) | method(...schemas) {
  method label (line 211) | label(name) {
  method isAsync (line 222) | isAsync() {
  method rebuild (line 247) | rebuild(schema) {
  method build (line 265) | build(obj, desc) {

FILE: lib/types/any.js
  method method (line 37) | method(method, description) {
  method validate (line 44) | validate(value, helpers, { method }) {
  method method (line 58) | method(messages) {
  method method (line 65) | method(schema) {
  method method (line 78) | method(code, local) {
  method validate (line 84) | validate(value, helpers, { code, local }) {
  method keep (line 95) | keep(rule, enabled = true) {
  method message (line 100) | message(rule, message) {
  method warn (line 105) | warn(rule, enabled = true) {
  method build (line 113) | build(obj, desc) {

FILE: lib/types/array.js
  method method (line 35) | method(value, { schema, state, prefs }) {
  method validate (line 50) | validate(value, { schema, error }) {
  method method (line 74) | method(schema) {
  method validate (line 81) | validate(value, { state, prefs, error }, { schema: has }) {
  method method (line 102) | method(...schemas) {
  method validate (line 115) | validate(value, { schema, error, state, prefs, errorsArray }) {
  method method (line 359) | method(limit) {
  method validate (line 363) | validate(value, helpers, { limit }, { name, operator, args }) {
  method method (line 382) | method(limit) {
  method method (line 389) | method(limit) {
  method method (line 396) | method(...schemas) {
  method method (line 415) | method(enabled) {
  method method (line 425) | method(options = {}) {
  method validate (line 440) | validate(value, { error, state, prefs, schema }, { options }) {
  method method (line 459) | method(enabled) {
  method method (line 473) | method(comparator, options = {}) {
  method validate (line 492) | validate(value, { state, error, schema }, { comparator: raw, options }, ...
  method isAsync (line 568) | isAsync() {
  method to (line 593) | to(value, helpers) {
  method rebuild (line 600) | rebuild(schema) {
  method build (line 627) | build(obj, desc) {

FILE: lib/types/binary.js
  method method (line 18) | method(value, { schema }) {
  method validate (line 29) | validate(value, { error }) {
  method method (line 38) | method(encoding) {
  method method (line 47) | method(limit) {
  method validate (line 51) | validate(value, helpers, { limit }, { name, operator, args }) {
  method method (line 70) | method(limit) {
  method method (line 77) | method(limit) {
  method to (line 87) | to(value, helpers) {

FILE: lib/types/boolean.js
  method coerce (line 41) | coerce(value, { schema }) {
  method validate (line 61) | validate(value, { error }) {
  method method (line 70) | method(...values) {
  method method (line 89) | method(...values) {
  method method (line 108) | method(enabled = true) {
  method to (line 118) | to(value, helpers) {
  method to (line 125) | to(value, helpers) {
  method build (line 134) | build(obj, desc) {

FILE: lib/types/date.js
  method method (line 25) | method(value, { schema }) {
  method validate (line 31) | validate(value, { schema, error, prefs }) {
  method validate (line 55) | validate(value, helpers, { date }, { name, operator, args }) {
  method method (line 79) | method(format) {
  method method (line 88) | method(date) {
  method method (line 95) | method() {
  method method (line 102) | method(date) {
  method method (line 109) | method(date) {
  method method (line 116) | method(date) {
  method method (line 123) | method(type = 'javascript') {
  method to (line 135) | to(value, helpers) {
  method to (line 142) | to(value, { prefs }) {

FILE: lib/types/function.js
  method method (line 21) | method(n) {
  method validate (line 27) | validate(value, helpers, { n }) {
  method method (line 38) | method() {
  method validate (line 42) | validate(value, helpers) {
  method method (line 53) | method(n) {
  method validate (line 59) | validate(value, helpers, { n }) {
  method method (line 70) | method(n) {
  method validate (line 76) | validate(value, helpers, { n }) {

FILE: lib/types/keys.js
  method args (line 45) | args(schema, keys) {
  method validate (line 50) | validate(value, { schema, error, state, prefs }) {
  method method (line 171) | method(...peers /*, [options] */) {
  method method (line 180) | method(schema) {
  method method (line 194) | method(subject, schema, message) {
  method validate (line 209) | validate(value, { error, prefs, state }, { subject, schema, message }) {
  method method (line 224) | method(constructor, name) {
  method validate (line 232) | validate(value, helpers, { constructor, name }) {
  method method (line 244) | method(schema) {
  method method (line 269) | method(limit) {
  method validate (line 273) | validate(value, helpers, { limit }, { name, operator, args }) {
  method method (line 292) | method(limit) {
  method method (line 299) | method(limit) {
  method method (line 306) | method(...peers /*, [options] */) {
  method method (line 315) | method(...peers /*, [options] */) {
  method method (line 324) | method(...peers /*, [options] */) {
  method method (line 331) | method(pattern, schema, options = {}) {
  method method (line 371) | method() {
  method validate (line 375) | validate(value, helpers) {
  method method (line 386) | method() {
  method validate (line 390) | validate(value, helpers) {
  method method (line 401) | method(from, to, options = {}) {
  method method (line 431) | method(type = 'any') {
  method validate (line 435) | validate(value, helpers, { type }) {
  method method (line 448) | method(allow) {
  method method (line 455) | method(key, peers, options = {}) {
  method method (line 462) | method(key, peers, options = {}) {
  method method (line 469) | method(...peers /*, [options] */) {
  method default (line 480) | default(value, options) {
  method isAsync (line 489) | isAsync() {
  method rebuild (line 515) | rebuild(schema) {
  method build (line 529) | build(obj, desc) {
  method and (line 653) | and(schema, dep, value, state, prefs) {
  method nand (line 683) | nand(schema, dep, value, state, prefs) {
  method or (line 710) | or(schema, dep, value, state, prefs) {
  method oxor (line 728) | oxor(schema, dep, value, state, prefs) {
  method with (line 750) | with(schema, dep, value, state, prefs) {
  method without (line 768) | without(schema, dep, value, state, prefs) {
  method xor (line 786) | xor(schema, dep, value, state, prefs) {
  method constructor (line 1033) | constructor(rel, key, peers, paths, options) {
  method describe (line 1042) | describe() {
  method concat (line 1068) | concat(source) {

FILE: lib/types/link.js
  method args (line 27) | args(schema, ref) {
  method validate (line 32) | validate(value, { schema, state, prefs }) {
  method generate (line 41) | generate(schema, value, state, prefs) {
  method method (line 49) | method(ref) {
  method method (line 65) | method(enabled = true) {
  method concat (line 74) | concat(source) {
  method build (line 93) | build(obj, desc) {

FILE: lib/types/number.js
  method decimalPlaces (line 16) | decimalPlaces(value) {
  method method (line 40) | method(value, { schema, error }) {
  method validate (line 78) | validate(value, { schema, error, prefs }) {
  method validate (line 117) | validate(value, helpers, { limit }, { name, operator, args }) {
  method method (line 136) | method(limit) {
  method method (line 143) | method() {
  method validate (line 147) | validate(value, helpers) {
  method method (line 158) | method(limit) {
  method method (line 165) | method(limit) {
  method method (line 172) | method(limit) {
  method method (line 179) | method(base) {
  method validate (line 193) | validate(value, helpers, { base, baseDecimalPlace, pfactor }, options) {
  method method (line 220) | method() {
  method method (line 227) | method() {
  method validate (line 231) | validate(value, helpers) {
  method method (line 245) | method() {
  method method (line 252) | method(limit) {
  method validate (line 258) | validate(value, helpers, { limit }) {
  method method (line 272) | method(sign) {
  method validate (line 278) | validate(value, helpers, { sign }) {
  method method (line 291) | method(enabled = true) {
  method to (line 303) | to(value, helpers) {

FILE: lib/types/object.js
  method to (line 16) | to(value, helpers) {

FILE: lib/types/string.js
  method method (line 70) | method(value, { schema, state, prefs }) {
  method validate (line 129) | validate(value, { schema, error }) {
  method method (line 150) | method() {
  method validate (line 154) | validate(value, helpers) {
  method method (line 165) | method(options = {}) {
  method validate (line 175) | validate(value, helpers, { options }) {
  method method (line 187) | method(direction) {
  method validate (line 193) | validate(value, helpers, { direction }) {
  method method (line 207) | method() {
  method validate (line 211) | validate(value, helpers) {
  method method (line 234) | method(options = {}) {
  method validate (line 243) | validate(value, helpers, { options }) {
  method method (line 267) | method(options) {
  method validate (line 276) | validate(value, helpers, args, { address }) {
  method method (line 287) | method(options = {}) {
  method validate (line 297) | validate(value, helpers, { options }, { regex, address }) {
  method method (line 317) | method(options = {}) {
  method validate (line 385) | validate(value, helpers, args, { regex }) {
  method method (line 405) | method(options = {}) {
  method validate (line 415) | validate(value, helpers, { options }) {
  method method (line 437) | method() {
  method validate (line 441) | validate(value, helpers) {
  method method (line 454) | method() {
  method method (line 461) | method(options = {}) {
  method validate (line 469) | validate(value, helpers, { options }, { regex }) {
  method method (line 484) | method() {
  method validate (line 488) | validate(value, { error }) {
  method method (line 499) | method() {
  method validate (line 503) | validate(value, helpers) {
  method method (line 514) | method(limit, encoding) {
  method validate (line 518) | validate(value, helpers, { limit, encoding }, { name, operator, args }) {
  method method (line 539) | method() {
  method method (line 546) | method(limit, encoding) {
  method method (line 554) | method(limit, encoding) {
  method method (line 562) | method(form = 'NFC') {
  method validate (line 568) | validate(value, { error }, { form }) {
  method method (line 581) | method(regex, options = {}) {
  method validate (line 595) | validate(value, helpers, { regex, options }, { errorCode }) {
  method method (line 610) | method(pattern, replacement) {
  method method (line 631) | method() {
  method validate (line 635) | validate(value, helpers) {
  method method (line 646) | method(enabled = true) {
  method validate (line 652) | validate(value, helpers, { enabled }) {
  method method (line 666) | method(enabled = true) {
  method method (line 675) | method() {
  method method (line 682) | method(options = {}) {
  method validate (line 694) | validate(value, helpers, { options }, { regex, domain, scheme }) {
  method build (line 737) | build(obj, desc) {

FILE: lib/types/symbol.js
  method slice (line 13) | slice() {
  method method (line 30) | method(value, { schema, error }) {
  method validate (line 47) | validate(value, { error }) {
  method method (line 56) | method(iterable) {
  method build (line 88) | build(obj, desc) {

FILE: lib/validator.js
  method constructor (line 202) | constructor(tracer, debug, links) {
  method snapshot (line 215) | snapshot() {
  method restore (line 223) | restore() {
  method commit (line 230) | commit() {

FILE: lib/values.js
  method constructor (line 13) | constructor(values, refs) {
  method length (line 22) | get length() {
  method add (line 27) | add(value, refs) {
  method merge (line 54) | static merge(target, source, remove) {
  method remove (line 77) | remove(value) {
  method has (line 95) | has(value, state, prefs, insensitive) {
  method get (line 100) | get(value, state, prefs, insensitive) {
  method override (line 178) | override() {
  method values (line 183) | values(options) {
  method clone (line 202) | clone() {
  method concat (line 209) | concat(source) {
  method describe (line 218) | describe() {

FILE: test/extend.js
  method validate (line 26) | validate(value, helpers, args, options) {
  method validate (line 74) | validate(value, helpers, args, options) {
  method validate (line 101) | validate(value, helpers, args, options) {
  method method (line 138) | method() {
  method validate (line 142) | validate(value, helpers) {
  method args (line 191) | args(schema, limit) {
  method validate (line 252) | validate(value, helpers) {
  method validate (line 280) | validate(value, helpers) {
  method validate (line 308) | validate(value, helpers) {
  method validate (line 337) | validate(value, helpers, args, options) {
  method validate (line 343) | validate(value, helpers, args, options) {
  method validate (line 349) | validate(value, helpers, args, options) {
  method validate (line 377) | validate(value, helpers, args, options) {
  method validate (line 402) | validate(value, { error }) {
  method validate (line 421) | validate(value, { schema }) {
  method method (line 427) | method(first, second) {
  method validate (line 453) | validate(value, { schema }) {
  method method (line 459) | method(first, second) {
  method coerce (line 480) | coerce(value, helpers) {
  method method (line 491) | method(schema) {
  method validate (line 513) | validate(value, helpers, args, options) {
  method validate (line 658) | validate(value, { error }, args, options) {
  method coerce (line 678) | coerce(value, helpers) {
  method method (line 694) | method(value, { error }) {
  method method (line 714) | method(value, { error }) {
  method method (line 743) | method(value, { error }) {
  method method (line 763) | method(value, { error }) {
  method coerce (line 791) | coerce(value, { error }) {
  method coerce (line 802) | coerce(value, { error }) {
  method coerce (line 812) | coerce(value, { error }) {
  method validate (line 829) | validate(value, { error }) {
  method validate (line 872) | validate(value, helpers) {
  method validate (line 884) | validate(value, helpers) {
  method validate (line 905) | validate(value, { error }) {
  method validate (line 917) | validate(value, { error }) {
  method validate (line 939) | validate(value, { error }) {
  method validate (line 952) | validate(value, { error }) {
  method validate (line 971) | validate(value, { error }) {
  method validate (line 983) | validate(value, { error }) {
  method validate (line 1001) | validate(value, { error }) {
  method validate (line 1014) | validate(value, { error }) {
  method validate (line 1060) | validate(value, { error }) {
  method coerce (line 1089) | coerce(value, { schema }) {
  method validate (line 1097) | validate(value, { schema, error }) {
  method method (line 1116) | method() {
  method method (line 1123) | method() {
  method validate (line 1127) | validate(value, helpers, args, options) {
  method method (line 1138) | method(q) {
  method validate (line 1150) | validate(value, helpers, args, options) {
  method method (line 1160) | method() {
  method method (line 1223) | method(q) {
  method validate (line 1234) | validate(value, helpers, args, options) {
  method method (line 1276) | method(schema) {
  method rebuild (line 1285) | rebuild(schema) {
  method method (line 1313) | method(schema) {
  method factor (line 1376) | factor(rule, n) {
  method method (line 1398) | method(b) {
  method prepare (line 1422) | prepare(value, helpers) {
  method prepare (line 1444) | prepare(value, { error }) {
  method prepare (line 1471) | prepare(value, helpers) {
  method prepare (line 1485) | prepare(value, { error }) {
  method method (line 1522) | method(value, helpers) {
  method method (line 1571) | method(value, helpers) {
  method label (line 1634) | label(...args) {

FILE: test/index.js
  method compile (line 416) | compile() { }
  method func (line 868) | func() { }
  method func (line 875) | func() { }

FILE: test/index.ts
  type TResult (line 1073) | type TResult = { username: string; password: string };
  type TResult (line 1157) | type TResult = { username: string; password: string };
  method coerce (line 1197) | coerce(schema, value) {
  method method (line 1209) | method(allowFalse: boolean) {
  method validate (line 1217) | validate(value: boolean, helpers, params, options) {
  type User (line 1368) | interface User {
  type Comment (line 1398) | interface Comment {
  type Comment2 (line 1410) | interface Comment2 {
  type CommentWithAlternatives (line 1424) | interface CommentWithAlternatives {
  type TResult (line 1454) | type TResult = { username: string; password: string };

FILE: test/manifest.js
  method method (line 511) | method(button) {
  method build (line 520) | build(obj, desc) {
  method coerce (line 564) | coerce(value, { schema }) {
  method validate (line 572) | validate(value, { schema, error }) {
  method method (line 591) | method() {
  method method (line 598) | method() {
  method validate (line 602) | validate(value, helpers, args, options) {
  method method (line 613) | method(q) {
  method validate (line 625) | validate(value, helpers, args, options) {
  method method (line 635) | method() {

FILE: test/modify.js
  method coerce (line 733) | coerce(value, helpers) {
  method method (line 747) | method(schema) {
  method method (line 753) | method(schema) {
  method validate (line 757) | validate() { }
  method method (line 760) | method(schema) {

FILE: test/template.js
  method uppercase (line 185) | uppercase(value) {
  method length (line 206) | length(value) {

FILE: test/types/array.js
  method method (line 1855) | method() {
  method method (line 1882) | method() {

FILE: test/types/date.js
  method format (line 187) | format(format) {

FILE: test/types/object.js
  method constructor (line 99) | constructor() {