get not() {
    const f = (validator) => this.and(this.constructor.not(validator));
    if (!this.constructor[NEGATE]) return f;

    const p = new this.constructor[NEGATE](this.unValidate);
    return new Proxy(f, {
      get: (_, ...args) => Reflect.get(p, ...args),
    });
  }
/**
   * A type-restriction method that succeeds if the given `validator` fails, and
   * fails otherwise. NOTE that this is not actually a function, but rather a
   * special `Proxy` object that behaves like both a function and an object.
   *
   * When used as an object it operates like a special negated version of
   * `this`. I.e. when used as an object it will have all the same
   * type-restrictions as are available on `this`, but where every
   * type-restriction is negated.
   *
   * When used as a function it will simply negate the given `validator`. NOTE
   * that this may not behave exactly like you might initially expect, for
   * example: the validator `is.any().not(is.number().lt(0))` is not equal to
   * the validator `is.number().not.lt(0)`! For example, when run on an input
   * value of type string, this value will be ok when run against the first
   * validator, but not the second. As the first will negate the whole validator
   * whereas the second will only negate the type-restriction `lt`. Thus for the
   * first the input is strictly `not (a number less than 0)` and will therefore
   * be ok, and for the second the number must be `a number && not less then 0`.
   *
   * @example
   * const v1 = is.any().not(is.number().lt(0));
   * const v2 = is.number().not.lt(0);
   *
   * v1.run('lol');     // ok
   * // v1.run(-1);     // throws
   * v1.run(1);         // ok
   *
   * // v2.run('lol');  // throws
   * // v2.run(-1);     // throws
   * v2.run(1);         // ok
   *
   * @category instance
   * @function not
   * @memberOf Monadidator
   * @param {Monadidator} validator
   * @return {Monadidator}
   */
A type-restriction method that succeeds if the given `validator` fails, and
fails otherwise. NOTE that this is not actually a function, but rather a
special `Proxy` object that behaves like both a function and an object.

When used as an object it operates like a special negated version of
`this`.

When used as a function it will simply negate the given `validator`.








A type - restriction method that succeeds if the given ` validator ` fails and fails otherwise . NOTE that this is not actually a function but rather a special ` Proxy ` object that behaves like both a function and an object . When used as an object it operates like a special negated version of ` this ` . When used as a function it will simply negate the given ` validator ` .
get not() {
    const f = (validator) => this.and(this.constructor.not(validator));
    if (!this.constructor[NEGATE]) return f;
    const p = new this.constructor[NEGATE](this.unValidate);
    return new Proxy(f, {
      get: (_, ...args) => Reflect.get(p, ...args),
    });
  }
get not ( ) { const f = ( validator ) => this . and ( this . constructor . not ( validator ) ) ; if ( ! this . constructor [ NEGATE ] ) return f ; const p = new this . constructor [ NEGATE ] ( this . unValidate ) ; return new Proxy ( f , { get : ( _ , ... args ) => Reflect . get ( p , ... args ) , } ) ; }
A type-restriction method that succeeds if the given `validator` fails, and
 fails otherwise.
A type - restriction method that succeeds if the given ` validator ` fails and fails otherwise .