          - instance: The instance to register.
          - container: The container in which to register the block.
     */
-    public static func register<T, C: Hashable>(instance: T, container: C, metadata: Metadata = [:]) -> Key {
+    public static func register<T, C: Hashable>(instance: T, container: C, metadata: Any = ()) -> Key {
         return register(key: Key(type: T.self, name: Name.default, container: container), metadata: metadata, cached: true) { instance }
     }
     

    /**
     Retrieve metadata
    */
    public static func metadata(for key: Key) -> Metadata? {
        return lock.read {
            guard let dependency = registrations[key] else { return nil }
            return dependency.metadata
        }
    }
    
    /**
     Retrieve metadata for multiple keys.
    */
    public static func metadata<K: Sequence>(for keys: K) -> [Key: Metadata] where K.Iterator.Element == Key {
        return lock.read { registrations.filter{ keys.contains($0.key) }.map{ (key: $0.key, value: $0.value.metadata) }.dictionary() }
    }
    
    /**

    /**
     Returns true if a registration exists for the given key.
    */
    public static func exists<M>(key: Key, metafilter: Metafilter<M>) -> Bool {
        return lock.read {
            guard let dependency = registrations[key] else { return false }
            guard let metadata = dependency.metadata as? M else { return false }
            return metafilter(metadata)
        }
    }

    /**
     Returns true if a registration exists for the given key.
     */
    public static func exists(key: Key) -> Bool {
        return lock.read { return registrations[key] != nil }
    }
    
    /**
     Returns true if a key with the given type, name, and container exists.
    */
    public static func exists<T, N: Hashable, C: Hashable, M>(type: T.Type, name: N, container: C, metafilter: @escaping Metafilter<M>) -> Bool {
        return exists(key: Key(type: type, name: name, container: container), metafilter: metathunk(metafilter))
    }

    /**
     Returns true if a key with the given type, name, and container exists.
     */
    public static func exists<T, N: Hashable, C: Hashable>(type: T.Type, name: N, container: C) -> Bool {
        return exists(key: Key(type: type, name: name, container: container))
    }
    
    /**
     Returns true if any keys with the given type and name exist in any containers.
    */
    public static func exists<T, N: Hashable, M>(type: T.Type, name: N, metafilter: @escaping Metafilter<M>) -> Bool {
        return exists(type: String(reflecting: type), name: name, container: nil, metafilter: metathunk(metafilter))
    }

    /**
     Returns true if any keys with the given type and name exist in any containers.
     */
    public static func exists<T, N: Hashable>(type: T.Type, name: N) -> Bool {
        return exists(type: String(reflecting: type), name: name, container: nil, metafilter: nil)
    }
    
    /**
     Returns true if any keys with the given type exist in the given container, independent of name.
    */
    public static func exists<T, C: Hashable, M>(type: T.Type, container: C, metafilter: @escaping Metafilter<M>) -> Bool {
        return exists(type: String(reflecting: type), name: nil, container: container, metafilter: metathunk(metafilter))
    }

    /**
     Returns true if any keys with the given type exist in the given container, independent of name.
     */
    public static func exists<T, C: Hashable>(type: T.Type, container: C) -> Bool {
        return exists(type: String(reflecting: type), name: nil, container: container, metafilter: nil)
    }
    
    /**
     Returns true if any keys with the given name exist in the given container, independent of type.
    */
    public static func exists<N: Hashable, C: Hashable, M>(name: N, container: C, metafilter: @escaping Metafilter<M>) -> Bool {
        return exists(type: nil, name: name, container: container, metafilter: metathunk(metafilter))
    }

    /**
     Returns true if any keys with the given name exist in the given container, independent of type.
     */
    public static func exists<N: Hashable, C: Hashable>(name: N, container: C) -> Bool {
        return exists(type: nil, name: name, container: container, metafilter: nil)
    }
    
    /**
     Return true if any keys with the given name exist in any container, independent of type.
    */
    public static func exists<N: Hashable, M>(name: N, metafilter: @escaping Metafilter<M>) -> Bool {
        return exists(type: nil, name: name, container: nil, metafilter: metathunk(metafilter))
    }
    
    /**
     Returns true if there are any keys registered in the given container.
    */
    public static func exists<C: Hashable, M>(container: C, metafilter: @escaping Metafilter<M>) -> Bool {
        return exists(type: nil, name: nil, container: container, metafilter: metathunk(metafilter))
    }

    /**
     Returns true if there are any keys registered in the given container.
     */
    public static func exists<C: Hashable>(container: C) -> Bool {
        return exists(type: nil, name: nil, container: container, metafilter: nil)
    }
    
    /**
     Returns true if there are any keys registered with the given type in any container, independent of name.
    */
    public static func exists<T, M>(type: T.Type, metafilter: @escaping Metafilter<M>) -> Bool {
        return exists(type: String(reflecting: type), name: nil, container: nil, metafilter: metathunk(metafilter))
    }

    /**
     Returns true if there are any keys registered with the given type in any container, independent of name.
     */
    public static func exists<T>(type: T.Type) -> Bool {
        return exists(type: String(reflecting: type), name: nil, container: nil, metafilter: nil)
    }
    
    public static func exists<M>(metafilter: @escaping Metafilter<M>) -> Bool {
        return exists(type: nil, name: nil, container: nil, metafilter: metathunk(metafilter))
    }
    
    /**
