         - cached: Whether or not to cache the result of the registration block.
         - registration: The block to register with Guise.
     */
-    public static func register<P, T, N: Hashable, C: Hashable>(name: N, container: C, metadata: Metadata = [:], cached: Bool = false, registration: @escaping Registration<P, T>) -> Key {
+    public static func register<P, T, N: Hashable, C: Hashable>(name: N, container: C, metadata: Any = (), cached: Bool = false, registration: @escaping Registration<P, T>) -> Key {
         return register(key: Key(type: T.self, name: name, container: container), metadata: metadata, cached: cached, registration: registration)
     }
-
+    
     /**
      Register the `registration` block with Guise under the given name and in the default container.
      

    /**
     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() }
    }
    
    /**

     Because all of type, name, and container are specified, this particular method will return either 
     an empty array or an array with a single value.
    */
    public static func filter<T, N: Hashable, C: Hashable, M>(type: T.Type, name: N, container: C, metafilter: Metafilter<M>) -> [Key] {
        let key = Key(type: type, name: name, container: container)
        return filter(key: key, metafilter: metafilter)
    }
    
    /**
     Find all keys for the given type, name, and container.
     
     Because all of type, name, and container are specified, this particular method will return either
     an empty array or an array with a single value.
     */
    public static func filter<T, N: Hashable, C: Hashable>(type: T.Type, name: N, container: C) -> [Key] {
        let key = Key(type: type, name: name, container: container)
        return filter(key: key)
    }
