Proper way to expose an API c++

I'm developing an API for my project and I would like to use this API on future projects. The problem is how I expose it:

The API uses a lot of libraries and I don't want the client code to download and compile these libraries over and over again. So my solution is to do something like this:

Engine.hpp

class __declspec(dllexport) Engine
	{
	public:
		Engine();

		~Engine();
	public:
		void run_window();

		// std::vector<UI::Window*> window_list;
	};

	std::string __declspec(dllexport) get_version();

Right now this work as it is, but I want to add some other classes I've created to this exposed class, but the problem arises when I try to include my class, which is dependent on a class (in this case, GLFW). The class simply looks like this:

Window.hpp

#include <GLFW/glfw3.h>

class Window{
public:
   Window(std::string name);
   ...
private:
   GLFWwindow* m_window;
};

So attempting to use UI::Window naturally causes a pre-compilation error saying it can't find GLFW header files, which is not included in client code's cmake. As far as I'm concerned the functions of libraries in Engine should be compiled alongside my code and should be included in the .dll and .lib files, but I'm getting this include error as expected.

I'm a bit new to API design so is there a way / best practice to expose my library dependent code to the client without having them import every single library?

I can use static variables inside the cpp files of Engine but I want the variables to be class members and I want the client to access some of them.

You're #includeing Window.hpp in your compilation unit, and Window.hpp contains #include <GLFW/glfw3.h>, so that's what the compiler tries to do. It has no idea why you're including glfw3.h, just that you told it to do so and that it can't find that file.

Luckily, you don't actually need glfw3.h. Since Window only contains a pointer to a GLFWwindow it has no need for the full definition of GLFWwindow in its header; it just needs to know that it's a class that exists. You tell it that using a forward-declaration:

class GLFWwindow;

class Window{
public:
   Window(std::string name);
   ...
private:
   GLFWwindow* m_window;
};

Then in Window.cpp you can #include the full glfw3.h header so that the Window member functions defined there know what to do. That's fine though, since Window.cpp doesn't need to be compiled when compiling your program (only when compiling your library).

You will still need to link your program to the glfw libraries though.