`InterfaceNotFoundError` error.

@api public
481300
function InterfaceNotFoundError(message, iface) {
  Error.call(this);
  Error.captureStackTrace(this, arguments.callee);
  this.message = message;
  this.code = 'INTERFACE_NOT_FOUND';
  this.interface = iface;
}
494519
function componentStillLoadingError(compType) {
    var /** @type {?} */ error = Error("Can't compile synchronously as " + __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__angular_core__["m" /* ɵstringify */])(compType) + " is still being loaded!");
    ((error))[__WEBPACK_IMPORTED_MODULE_0__angular_core__["_47" /* ɵERROR_COMPONENT_TYPE */]] = compType;
    return error;
}
338646
function _interfaceish(node, print) {
  print.plain(node.id);
  print.plain(node.typeParameters);
  if (node["extends"].length) {
    this.push(" extends ");
    print.join(node["extends"], { separator: ", " });
  }
  if (node.mixins && node.mixins.length) {
    this.push(" mixins ");
    print.join(node.mixins, { separator: ", " });
  }
  this.space();
  print.plain(node.body);
}
725462
def method_missing(method_name, *args, &block)
      config = Loquacious::Configuration.for method_name, &block
      raise Adhearsion::Configuration::ConfigurationError.new "Invalid plugin #{method_name}" if config.nil?
      config
    end
541254
def error
      @values.each_pair{|observable, value|
        return Error.new(observable, value) if Exception === value
      }
      return nil
    end
117161
function InvalidSourceError(error) {
    var instance = new Error("An exception was thrown when making a request.");

    instance.name = "InvalidSourceError";
    instance.innerError = error;

    if (Object.setPrototypeOf) {
        Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
    }

    if (Error.captureStackTrace) {
        Error.captureStackTrace(instance, InvalidSourceError);
    }

    return instance;
}
1005370
protected function discoverInterface() : bool
    {
        if (!($this->nb_interface instanceof INabuProviderInterface) &&
            ($nb_manager = $this->nb_descriptor->getManager()) instanceof INabuProviderManager
        ) {
            $this->nb_interface = $this->createInterface($nb_manager, $this->nb_descriptor);
        }

        return ($this->nb_interface instanceof INabuProviderInterface);
    }
1015130
function (def) {
                var classpath = def.$classpath;
                // Initialize the prototype
                var proto; // prototype being created
                var superInterface = null;
                if (def.$extends) {
                    // the prototype must be created from the super interface
                    superInterface = Aria.getClassRef(def.$extends);
                    if (!superInterface) {
                        this.$logError(this.BASE_INTERFACE_UNDEFINED, [classpath, def.$extends]);
                        throw new Error(this.BASE_INTERFACE_UNDEFINED);
                    }
                    var parentCstr = superInterface ? superInterface.interfaceDefinition : null;
                    parentCstr = parentCstr ? parentCstr.$noargConstructor : null;
                    if (!parentCstr) {
                        this.$logError(this.WRONG_BASE_INTERFACE, [classpath, def.$extends]);
                        throw new Error(this.WRONG_BASE_INTERFACE);
                    }
                    proto = new parentCstr();
                    proto.$interfaces = __copyMap(superInterface.prototype.$interfaces);
                } else {
                    proto = new __superInterfaceConstructor();
                    proto.$interfaces = {};
                }
                proto.$classpath = classpath; // classpath of the interface
                // Look into the members of the interface, and divide them into functions or properties
                var itf = def.$interface;
                var methods = []; // builds the string containing the methods of the interface
                var initProperties = []; // builds the string to initialize properties of the interface (objects and
                // arrays)
                var deleteProperties = []; // builds the string to delete properties of the interface (in $destructor)
                for (var member in itf) {
                    if (itf.hasOwnProperty(member)) {
                        if (!Aria.checkJsVarName(member) || __superInterfacePrototype[member]) {
                            this.$logError(this.INVALID_INTERFACE_MEMBER, [classpath, member]);
                            // remove and ignore that member:
                            itf[member] = null;
                            delete itf[member];
                            continue;
                        }
                        var memberValue = __normalizeMember.call(this, itf[member], classpath, member);
                        itf[member] = memberValue;
                        if (memberValue != null) {
                            if (memberValue.$type == "Function") {
                                var asyncParam = memberValue.$callbackParam;
                                if (asyncParam == null) {
                                    asyncParam = "null";
                                }
                                methods.push("p.", member, "=function(){\nreturn i.get(this.__$me).$call('", classpath, "','", member, "',arguments,", asyncParam, ");\n}\n");
                            } else if (memberValue.$type == "Interface") {
                                initProperties.push("this.", member, "=obj.", member, "?obj.", member, ".$interface('", memberValue.$classpath, "'):null;\n");
                                deleteProperties.push("this.", member, "=null;\n");
                            } else if (memberValue.$type == "Object") {
                                initProperties.push("this.", member, "=obj.", member, ";\n");
                                deleteProperties.push("this.", member, "=null;\n");
                            }
                        } else {
                            this.$logError(this.INVALID_INTERFACE_MEMBER_DEF, [classpath, member]);
                            delete itf[member];
                        }
                    }
                }
                // management of events
                // events in the prototype of the interface
                proto.$events = {};
                var parentEvents = false;
                if (superInterface) {
                    parentEvents = __mergeEvents(proto.$events, superInterface.prototype.$events, classpath);
                } else {
                    methods.push("p.$interface=function(a){\nreturn aria.core.Interfaces.getInterface(i.get(this.__$me),a,this);\n};\n");
                }
                if (__mergeEvents(proto.$events, def.$events, classpath) && !parentEvents) {
                    // The parent interface has no event but this interface has events!
                    // We have to add special wrappers for event handling
                    methods.push("p.$addListeners=function(a){\nreturn i.get(this.__$me).$addListeners(a,this);\n};\n");
                    methods.push("p.$onOnce=function(a){\nreturn i.get(this.__$me).$onOnce(a,this);\n};\n");
                    methods.push("p.$removeListeners=function(a){\nreturn i.get(this.__$me).$removeListeners(a,this);\n};\n");
                    methods.push("p.$unregisterListeners=function(a){\nreturn i.get(this.__$me).$unregisterListeners(a,this);\n};\n");
                    methods.push("p.$on=p.$addListeners;\n");
                }
                methods.push("p.$destructor=function(){\n", deleteProperties.join(''), "if(this.__$me){\ni['delete'](this.__$me);\n}\nthis.__$me=null;\n", superInterface
                        ? "e.prototype.$destructor.call(this);\n" /* call super interface at the end of the destructor */
                        : "", "};\n");
                var srcContent = [];
                var evalContext = {
                    i : new __weakMap(),
                    p : proto, // prototype
                    c : null, // constructor (will be set by the evaluated code)
                    e : superInterface
                };
                Aria.nspace(classpath, true);
                srcContent.push("var evalContext=arguments[2];\nvar i=evalContext.i;\nvar p=evalContext.p;\nvar e=evalContext.e;\nevalContext.c=function(obj){\n", (superInterface
                        ? 'e.call(this,obj);\n'
                        : ''), 'this.__$me=this.__$me||this;\ni.set(this.__$me,obj);\n', initProperties.join(''), '};\n', methods.join(''), 'Aria.$global.', classpath, '=evalContext.c;\n', 'p=null;\nevalContext=null;\n');
                srcContent = srcContent.join('');

                // Get original sourceURL of the interface
                var interfaceSrcURL = downloadMgr.resolveURL( Aria.getLogicalPath(classpath, ".js"), true );
                // Remove extension and add wrapper extension
                var indexOfExtension = interfaceSrcURL.lastIndexOf(".");
                var srcURL = interfaceSrcURL.substring(0,indexOfExtension) + "-wrapper.js";
                // Generate the interface wrapper
                Aria["eval"](srcContent, srcURL, evalContext);
                var constructor = evalContext.c;
                proto.$interfaces[classpath] = constructor;
                constructor.prototype = proto;
                constructor.interfaceDefinition = def;
                constructor.superInterface = superInterface;
                def.$noargConstructor = new Function();
                def.$noargConstructor.prototype = proto;
                Aria.$classes.push(constructor);
                return constructor;
            }
73604
function parseInterfaces(interfaces, constructor) {
        var interfs = toArray(interfaces),
            x = interfs.length,
            interf,
            key,
            value;

        for (x -= 1; x >= 0; x -= 1) {
            interf = interfs[x];

            // Grab methods
            for (key in interf[$interface].methods) {

                value = interf[$interface].methods[key];

                 // Check if method is already defined as abstract and is compatible
                if (constructor[$abstract].methods[key]) {
                    if (!isFunctionCompatible(constructor[$abstract].methods[key], value)) {
                        throw new Error('Method "' + key + '( ' + value.signature + ')" described in interface "' + interf.prototype.$name + '" is not compatible with the one already defined in "' + constructor.prototype.$name + '": "' + key + '(' + constructor[$abstract].methods[key].signature + ')".');
                    }
                } else {
                    constructor[$abstract].methods[key] = interf[$interface].methods[key];
                }
            }

            // Grab static methods
            for (key in interf[$interface].staticMethods) {

                value = interf[$interface].staticMethods[key];

                // Check if method is already defined as abstract and is compatible
                if (constructor[$abstract].staticMethods[key]) {
                    if (!isFunctionCompatible(constructor[$abstract].staticMethods[key], value)) {
                        throw new Error('Static method "' + key + '( ' + value.signature + ')" described in interface "' + interf.prototype.$name + '" is not compatible with the one already defined in "' + constructor.prototype.$name + '": "' + key + '(' + constructor[$abstract].staticMethods[key].signature + ')".');
                    }
                } else {
                    constructor[$abstract].staticMethods[key] = value;
                }
            }
        }
    }
1346979
function unknownError(message, stack) {
    jitsu.log.error(message);
    stack.split('\n').forEach(function (line) {
      jitsu.log.error(line);
    })
  }
577332
function transactionNotFoundError(response, message, body) {
  var content = errorContent(ErrorType.transaction, message, body);
  send(response, content, StatusCode.notFound);
}
497547
function endpointMatchDesiredInterface(endpoint) {
    var interfaceToUse = 'public';
    if (options.useInternal === true) {
      interfaceToUse = 'internal';
    } else if (options.useAdmin === true) {
      interfaceToUse = 'admin';
    }
    return endpoint['interface'] === interfaceToUse;
  }
1287300
function MIDINotMIDIError() {
    Error.call(this);
    Error.captureStackTrace(this, this.constructor);

    this.name = this.constructor.name;
    this.message = 'Not a valid MIDI file';
}
1161030
def method_missing(meth, *args, &block)
      raise NoMethodError, "undefined method #{meth} for #{self.class.to_s}" if WotApiRu::Constants::PATH[meth.to_sym].nil?
      options = args[0] || {}
      options[:application_id] ||= WotApiRu::Settings[:application_id]
      path = WotApiRu::Constants::HOST + WotApiRu::Constants::PATH[meth.to_sym]
      invoke(path, options)
    end
71777
@Override
    protected Class<?> resolveProxyClass(String[] interfaceNames) throws ClassNotFoundException {
        ClassLoader proxyClassLoader = classLoader;
        Class<?>[] interfaces = new Class[interfaceNames.length];
        Class<?> nonPublicInterface = null;

        for (int i = 0; i < interfaceNames.length; i++) {
            Class<?> intf = loadClass(interfaceNames[i]);

            if (!Modifier.isPublic(intf.getModifiers())) {
                ClassLoader classLoader = getClassLoader(intf);
                if (nonPublicInterface != null) {
                    if (classLoader != proxyClassLoader) {
                        throw new IllegalAccessError(nonPublicInterface + " and " + intf + " both declared non-public in different class loaders");
                    }
                } else {
                    nonPublicInterface = intf;
                    proxyClassLoader = classLoader;
                }
            }

            interfaces[i] = intf;
        }

        try {
            return Proxy.getProxyClass(proxyClassLoader, interfaces);
        } catch (IllegalArgumentException ex) {
            throw new ClassNotFoundException(null, ex);
        }
    }
309824
function APIError(message, type, field) {
  Error.call(this);
  Error.captureStackTrace(this, arguments.callee);
  this.name = 'APIError';
  this.message = message;
  this.type = type;
  this.field = field;
}
7645
function extendsOrImplementsInterface($interfaceName, $includeSelf) {
    $interfacesAll = $this->getAllInterfaces($includeSelf);
    return isset($interfacesAll[$interfaceName]);
  }