_HeaderOutputPredefine.h

#pragma once
 
// clang-format off
 
#ifdef _MSC_VER
#pragma warning(disable : 4099) // for MOJANG : type name first seen using 'class' now seen using 'struct'
#pragma warning(disable : 4201) // for MOJANG : nonstandard extension used : nameless struct/union
#pragma warning(disable : 4373) // for MOJANG : override virtual function with different const/volatile params
#endif
 
#include "ll/api/base/Macro.h"
 
#define MCAPI  LL_SHARED_IMPORT
#define MCTAPI template<> MCAPI
#define MCFOLD MCAPI /*Identical COMDAT Folding*/
#define MCNAPI [[deprecated("This API is not available. Open an issue if you need it. "\
                            "https://github.com/LiteLDev/mcapi-requests/issues/new")]] MCAPI
 
#include <algorithm>          // STL general algorithms
#include <array>              // STL array container
#include <bitset>             // STL bitset container
#include <cctype>             // Character handling functions
#include <cerrno>             // C Error codes
#include <chrono>             // C++11 Time library
#include <clocale>            // C localization library
#include <cmath>              // Common mathematics functions
#include <complex>            // Complex number type
#include <condition_variable> // condition variable
#include <cstdio>             // C Standard Input/Output library
#include <cstdlib>            // C Standard General Utilities Library
#include <cstring>            // C string handling
#include <ctime>              // C Time library
#include <cwchar>             // Wide character type
#include <cwctype>            // Wide character classification
#include <deque>              // STL double ended queue container
#include <exception>          // Exception handling classes
#include <filesystem>         // STL file system
#include <forward_list>       // STL forward list container
#include <fstream>            // File stream classes
#include <functional>         // STL Function objects
#include <iomanip>            // Input/Output manipulators
#include <ios>                // Base input/output stream classes
#include <iosfwd>             // Input/Output forward declarations
#include <iostream>           // Standard Input/Output stream objects
#include <istream>            // Basic input stream classes
#include <limits>             // Numeric limits
#include <list>               // STL linear list container
#include <map>                // STL map container
#include <memory>             // STL unique_ptr, shared_ptr, weak_ptr
#include <mutex>              // STL mutual exclusion primitives
#include <numbers>            // numbers standard header
#include <optional>           // STL optional type
#include <ostream>            // Basic output stream classes
#include <queue>              // STL queue and priority_queue container
#include <random>             // C++11 Random numbers
#include <set>                // STL set and multiset container
#include <shared_mutex>       // STL shared mutual exclusion primitives
#include <sstream>            // String stream classes
#include <stack>              // STL stack container
#include <stdexcept>          // Standard exception objects
#include <streambuf>          // Stream buffer classes
#include <string>             // String class
#include <string_view>        // STL string_view type
#include <unordered_map>      // STL unordered map container
#include <unordered_set>      // STL unordered set container
#include <utility>            // STL utility components
#include <variant>            // STL variant type
#include <vector>             // STL dynamic array container
#include <future>             // STL future
#include <regex>         // Regular expression library
#include <any>           // STL any type
 
// STL expected for C++23
#if LL_HAS_CXX23
#include <expected>
#endif
 
#include "entt/entt.hpp" // Entity Component System Library
#include "entt/fwd.hpp"  // Entity Component Forward Declarations
#include "glm/glm.hpp"   // OpenGL Mathematics Library
#include "glm/ext.hpp"   // OpenGL Mathematics Library
#include "gsl/gsl"       // Guideline Support Library
 
// LevelDB C++ Library
#include "leveldb/c.h"
#include "leveldb/cache.h"
#include "leveldb/comparator.h"
#include "leveldb/db.h"
#include "leveldb/dumpfile.h"
#include "leveldb/env.h"
#include "leveldb/filter_policy.h"
#include "leveldb/iterator.h"
#include "leveldb/options.h"
#include "leveldb/slice.h"
#include "leveldb/status.h"
#include "leveldb/table.h"
#include "leveldb/table_builder.h"
#include "leveldb/write_batch.h"
 
// RapidJSON C++ Library
#include "rapidjson/document.h"
#include "rapidjson/encodings.h"
#include "rapidjson/error/en.h"
#include "rapidjson/filereadstream.h"
#include "rapidjson/filewritestream.h"
#include "rapidjson/pointer.h"
#include "rapidjson/prettywriter.h"
#include "rapidjson/rapidjson.h"
#include "rapidjson/reader.h"
#include "rapidjson/schema.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/writer.h"
 
// type_safe C++ Library
#include "type_safe/strong_typedef.hpp"
 
// expected_lite C++ Library
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4702)
#endif
#define nsel_CONFIG_SELECT_EXPECTED 1
#include "nonstd/expected.hpp"
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#include "ll/api/base/Alias.h"
#include "ll/api/base/StdInt.h"
 
// fmt C++ Library
#include "fmt/format.h"
#include "fmt/std.h"
 
// moodycamel::ConcurrentQueue C++ Library
#include "concurrentqueue.h" 
 
// stb C++ Library
#include "stb_truetype.h"
 
struct HWND__;
struct HKEY__;
struct HICON__;
struct tagRECT;
struct _TP_CALLBACK_INSTANCE;
struct _TP_WAIT;
struct _TP_WORK;
struct _TP_TIMER;
typedef long HRESULT;
enum _WINHTTP_WEB_SOCKET_BUFFER_TYPE;
struct in6_addr;
struct in_addr;
struct sockaddr;
struct addrinfo;
struct _IP_ADAPTER_PREFIX_XP;
struct sockaddr_storage;
struct sockaddr_in;
struct sockaddr_in6;
struct evp_md_ctx_st;
struct asn1_string_st;
struct bio_st;
struct XUser;
struct tagPOINT;
struct _INITIALIZE_OPTIONS;
struct HC_CALL;
struct tagWNDCLASSEXW;
struct HINSTANCE__;
 
// DirectX definitions
typedef enum D3D_FEATURE_LEVEL;
typedef enum DXGI_SWAP_EFFECT;
typedef enum DXGI_FORMAT;
typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS;
typedef enum D3D_SHADER_MODEL;
typedef enum D3D_DRIVER_TYPE;
typedef enum D3D12_RESOURCE_STATES;
typedef enum D3D12_RESOURCE_FLAGS;
struct IDXGISwapChain3;
struct ID3D11Texture2D;
struct ID3D11Device;
struct ID3D11DeviceContext;
struct ID3DUserDefinedAnnotation;
struct ID3D11InfoQueue;
struct ID3D11RenderTargetView;
struct ID3D11DepthStencilView;
struct ID3D11BlendState;
struct ID3D11DepthStencilState;
struct ID3D11InputLayout;
struct ID3D11RasterizerState;
struct ID3D11SamplerState;
struct IUnknown;
struct ID3D11ShaderResourceView;
struct ID3D11UnorderedAccessView;
struct ID3D12DescriptorHeap;
struct ID3D12Resource;
struct ID3D12Device;
struct ID3D12Device5;
struct ID3D12CommandSignature;
struct D3D12_CPU_DESCRIPTOR_HANDLE;
// Because these are used in TypedStorage, we need to define them here to avoid compilation errors.
#ifndef D3D12_RAYTRACING_GEOMETRY_DESC
struct D3D12_RAYTRACING_GEOMETRY_DESC {};
#endif
#ifndef D3D12_FEATURE_DATA_ARCHITECTURE
struct D3D12_FEATURE_DATA_ARCHITECTURE {};
#endif
#ifndef D3D12_FEATURE_DATA_D3D12_OPTIONS
struct D3D12_FEATURE_DATA_D3D12_OPTIONS {};
#endif
 
namespace GameInput::v2 {
    class IGameInput;
}
namespace Bedrock {
    template<typename T>
    struct ComAdapter {
        std::unique_ptr<T>* mParent;
        T* mPtr;
 
        struct Deleter {
            void operator()(T* ptr);
        };
    };
}
struct APP_LOCAL_DEVICE_ID;
namespace winrt
{
    struct event_token;
    namespace Windows
    {
        namespace UI::Text::Core
        {
            struct CoreTextEditContext;
        }
 
        namespace ApplicationModel::DataTransfer
        {
            struct DataTransferManager;
        }
    }
}
namespace DirectX {
    struct XMMATRIX;
}
 
#include "mc/deps/core/utility/optional_ref.h" // replace optional<reference_wrapper<>>
#include "mc/platform/brstd/function_ref.h"    // function reference
#include "mc/math/vector/Vecs.h"               // for vector types
 
template <typename T0, typename T1>
class AutomaticID {
public:
    T1 mValue;
 
    [[nodiscard]] constexpr AutomaticID() : mValue(0) {}
 
    [[nodiscard]] constexpr AutomaticID(T1 x) : mValue(x) {}
 
    [[nodiscard]] constexpr operator T1() const { return mValue; }
 
    [[nodiscard]] inline bool operator==(AutomaticID const& other) const { return mValue == other.mValue; }
 
    [[nodiscard]] inline bool operator==(T1 const& other) const { return mValue == other; }
 
    [[nodiscard]] inline std::strong_ordering operator<=>(AutomaticID const& other) const { return mValue <=> other.mValue; }
 
    [[nodiscard]] inline std::strong_ordering operator<=>(T1 const& other) const { return mValue <=> other; }
};
template <typename A, typename T>
struct std::hash<AutomaticID<A, T>> {
    size_t operator()(AutomaticID<A, T> const& dimId) const { return static_cast<size_t>(dimId.mValue); }
};
class Dimension;
using DimensionType = AutomaticID<Dimension, int>;
 
struct RecipeNetIdTag;
struct CreativeItemNetIdTag;
struct ContainerRuntimeIdTag;
struct ItemStackNetIdTag;
struct ItemStackRequestIdTag;
struct ItemStackLegacyRequestIdTag;
 
template <typename T0, typename T1 = uint, int T2 = 0>
class TypedClientNetId;
template <typename T0, typename T1 = uint, int T2 = 0>
class TypedServerNetId;
template <typename T0, typename T1 = uint, int T2 = 0>
class TypedRuntimeId;
 
using RecipeNetId              = TypedServerNetId<RecipeNetIdTag>;
using CreativeItemNetId        = TypedServerNetId<CreativeItemNetIdTag>;
using ContainerRuntimeId       = TypedRuntimeId<ContainerRuntimeIdTag>;
using ItemStackNetId           = TypedServerNetId<ItemStackNetIdTag, int>;
using ItemStackRequestId       = TypedClientNetId<ItemStackRequestIdTag, int>;
using ItemStackLegacyRequestId = TypedClientNetId<ItemStackLegacyRequestIdTag, int>;
 
class BlockType;
template <typename T0>
class ActorBlockBase;
using ActorBlock = ActorBlockBase<BlockType>;
 
template<int>
class ParityImprovedNoiseImpl;
 
template<typename T>
class buffer_span_mut {
public:
    T* mBegin;
    T* mEnd;
    class iterator {
    public:
        T* mPtr;
    };
};
 
namespace Bedrock {
template <typename T, typename Err = std::error_code>
class Result;
template <typename T>
class NonOwnerPointer;
template <typename T>
using NotNullNonOwnerPtr = gsl::not_null<NonOwnerPointer<T>>;
 
template <typename T, typename... Args>
class ImplBase {
public:
    virtual ~ImplBase() = default;
};
 
template <typename T, typename U, typename A, typename M>
class AccessUpdateEditor;
namespace Detail {
template <typename T, typename U = void>
struct AccessUpdateEditorAccessor;
}
 
namespace Threading {
template <typename T, typename Alloc = std::allocator<T>>
class ThreadLocalObject;
}
}
 
namespace Core {
template <typename... Params>
class CallbackListeners {
public:
    class Listener {};
};
template <typename TKey, typename TValue, typename TValuePtr, typename... TNewInstanceArgs>
class LRUCache {
public:
    void* mUnk[14];
};
}
 
namespace Puv {
template <typename From, typename To, typename CustomData>
class CerealUpgrader;
 
template <typename T0, typename T1, typename T2, typename T3>
class SlicedLoader;
}
 
namespace Social {
enum class SignInResult;
}
 
namespace NetherNet::Utils {
template <typename T>
class ThreadSafe {
public:
    class View {};
};
}
 
namespace rtc {
template<class T, size_t N = size_t(-4711ll)>
class ArrayView;
}
 
template <typename T0>
class http_stl_allocator;
using http_string  = std::basic_string<char, std::char_traits<char>, class http_stl_allocator<char>>;
using http_wstring = std::basic_string<wchar_t, std::char_traits<wchar_t>, class http_stl_allocator<wchar_t>>;
 
namespace asio::ssl {
class verify_context;
}
 
namespace leveldb {
class Compressor;
class DecompressAllocator;
}
 
// clang-format on