Где найти полную документацию по объектам языка 1С (для OLE)?

#include <windows.h>
#include <iostream>
#include <io.h>
#include <stdexcept>
#include <fcntl.h>
#include <comdef.h>
#include <vector>
 
#pragma comment(lib, "ole32.lib")
#pragma comment(lib, "oleaut32.lib")
#pragma comment(lib, "comsuppw.lib") // Для _bstr_t
 
 
class OneS77 {
public:
    OneS77(const std::wstring& progId = L"V77S.Application")
    {
        // Инициализация COM и консоли
        ::SetConsoleOutputCP(CP_UTF8);
        ::SetConsoleCP(CP_UTF8);
        _setmode(_fileno(stdout), _O_WTEXT);
        HRESULT hr = ::CoInitialize(nullptr);
        if (FAILED(hr)) throw_com(L"CoInitialize", hr);
 
        CLSID cls;
        hr = ::CLSIDFromProgID(progId.c_str(), &cls);
        if (FAILED(hr)) throw_com(L"CLSIDFromProgID(" + progId + L")", hr);
 
        hr = ::CoCreateInstance(cls, nullptr, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void**)&pApp);
        if (FAILED(hr) || !pApp) throw_com(L"CoCreateInstance(" + progId + L")", hr);
    }
 
    ~OneS77()
    {
        if (pApp) pApp->Release();
        ::CoUninitialize();
    }
 
    // Инициализация платформы через RMTrade
    void Initialize(const std::wstring& baseParams, bool noSplash = true)
    {
        auto code = getIntProperty(L"RMTrade");
        auto disp = getDispId(L"Initialize");
        std::vector<VARIANT> args;
        // Обратный порядок
        if (noSplash) args.push_back(makeBstr(L"NO_SPLASH_SHOW"));
        args.push_back(makeBstr(baseParams));
        args.push_back(makeI4(code));
        VARIANT result;
 
        invoke(disp, args, result);
        if (!(result.vt == VT_BOOL && result.boolVal == VARIANT_TRUE))
        {
            throw std::runtime_error("Initialize returned false");
        }
    }
 
    // Вызов встроенного выражения через EvalExpr
    std::wstring EvalExpr(const std::wstring& expr)
    {
        auto disp = getDispId(L"EvalExpr");
        std::vector<VARIANT> args{ makeBstr(expr) };
        VARIANT res;
        invokePropertyGet(disp, args, res);
        if (res.vt != VT_BSTR) throw std::runtime_error("EvalExpr non-string result");
        std::wstring out = res.bstrVal;
        return out;
    }
 
    // Создание объекта 1С через CreateObject
    VARIANT CreateObject(const std::wstring& objName)
    {
        auto disp = getDispId(L"CreateObject");
        VARIANT arg = makeBstr(objName);
        VARIANT res;
        invoke(disp, {arg}, res);
        VariantClear(&arg);
        if (res.vt != VT_DISPATCH) throw std::runtime_error("CreateObject returned non-dispatch");
        return res;
    }
 
    // Установка свойства или реквизита через SetValue
    void SetValue(IDispatch* obj, const std::wstring& prop, const VARIANT& value)
    {
        // Метод SetValue(obj, prop, value)
        DISPID disp = getDispId(L"SetValue");
        // args: value, property name, object
        std::vector<VARIANT> args{ value, makeBstr(prop), makeDispatchVariant(obj) };
        VARIANT res;
        invoke(disp, args, res);
        VariantClear(&res);
    }
 
    // Вызов метода на переданном объекте через IDispatch::Invoke
    void InvokeMethod(IDispatch* obj, const std::wstring& method, const std::vector<VARIANT>& params)
    {
        DISPID disp;
        OLECHAR* name = const_cast<OLECHAR*>(method.c_str());
        HRESULT hr = obj->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &disp);
        if (FAILED(hr)) throw_com(L"GetIDsOfNames(" + method + L")", hr);
 
        // Подготовка параметров
        std::vector<VARIANT> args = params;
        DISPPARAMS dp;
        dp.cArgs = (UINT)args.size();
        dp.rgvarg = args.empty() ? nullptr : args.data();
        dp.cNamedArgs = 0;
        dp.rgdispidNamedArgs = nullptr;
 
        VARIANT res;
        VariantInit(&res);
        hr = obj->Invoke(disp, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &dp, &res, nullptr, nullptr);
        if (FAILED(hr)) throw_com(L"InvokeMethod(" + method + L")", hr);
        VariantClear(&res);
    }
 
private:
    IDispatch* pApp = nullptr;
 
    void throw_com(const std::wstring& func, HRESULT hr)
    {
        _com_error err(hr);
        std::wstring msg = func + L" failed: " + err.ErrorMessage();
        throw std::runtime_error(std::string(msg.begin(), msg.end()));
    }
 
    DISPID getDispId(const std::wstring& name)
    {
        DISPID disp;
        OLECHAR* nm = const_cast<OLECHAR*>(name.c_str());
        HRESULT hr = pApp->GetIDsOfNames(IID_NULL, &nm, 1, LOCALE_USER_DEFAULT, &disp);
        if (FAILED(hr)) throw_com(L"GetIDsOfNames(" + name + L")", hr);
        return disp;
    }
 
 
    int getIntProperty(const std::wstring & name)
    {
        auto disp = getDispId(name);
        VARIANT var;
        VariantInit(&var);
        DISPPARAMS dp{ nullptr, nullptr, 0, 0 };
        HRESULT hr = pApp->Invoke(disp, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &dp, &var, nullptr, nullptr);
        if (FAILED(hr) || var.vt != VT_I4) throw_com(L"PropertyGet(" + name + L")", hr);
        int val = var.lVal;
        VariantClear(&var);
        return val;
    }
 
    VARIANT makeBstr(const std::wstring& s)
    {
        VARIANT v;
        VariantInit(&v);
        v.vt = VT_BSTR;
        v.bstrVal = SysAllocString(s.c_str());
        return v;
    }
 
    VARIANT makeI4(int x)
    {
        VARIANT v;
        VariantInit(&v);
        v.vt = VT_I4;
        v.lVal = x;
        return v;
    }
 
    // Служебный вариант для передачи IDispatch* в методы SetValue и др.
    VARIANT makeDispatchVariant(IDispatch* obj)
    {
        VARIANT v;
        VariantInit(&v);
        v.vt = VT_DISPATCH;
        v.pdispVal = obj;
        return v;
    }
 
    void invoke(DISPID disp, const std::vector<VARIANT>& args, VARIANT& result)
    {
        DISPPARAMS dp;
        dp.cArgs = (UINT)args.size();
        dp.rgvarg = const_cast<VARIANT*>(args.data());
        dp.cNamedArgs = 0;
        dp.rgdispidNamedArgs = nullptr;
        VariantInit(&result);
        HRESULT hr = pApp->Invoke(disp, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &dp, &result, nullptr, nullptr);
        if (FAILED(hr)) throw_com(L"Invoke method", hr);
    }
 
    void invokePropertyGet(DISPID disp, const std::vector<VARIANT>& args, VARIANT& result)
    {
        DISPPARAMS dp;
        dp.cArgs = (UINT)args.size();
        dp.rgvarg = const_cast<VARIANT*>(args.data());
        dp.cNamedArgs = 0;
        dp.rgdispidNamedArgs = nullptr;
        VariantInit(&result);
        HRESULT hr = pApp->Invoke(disp, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &dp, &result, nullptr, nullptr);
        if (FAILED(hr)) throw_com(L"Invoke property get", hr);
    }
};
 
int wmain()
{
    try {
        OneS77 v7;
        v7.Initialize(L"/D \"E:\\111111C\\БАЗА 2014 2\\1SBDB\"");
        auto res = v7.EvalExpr(L"\"Hello\"");
        std::wcout << L"EvalExpr: " << res << std::endl;
 
        VARIANT docVar = v7.CreateObject(L"Документ.ОперацияПоРасчСчету");
        IDispatch* pDoc = docVar.pdispVal;
 
        v7.InvokeMethod(pDoc, L"ПолучитьДокумент", {});
    
    }
    catch (const std::exception& ex)
    {
        std::wcout << L"Error: " << std::wstring(ex.what(), ex.what() + strlen(ex.what())) << std::endl;
    }
 
    return 0;
}