Is default move constructor optimized away by compiler?

I have an std::multimap of the following type:

 typedef std::multimap<std::pair<bool,uint32_t>, FooObject>

The FooObject has default move copy and assign constructors declared:

   FooObject(FooObject&& v) = default;
   FooObject& operator=(FooObject&& other)=default;

The copy/assign constructors are private to disable implicit copy.

So I should be able to emplace a pair into the map like this:

mymap.emplace(std::make_pair(false,32),FooObject());

This throws a list of errors with the one at the end:

error C2660: 'std::pair::pair': function does not take 2 arguments

If I declare move copy assign constructors without "default" then it compiles ok.

   FooObject(FooObject&& v){}
   FooObject& operator=(FooObject&& other){}

Why is that? Does the compiler optimize away these constructors when marked with "default" keyword? I am using MSVC140

UPDATE:

Based on the comments below I found the reason - FooObject has a non-copiable member instance. Here is the FooObject:

#define NO_COPY_ASSIGN(TypeName)   \                                                     
  TypeName (const TypeName &);     \                                                                
  void operator= (const TypeName &);

class FooObject
{
private:
   NO_COPY_ASSIGN(FooObject)
public:
    struct FooStruct
    {
        FooBuffer   frameBuffer;   //<--Here it is
    }fooStruct;

    FooObject(){}


    /** Move constructor to allow insert into vector without copy */
    FooObject(FooObject&& v) = default;
    FooObject& operator=(FooObject&& other) = default;

};

*FooBuffer has also its copy/assign private.But I still don't get why replacing 'default' with {} fixes that.Please explain.