What exactly is does "external only" mean referring to classes?

class AwesomeClass{
   private: int a, int b;
   public AwesomeClass(int x,int y){
      a = x; b = y;
   }
   public void setA(int newa){
        a = newa;
   }
   public void setb(int newb){
        b = newb;
   }
   public int sum(){
       return a+b;
   }
}

DLLFUNC AwesomeClass* ac_create(int a, int b){
    return new AwesomeClass(a,b);
}

DLLFUNC void ac_setA(AwesomeClass* ac, int newa){
    ac.setA(newa);
}

DLLFUNC void ac_setB(AwesomeClass* ac, int newB){
    ac.setB(newB);
}

DLLFUNC int ac_sum(AwesomeClass* ac){
    return ac.sum();
}

#define AwesomeClass int
AwesomeClass* ac_create(int a, int b);
void ac_setA(AwesomeClass* ac, int newa);
void ac_setB(AwesomeClass* ac, int newB);
int ac_sum(AwesomeClass* ac);

AwesomeClass* myinstance = ac_create(3,5);
AwesomeClass* anotherinstance = ac_create(10,11);//you can create as many instances as you want
printf("%d",ac_sum(myinstance));//will show you 8
ac_setA(myinstance,5);
printf("%d",ac_sum(myinstance));//will show you 10

class CObject
{
public:
   // Constructor
   CObject(int, int, int);
   // Destructor
   ~CObject();
   int a;
   int b;
   int c;
   
  // Sample method
  void foo(); 
}

/**
 * Constructor
 */ 
CObject::CObject(int x, int y, int z)
{
   this->a = x;
   this->b = y;
   this->c = z;
}

/**
 * Destructor
 */
CObject::~CObject()
{
}

// Sample method
void CObject::foo()
{
   this->c = this->a + this->b;
}

// Create instance of the class
DLLFUNC CObject *CObject_Create()
{
   return new CObject();
}

DLLFUNC void CObject_Destroy(CObject *instance)
{
   delete instance;
}

// This function will be called in lite-c
DLLFUNC void CObject_foo(CObject *instance)
{
   // Call the function
   instance->foo();
}

typedef struct CObject
{
   int a;
   int b;
   int c;
}CObject;

// Create instance of the class
CObject *CObject_Create();
// Destroy instance of the class
void CObject_Destroy(CObject *instance);
// Call method foo
void CObject_foo(CObject *instance);

#define INTERFACE IDirect3DTexture9

DECLARE_INTERFACE_(IDirect3DTexture9, IDirect3DBaseTexture9)
{
    /*** IUnknown methods ***/
    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void** ppvObj) PURE;
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;

    /*** IDirect3DBaseTexture9 methods ***/
    STDMETHOD(GetDevice)(THIS_ IDirect3DDevice9** ppDevice) PURE;
    STDMETHOD(SetPrivateData)(THIS_ REFGUID refguid,CONST void* pData,DWORD SizeOfData,DWORD Flags) PURE;
    STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid,void* pData,DWORD* pSizeOfData) PURE;
    STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid) PURE;
    STDMETHOD_(DWORD, SetPriority)(THIS_ DWORD PriorityNew) PURE;
    STDMETHOD_(DWORD, GetPriority)(THIS) PURE;
    STDMETHOD_(void, PreLoad)(THIS) PURE;
    STDMETHOD_(D3DRESOURCETYPE, GetType)(THIS) PURE;
    STDMETHOD_(DWORD, SetLOD)(THIS_ DWORD LODNew) PURE;
    STDMETHOD_(DWORD, GetLOD)(THIS) PURE;
    STDMETHOD_(DWORD, GetLevelCount)(THIS) PURE;
    STDMETHOD(SetAutoGenFilterType)(THIS_ D3DTEXTUREFILTERTYPE FilterType) PURE;
    STDMETHOD_(D3DTEXTUREFILTERTYPE, GetAutoGenFilterType)(THIS) PURE;
    STDMETHOD_(void, GenerateMipSubLevels)(THIS) PURE;
    STDMETHOD(GetLevelDesc)(THIS_ UINT Level,D3DSURFACE_DESC *pDesc) PURE;
    STDMETHOD(GetSurfaceLevel)(THIS_ UINT Level,void** ppSurfaceLevel) PURE;//IDirect3DSurface9
    STDMETHOD(LockRect)(THIS_ UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags) PURE;
    STDMETHOD(UnlockRect)(THIS_ UINT Level) PURE;
    STDMETHOD(AddDirtyRect)(THIS_ CONST RECT* pDirtyRect) PURE;
};
MY_DECLARE_INTERFACE(IDirect3DTexture9)