// =============================================================================
// Azul C++20 API Wrapper
// =============================================================================
//
// Compile with: g++ -std=c++20 -o myapp myapp.cpp -lazul
//
// This header provides C++ wrapper classes for the Azul C API.
// All classes use RAII for memory management.
//
// C++17+ FEATURES:
//   - String supports std::string_view constructor and conversion
//   - Option types support toStdOptional() and std::optional conversion
//   - [[nodiscard]] attributes for static constructors
//
// C++20+ FEATURES:
//   - Vec types support toSpan() and std::span conversion for zero-copy access
//
// =============================================================================

#ifndef AZUL_CPP20_HPP
#define AZUL_CPP20_HPP

extern "C" {
#include "azul.h"
}

#include <cstdint>
#include <cstddef>
#include <cstring>
#include <utility>
#include <stdexcept>
#include <string>
#include <vector>
#include <optional>
#include <variant>
#include <type_traits>
#include <concepts>
#include <span>
#include <string_view>
#include <functional>

template<class W, class F> inline W az_detail_wrap_cb(F f) { W w = W(); w.cb = f; return w; }

// Helper to create AzString from string literal
inline AzString az_string_from_literal(const char* s) {
    return AzString_copyFromBytes(reinterpret_cast<const uint8_t*>(s), 0, std::strlen(s));
}

namespace azul {

// Forward declarations
class MonitorId;
class WasmWindowOptions;
class IconKey;
class MacWindowOptions;
class IOSHandle;
class MacOSHandle;
class XcbHandle;
class XlibHandle;
class WaylandHandle;
class WindowsHandle;
class WebHandle;
class AndroidHandle;
class IconProviderHandle;
class VideoModeVecSlice;
class MonitorVecSlice;
class MimeTypeDataVecSlice;
class TouchPointVecSlice;
class AudioSink;
class HttpHeaderVecSlice;
class MsgBox;
class FileDialog;
class ColorPickerDialog;
class RefCount;
class GraphemeClusterId;
class PenTilt;
class NodeFlags;
class DomId;
class NodeHierarchyItemId;
class NodeHierarchyItem;
class TagId;
class DebugState;
class GeolocationProbeConfig;
class LocationFix;
class NodeId;
class SelectionId;
class TextInputSelectionRange;
class TextSelectionStartEnd;
class NodeDataVecSlice;
class NodeHierarchyItemVecSlice;
class DomIdVecSlice;
class TagIdToNodeIdMappingVecSlice;
class VertexAttributeVecSlice;
class NodeHierarchyItemIdVecSlice;
class IdOrClassVecSlice;
class SelectionRangeVecSlice;
class SelectionVecSlice;
class DomVecSlice;
class AttributeTypeVecSlice;
class AccessibilityActionVecSlice;
class CoreCallbackDataVecSlice;
class ParentWithNodeDepthVecSlice;
class XmlNodeChildVecSlice;
class AccessibilitySettings;
class InputMetrics;
class DragDelta;
class MenuItemVecSlice;
class CssNthChildPattern;
class ColorU;
class FloatValue;
class LayoutSize;
class StyleLineClamp;
class Orphans;
class Widows;
class StyleHangingPunctuation;
class XmlTextPos;
class LogicalSize;
class StyledNodeState;
class CssPropertyCachePtr;
class SvgRenderTransform;
class LogicalPosition;
class ScreenPosition;
class CursorNodePosition;
class GridMinMax;
class ShapePoint;
class LayoutRectVecSlice;
class LayoutPoint;
class LinuxDecorationsState;
class CascadeInfo;
class GridTrackSizingVecSlice;
class ContentGroupVecSlice;
class StyledTextRunVecSlice;
class CssRuleBlockVecSlice;
class CascadeInfoVecSlice;
class NormalizedRadialColorStopVecSlice;
class StyleFontFamilyVecSlice;
class StyleFilterVecSlice;
class StyleBackgroundSizeVecSlice;
class StyleBackgroundContentVecSlice;
class CssDeclarationVecSlice;
class StyleBackgroundPositionVecSlice;
class NormalizedLinearColorStopVecSlice;
class CssPropertyWithConditionsVecSlice;
class CssVecSlice;
class StyleTransformVecSlice;
class StyledNodeVecSlice;
class ShapePointVecSlice;
class NamedFontVecSlice;
class GridAreaDefinitionVecSlice;
class SvgTransform;
class ScrollbarFadeDuration;
class ScrollbarFadeDelay;
class U16VecSlice;
class AudioMetrics;
class ScrollPhysics;
class CalcAstItemVecSlice;
class MinMaxRange;
class AspectRatioValue;
class F32VecSlice;
class EmptyStruct;
class U32VecSlice;
class DynamicSelectorVecSlice;
class U8VecSlice;
class MapTileId;
class MapViewport;
class CheckBoxState;
class NumberInputState;
class ProgressBarState;
class TabHeaderState;
class ListViewRowVecSlice;
class TitlebarButtons;
class RibbonSectionVecSlice;
class RibbonTabVecSlice;
class TreeViewNodeVecSlice;
class MapLatLon;
class GlVoidPtrConst;
class GlVoidPtrMut;
class TextureFlags;
class GLsyncPtr;
class SvgVertex;
class SvgVertexVecSlice;
class DebugMessageVecSlice;
class ImageRef;
class ImageDescriptorFlags;
class ImageRefHash;
class RouteVecSlice;
class VideoEncoder;
class VideoDecoder;
class Panose;
class LoadedFontVecSlice;
class Svg;
class CssPathSelectorVecSlice;
class SvgDashPattern;
class SvgVector;
class SvgRect;
class SvgPoint;
class SvgPathVecSlice;
class SvgPathElementVecSlice;
class SystemTickDiff;
class SystemTick;
class SystemTimeDiff;
class CssDuration;
class IcuTime;
class StringPairVecSlice;
class StringVecSlice;
class GLbooleanVecRefMut;
class GLfloatVecRefMut;
class U8VecRefMut;
class TessellatedSvgNodeVecRef;
class F32VecRef;
class GLuintVecRef;
class I32VecRef;
class U8VecRef;
class GLintVecRefMut;
class GLenumVecRef;
class GLint64VecRefMut;
class RefstrVecRef;
class HttpResponseTooLargeError;
class ErrorLocation;
class CssSyntaxErrorPos;
class App;
class TimerId;
class Thread;
class ThreadId;
class TimerIdVecSlice;
class ThreadIdVecSlice;
class ExternalResourceVecSlice;
class DirEntryVecSlice;
class FmtArgVecSlice;
class JsonKeyValueVecSlice;
class JsonVecSlice;
class Db;
class Pdf;
class GamepadId;
class WacomPadState;
class AudioConfig;
class Udp;
class DbValueVecSlice;
class IcuDate;
class IcuLocalizerHandle;
class FluentLocalizerHandle;
class ComponentDataFieldVecSlice;
class ComponentLibraryVecSlice;
class ComponentDefVecSlice;
class ComponentDataModelVecSlice;
class ComponentEnumVariantVecSlice;
class ComponentFieldTypeBox;
class ComponentEnumModelVecSlice;
class ComponentFieldOverrideVecSlice;
class ComponentCallbackArgVecSlice;
class DpiScaleFactor;
class WindowFlags;
class VideoMode;
class TextCursor;
class XWindowTypeVecSlice;
class TouchPoint;
class DetectedPinch;
class TimerCallbackReturn;
class RefAny;
class PenState;
class ScrollState;
class DomNodeId;
class ParentWithNodeDepth;
class SelectionColor;
class VirtualKeyCodeVecSlice;
class AccessibilityStateVecSlice;
class ScanCodeVecSlice;
class PixelValue;
class StyleColorMatrix;
class LayoutFlexGrow;
class LayoutFlexShrink;
class PercentageValue;
class AngleValue;
class DirectionCorners;
class StyleBorderBottomColor;
class StyleBorderBottomStyle;
class StyleBorderLeftColor;
class StyleBorderLeftStyle;
class StyleBorderRightColor;
class StyleBorderRightStyle;
class StyleBorderTopColor;
class StyleBorderTopStyle;
class StyleTransformMatrix2D;
class StyleTransformMatrix3D;
class StyleTransformScale2D;
class StyleTransformScale3D;
class StyleTextColor;
class SelectionBackgroundColor;
class ColumnRuleColor;
class CaretAnimationDuration;
class ColumnRuleStyle;
class ShapeImageThreshold;
class CaretColor;
class StyleExclusionMargin;
class StyleInitialLetter;
class ScrollbarColorCustom;
class ShapeInset;
class ShapeEllipse;
class LayoutRect;
class StyledNode;
class ArithmeticCoefficients;
class StyleBackgroundRepeatVecSlice;
class ScrollbarPreferences;
class TextRenderingHints;
class AnimationMetrics;
class CssSyntaxInvalidAdvance;
class SvgFillStyle;
class OsVersion;
class VisualHints;
class StyleClipRect;
class DesktopEnvVersion;
class ColorInputState;
class OnTextInputReturn;
class GlShaderPrecisionFormatReturn;
class GlContextPtr;
class GLuintVecSlice;
class GLintVecSlice;
class ImageDescriptor;
class FontMetrics;
class FontRef;
class LogicalRect;
class ShapeCircle;
class SvgLine;
class SvgCubicCurve;
class SvgQuadraticCurve;
class GetSystemTimeCallback;
class ScrollIntoViewOptions;
class NonXmlCharError;
class InvalidCharError;
class InvalidQuoteError;
class InvalidSpaceError;
class ErrorLocationRange;
class RendererOptions;
class FileMetadata;
class SensorReading;
class GamepadState;
class CameraConfig;
class ScreenCaptureConfig;
class DetectedRotation;
class DetectedLongPress;
class IcuDateTime;
class HidpiAdjustedBounds;
class WindowSize;
class TextOpMoveCursor;
class CallbackInfo;
class TagIdToNodeIdMapping;
class MouseState;
class SelectionRange;
class SelectionRadius;
class PixelValueSize;
class PixelValueNoPercent;
class StyleBlur;
class StyleFilterOffset;
class LayoutLeft;
class LayoutMarginBottom;
class LayoutMarginLeft;
class LayoutMarginRight;
class LayoutMarginTop;
class LayoutMaxHeight;
class LayoutMaxWidth;
class LayoutMinHeight;
class LayoutMinWidth;
class LayoutPaddingBottom;
class LayoutPaddingLeft;
class LayoutPaddingRight;
class LayoutPaddingTop;
class LayoutRight;
class LayoutTop;
class NormalizedLinearColorStop;
class NormalizedRadialColorStop;
class StyleBorderBottomLeftRadius;
class StyleBorderBottomRightRadius;
class LayoutBorderBottomWidth;
class LayoutBorderLeftWidth;
class LayoutBorderRightWidth;
class StyleBorderTopLeftRadius;
class StyleBorderTopRightRadius;
class LayoutBorderTopWidth;
class StyleFontSize;
class StyleLetterSpacing;
class StyleLineHeight;
class StyleOpacity;
class StyleTransformOrigin;
class StyleTransformTranslate2D;
class StyleTransformTranslate3D;
class StyleTransformRotate3D;
class StyleTransformSkew2D;
class StyleWordSpacing;
class StylePerspectiveOrigin;
class LayoutGap;
class ShapeMargin;
class ColumnRuleWidth;
class StyleTextIndent;
class LayoutBorderSpacing;
class LayoutPaddingInlineStart;
class LayoutColumnGap;
class LayoutPaddingInlineEnd;
class LayoutRowGap;
class LayoutInsetBottom;
class SystemColors;
class CaretWidth;
class StyleTabSize;
class StyleOverflowClipMargin;
class Texture;
class ImageMask;
class SvgStrokeStyle;
class InstantPtr;
class ListViewRowVec;
class StyleFilterVec;
class AccessibilityStateVec;
class MenuItemVec;
class StyleFontFamilyVec;
class DomVec;
class IdOrClassVec;
class DynamicSelectorVec;
class CssPropertyWithConditionsVec;
class StyleBackgroundContentVec;
class StyleBackgroundPositionVec;
class StyleBackgroundRepeatVec;
class StyleBackgroundSizeVec;
class StyleTransformVec;
class SvgVertexVec;
class U32Vec;
class VirtualKeyCodeVec;
class CascadeInfoVec;
class CssDeclarationVec;
class CssPathSelectorVec;
class CssVec;
class CssRuleBlockVec;
class U16Vec;
class F32Vec;
class U8Vec;
class GLuintVec;
class GLintVec;
class StringVec;
class MimeTypeDataVec;
class StringPairVec;
class NormalizedLinearColorStopVec;
class NormalizedRadialColorStopVec;
class NodeHierarchyItemVec;
class TagIdToNodeIdMappingVec;
class ParentWithNodeDepthVec;
class NodeDataVec;
class AttributeTypeVec;
class CoreCallbackDataVec;
class AccessibilityActionVec;
class GridTrackSizingVec;
class VertexAttributeVec;
class DebugMessageVec;
class ShapePointVec;
class MonitorVec;
class VideoModeVec;
class XWindowTypeVec;
class ScanCodeVec;
class ContentGroupVec;
class StyledNodeVec;
class DomIdVec;
class TimerIdVec;
class SelectionRangeVec;
class ThreadIdVec;
class StyledTextRunVec;
class SelectionVec;
class HttpHeaderVec;
class FmtArgVec;
class JsonVec;
class DirEntryVec;
class JsonKeyValueVec;
class NamedFontVec;
class ExternalResourceVec;
class NodeHierarchyItemIdVec;
class CalcAstItemVec;
class GridAreaDefinitionVec;
class ComponentDataFieldVec;
class ComponentDefVec;
class ComponentLibraryVec;
class ComponentDataModelVec;
class ComponentEnumModelVec;
class ComponentEnumVariantVec;
class ComponentCallbackArgVec;
class ComponentFieldOverrideVec;
class SvgPathElementVec;
class SvgPathVec;
class RibbonSectionVec;
class RibbonTabVec;
class TreeViewNodeVec;
class RouteVec;
class TouchPointVec;
class LayoutRectVec;
class DbValueVec;
class LoadedFontVec;
class SvgRenderOptions;
class IconStyleOptions;
class TaskBarIcon;
class SmallWindowIconBytes;
class LargeWindowIconBytes;
class VirtualViewCallbackInfo;
class LayoutCallback;
class LayoutCallbackInfo;
class TimerCallback;
class WriteBackCallback;
class ThreadCallback;
class RenderImageCallbackInfo;
class ListViewOnColumnClickCallback;
class CoreCallback;
class ListViewOnRowClickCallback;
class CheckBoxOnToggleCallback;
class DropDownOnChoiceChangeCallback;
class TabOnClickCallback;
class ListViewOnLazyLoadScrollCallback;
class ButtonOnClickCallback;
class XmlAttributeMap;
class Callback;
class KeyboardState;
class TouchState;
class CoreRenderImageCallback;
class VirtualKeyCodeCombo;
class TextInputOnVirtualKeyDownCallback;
class SelectionState;
class TextOpExtendSelection;
class RenderImageCallback;
class TextOpClearSelection;
class DatasetMergeCallback;
class FocusVisuals;
class DragData;
class VirtualViewCallback;
class RibbonOnTabClickCallback;
class TreeViewOnNodeClickCallback;
class OnVideoFrameCallback;
class MapPinTapCallback;
class OnAudioFrameCallback;
class Menu;
class Css;
class StyleBoxShadow;
class LinearGradient;
class StyleBackgroundPosition;
class GridTemplate;
class GridAutoTracks;
class StyledDom;
class VertexLayout;
class ContentGroup;
class SafeAreaInsets;
class GridTemplateAreas;
class StyleObjectPosition;
class FileInputOnPathChangeCallback;
class ColorInputOnValueChangeCallback;
class TextInputOnTextInputCallback;
class TextInputOnFocusLostCallback;
class NumberInputOnValueChangeCallback;
class NumberInputOnFocusLostCallback;
class ProgressBar;
class ListViewState;
class VideoFrame;
class MapViewportChangedCallback;
class AudioFrame;
class GetProgramBinaryReturn;
class LoadedFontSource;
class TessellatedSvgNode;
class CssPath;
class ShapePolygon;
class SvgPath;
class SvgMultiPolygon;
class ParsedSvg;
class String;
class InvalidCharMultipleError;
class FluentZipLoadResult;
class ThreadSender;
class ThreadReceiver;
class DbRows;
class ComponentMap;
class WaylandTheme;
class MimeTypeHint;
class MimeTypeData;
class HttpHeader;
class HttpResponse;
class HttpRequestConfig;
class TimerCallbackInfo;
class CoreCallbackData;
class CoreMenuCallback;
class AttributeNameValue;
class XmlTagName;
class VertexAttribute;
class CoreImageCallback;
class ClipboardContent;
class TextInputOnVirtualKeyDown;
class TextOpSetSelection;
class NodeStateSnapshot;
class ParseIntErrorWithInput;
class ParseFloatErrorWithInput;
class CssRuleBlock;
class RadialGradient;
class ConicGradient;
class CounterReset;
class Content;
class CounterIncrement;
class StyleHyphenationLanguage;
class NamedGridLine;
class ShapePath;
class TextOpReplaceText;
class TextOpDeleteText;
class TextOpSelectAll;
class TextOpInsertText;
class PendingTextEdit;
class NamedFont;
class GridAreaDefinition;
class InvalidValueErrOwned;
class FileTypeList;
class MapTileLayer;
class ButtonOnClick;
class FileInputOnPathChange;
class CheckBoxOnToggle;
class DropDownOnChoiceChange;
class ColorInputOnValueChange;
class TextInputOnTextInput;
class TextInputOnFocusLost;
class NumberInputOnValueChange;
class NumberInputOnFocusLost;
class TabOnClick;
class ListViewRow;
class ListViewOnLazyLoadScroll;
class ListViewOnColumnClick;
class ListViewOnRowClick;
class RibbonTab;
class RibbonOnTabClick;
class TreeViewNode;
class TreeViewOnNodeClick;
class Titlebar;
class OnVideoFrame;
class MapViewportChanged;
class OnAudioFrame;
class GetActiveAttribReturn;
class GetActiveUniformReturn;
class VertexArrayObject;
class DebugMessage;
class RawImage;
class Route;
class RouteMatch;
class LoadedFont;
class FilePath;
class StringPair;
class StringSet;
class DuplicatedNamespaceError;
class UnknownNamespaceError;
class UnexpectedCloseTagError;
class UnknownEntityReferenceError;
class DuplicatedAttributeError;
class InvalidStringError;
class MalformedHierarchyError;
class SelectAllResult;
class DeleteResult;
class IcuError;
class HttpStatusError;
class FileError;
class JsonParseError;
class UrlParseError;
class PixelNoValueGivenError;
class VarOnShorthandPropertyError;
class WrongComponentCountError;
class AngleNoValueGivenError;
class WhiteSpaceInComponentNameError;
class WhiteSpaceInComponentTypeError;
class UnknownPropertyKeyError;
class UselessFunctionArgumentError;
class MissingTypeError;
class MapPinTap;
class ThreadWriteBackMsg;
class Url;
class JsonInternal;
class DirEntry;
class BiometricPrompt;
class VideoConfig;
class ComponentId;
class ComponentLibrary;
class ComponentDataModel;
class ComponentEnumVariant;
class ComponentEnumModel;
class ComponentInstanceDefault;
class ComponentCallbackSignature;
class Monitor;
class DialogAriaInfo;
class AccessibilityInfo;
class DragState;
class SmallAriaInfo;
class ProgressAriaInfo;
class MeterAriaInfo;
class CssAttributeSelector;
class StyledTextRun;
class TextOpCopy;
class TextOpPaste;
class TextOpCut;
class SystemFonts;
class PercentageParseErrorWithInput;
class TitlebarMetrics;
class LinuxCustomization;
class FileInputState;
class TextInputState;
class VertexBuffer;
class SvgParseOptions;
class UnknownSelectorError;
class Timer;
class FmtArg;
class Json;
class ComponentDef;
class ComponentFieldOverride;
class LinuxWindowOptions;
class WindowsWindowOptions;
class NodeData;
class StringMenuItem;
class GridPlacement;
class CssMockEnvironment;
class SystemMetrics;
class Button;
class MapWidget;
class FileInputStateWrapper;
class CheckBoxStateWrapper;
class DropDown;
class ColorInputStateWrapper;
class TextInputStateWrapper;
class NumberInputStateWrapper;
class TabHeader;
class ListView;
class Ribbon;
class TreeView;
class CameraWidget;
class ScreenCaptureWidget;
class VideoWidget;
class MicrophoneWidget;
class TessellatedGPUSvgNode;
class TessellatedColoredGPUSvgNode;
class XmlTextError;
class JsonKeyValue;
class ExternalResource;
class ComponentCallbackArg;
class PlatformSpecificOptions;
class TextChangeset;
class Dom;
class SystemStyle;
class CssStyleBorderRadiusParseErrorOwned;
class FileInput;
class CheckBox;
class ColorInput;
class TextInput;
class ComponentDataField;
class FullWindowState;
class UndoableOperation;
class NumberInput;
class Frame;
class RibbonSection;
class AppConfig;
class WindowCreateOptions;
class VirtualViewReturn;
class DynamicCssProperty;
class CssPropertyWithConditions;
class CssBorderParseErrorOwned;
class CssParseErrorOwned;
class OptionI16;
class OptionU16;
class OptionU32;
class OptionUsize;
class OptionF32;
class OptionF64;
class OptionBool;
class OptionI64;
class OptionI32;
class OptionU64;
class OptionU8;
class OptionTimerId;
class OptionThread;
class OptionImageRef;
class OptionLayoutSize;
class OptionColorU;
class OptionTabIndex;
class OptionLogicalPosition;
class OptionScreenPosition;
class OptionCursorNodePosition;
class OptionDragDelta;
class OptionMouseCursorType;
class OptionHwndHandle;
class OptionLinuxDecorationsState;
class OptionLogicalSize;
class OptionVirtualKeyCode;
class OptionX11Visual;
class OptionWindowTheme;
class OptionAccessibilityRole;
class OptionPenTilt;
class OptionGestureDirection;
class OptionThreadId;
class OptionDomId;
class OptionAccessibilityState;
class OptionSvgVertex;
class OptionCascadeInfo;
class OptionNodeHierarchyItem;
class OptionXWindowType;
class OptionStyleBackgroundRepeat;
class OptionShapePoint;
class OptionU8VecRef;
class OptionNodeHierarchyItemId;
class OptionLinuxDesktopEnv;
class OptionOsCondition;
class OptionSvgDashPattern;
class OptionSvgPoint;
class OptionLocationFix;
class OptionBiometricResult;
class OptionWacomPadState;
class OptionScrollState;
class OptionPixelValue;
class OptionTextInputSelection;
class OptionMenuItemIcon;
class OptionFontRef;
class OptionRefAny;
class OptionLayoutRect;
class OptionDomNodeId;
class OptionDuration;
class OptionLogicalRect;
class OptionRendererOptions;
class OptionGlContextPtr;
class OptionTextCursor;
class OptionWindowFlags;
class OptionDetectedPinch;
class OptionDetectedRotation;
class OptionDetectedLongPress;
class OptionPenState;
class OptionStyledNode;
class OptionParentWithNodeDepth;
class OptionVideoMode;
class OptionOsVersion;
class OptionTouchPoint;
class OptionSensorReading;
class OptionGamepadState;
class OptionPixelValueNoPercent;
class OptionSelectionRange;
class OptionMouseState;
class OptionThreadSendMsg;
class OptionTagIdToNodeIdMapping;
class OptionNormalizedRadialColorStop;
class OptionNormalizedLinearColorStop;
class OptionGridTrackSizing;
class OptionStringVec;
class OptionJsonVec;
class OptionJsonKeyValueVec;
class OptionCalcAstItem;
class OptionSvgPathElement;
class OptionU8Vec;
class ResultU8VecEncodeImageError;
class OptionMenu;
class OptionVirtualKeyCodeCombo;
class OptionString;
class OptionCallback;
class OptionTaskBarIcon;
class OptionInstant;
class OptionKeyboardState;
class OptionSelectionState;
class OptionDatasetMergeCallback;
class OptionStyleTransform;
class OptionStyleBackgroundPosition;
class OptionCss;
class OptionStyleBackgroundSize;
class OptionSelection;
class OptionContentGroup;
class OptionSvgPath;
class OptionVideoFrame;
class ResultRefAnyString;
class ResultU8VecString;
class ResultVoidString;
class ResultStringString;
class OptionListViewOnRowClick;
class OptionListViewOnColumnClick;
class OptionListViewOnLazyLoadScroll;
class OptionColorInputOnValueChange;
class OptionButtonOnClick;
class OptionTabOnClick;
class OptionFileInputOnPathChange;
class OptionCheckBoxOnToggle;
class OptionDropDownOnChoiceChange;
class OptionTextInputOnTextInput;
class OptionTextInputOnVirtualKeyDown;
class OptionTextInputOnFocusLost;
class OptionNumberInputOnFocusLost;
class OptionNumberInputOnValueChange;
class OptionRawImage;
class OptionCoreMenuCallback;
class OptionWaylandTheme;
class OptionWindowIcon;
class OptionCoreImageCallback;
class OptionSelectAllResult;
class OptionDeleteResult;
class OptionClipboardContent;
class OptionFilePath;
class OptionPendingTextEdit;
class OptionMimeTypeHint;
class OptionAccessibilityAction;
class OptionDirEntry;
class OptionNamedFont;
class OptionStyleFilter;
class OptionHttpHeader;
class OptionCssRuleBlock;
class OptionCoreCallbackData;
class OptionVertexAttribute;
class OptionDebugMessage;
class OptionListViewRow;
class OptionIdOrClass;
class OptionStyleFontFamily;
class OptionStringPair;
class OptionMimeTypeData;
class OptionThemeCondition;
class OptionGridAreaDefinition;
class OptionComponentLibrary;
class OptionComponentDataModel;
class OptionComponentEnumModel;
class OptionComponentEnumVariant;
class OptionRibbonOnTabClick;
class OptionTreeViewOnNodeClick;
class OptionRibbonTab;
class OptionTreeViewNode;
class OptionRoute;
class OptionRouteMatch;
class OptionFileTypeList;
class OptionKeyringResult;
class OptionDbValue;
class OptionOnVideoFrame;
class OptionMapViewportChanged;
class OptionMapPinTap;
class OptionOnAudioFrame;
class OptionLoadedFont;
class ResultRawImageDecodeImageError;
class ResultEmptyStructFileError;
class Resultu64FileError;
class ResultU8VecFileError;
class ResultFileMetadataFileError;
class ResultStringFileError;
class ResultDirEntryVecFileError;
class ResultFilePathFileError;
class ResultUrlUrlParseError;
class OptionTimer;
class OptionDragState;
class OptionJson;
class OptionFmtArg;
class OptionMonitor;
class OptionStyleBackgroundContent;
class OptionStyledTextRun;
class OptionDynamicSelector;
class OptionAttributeType;
class OptionComponentDef;
class OptionComponentDefaultValue;
class OptionComponentFieldOverride;
class ResultHttpResponseHttpError;
class ResultU8VecHttpError;
class ResultJsonJsonParseError;
class OptionExternalResource;
class OptionJsonKeyValue;
class OptionXmlNodeChild;
class OptionCssPathSelector;
class OptionNodeData;
class OptionCssMockEnvironment;
class OptionComponentCallbackArg;
class OptionDom;
class OptionMenuItem;
class OptionComponentDataField;
class OptionCssProperty;
class OptionUndoableOperation;
class OptionRibbonSection;
class OptionCssPropertyWithConditions;
class ResultSvgSvgParseError;
class ResultParsedSvgSvgParseError;
class OptionCssDeclaration;
class ResultStyledDomRenderDomError;
class ResultStringCompileError;

// =============================================================================
// Template-based reflection scaffolding for RefAny::create<T> et al.
// =============================================================================

namespace detail {
    // Per-type runtime tag, derived from the address of a template-instantiated
    // static. The address is unique per T and has program-lifetime storage.
    template<class T>
    struct type_id_holder { static const uint64_t value; };
    template<class T>
    const uint64_t type_id_holder<T>::value = 0;

    template<class T>
    inline void type_destructor(void* ptr) noexcept {
        delete static_cast<T*>(ptr);
    }
} // namespace detail

/// Structural concept: any object type T can be reflected as long as it is
/// destructible and isn't `RefAny` itself (wrapping a RefAny in a RefAny is
/// not what anyone wants). No per-class registration needed.
template<class T>
concept ReflectableModel = std::is_object_v<T> && std::is_destructible_v<T>
    && !std::is_same_v<T, RefAny>;


// Free-function downcast helpers. Operate directly on the C struct
// `AzRefAny` so callback bodies can write
//     auto* d = azul::downcast_ref<MyData>(data);
// without first wrapping the parameter. The C function-pointer
// typedef fixes the parameter to `AzRefAny`, which has no methods of
// its own; these free templates fill the gap.

template<ReflectableModel T>
inline const T* downcast_ref(const AzRefAny& data) noexcept {
    const uint64_t tag = reinterpret_cast<uint64_t>(&detail::type_id_holder<T>::value);
    if (!AzRefAny_isType(&data, tag)) return nullptr;
    return static_cast<const T*>(AzRefAny_getDataPtr(&data));
}

template<ReflectableModel T>
inline T* downcast_mut(AzRefAny& data) noexcept {
    const uint64_t tag = reinterpret_cast<uint64_t>(&detail::type_id_holder<T>::value);
    if (!AzRefAny_isType(&data, tag)) return nullptr;
    return static_cast<T*>(const_cast<void*>(AzRefAny_getDataPtr(&data)));
}
// Wrapper class declarations

class MonitorId {
private:
    AzMonitorId inner_;

public:
    MonitorId(AzMonitorId inner) noexcept : inner_(inner) {}
    MonitorId(const MonitorId& other) noexcept : inner_(other.inner_) {}
    MonitorId& operator=(const MonitorId& other) noexcept { inner_ = other.inner_; return *this; }
    ~MonitorId() {}

    bool partialEq(const MonitorId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const MonitorId& b) const;
    uint8_t cmp(const MonitorId& b) const;
    String toDbgString() const;

    const AzMonitorId& inner() const { return inner_; }
    AzMonitorId& inner() { return inner_; }
    const AzMonitorId* ptr() const { return &inner_; }
    AzMonitorId* ptr() { return &inner_; }
    AzMonitorId release() { AzMonitorId result = inner_; inner_ = {}; return result; }
    operator AzMonitorId() && noexcept { AzMonitorId result = inner_; inner_ = {}; return result; }
};

class WasmWindowOptions {
private:
    AzWasmWindowOptions inner_;

public:
    WasmWindowOptions(AzWasmWindowOptions inner) noexcept : inner_(inner) {}
    WasmWindowOptions(const WasmWindowOptions& other) noexcept : inner_(other.inner_) {}
    WasmWindowOptions& operator=(const WasmWindowOptions& other) noexcept { inner_ = other.inner_; return *this; }
    ~WasmWindowOptions() {}

    [[nodiscard]] static WasmWindowOptions default_();

    bool partialEq(const WasmWindowOptions& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const WasmWindowOptions& b) const;
    uint8_t cmp(const WasmWindowOptions& b) const;
    String toDbgString() const;

    const AzWasmWindowOptions& inner() const { return inner_; }
    AzWasmWindowOptions& inner() { return inner_; }
    const AzWasmWindowOptions* ptr() const { return &inner_; }
    AzWasmWindowOptions* ptr() { return &inner_; }
    AzWasmWindowOptions release() { AzWasmWindowOptions result = inner_; inner_ = {}; return result; }
    operator AzWasmWindowOptions() && noexcept { AzWasmWindowOptions result = inner_; inner_ = {}; return result; }
};

class IconKey {
private:
    AzIconKey inner_;

public:
    IconKey(AzIconKey inner) noexcept : inner_(inner) {}
    IconKey(const IconKey& other) noexcept : inner_(other.inner_) {}
    IconKey& operator=(const IconKey& other) noexcept { inner_ = other.inner_; return *this; }
    ~IconKey() {}

    bool partialEq(const IconKey& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const IconKey& b) const;
    uint8_t cmp(const IconKey& b) const;
    String toDbgString() const;

    const AzIconKey& inner() const { return inner_; }
    AzIconKey& inner() { return inner_; }
    const AzIconKey* ptr() const { return &inner_; }
    AzIconKey* ptr() { return &inner_; }
    AzIconKey release() { AzIconKey result = inner_; inner_ = {}; return result; }
    operator AzIconKey() && noexcept { AzIconKey result = inner_; inner_ = {}; return result; }
};

class MacWindowOptions {
private:
    AzMacWindowOptions inner_;

public:
    MacWindowOptions(AzMacWindowOptions inner) noexcept : inner_(inner) {}
    MacWindowOptions(const MacWindowOptions& other) noexcept : inner_(other.inner_) {}
    MacWindowOptions& operator=(const MacWindowOptions& other) noexcept { inner_ = other.inner_; return *this; }
    ~MacWindowOptions() {}

    [[nodiscard]] static MacWindowOptions default_();

    bool partialEq(const MacWindowOptions& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const MacWindowOptions& b) const;
    uint8_t cmp(const MacWindowOptions& b) const;
    String toDbgString() const;

    const AzMacWindowOptions& inner() const { return inner_; }
    AzMacWindowOptions& inner() { return inner_; }
    const AzMacWindowOptions* ptr() const { return &inner_; }
    AzMacWindowOptions* ptr() { return &inner_; }
    AzMacWindowOptions release() { AzMacWindowOptions result = inner_; inner_ = {}; return result; }
    operator AzMacWindowOptions() && noexcept { AzMacWindowOptions result = inner_; inner_ = {}; return result; }
};

class IOSHandle {
private:
    AzIOSHandle inner_;

public:
    IOSHandle(AzIOSHandle inner) noexcept : inner_(inner) {}
    IOSHandle(const IOSHandle& other) noexcept : inner_(other.inner_) {}
    IOSHandle& operator=(const IOSHandle& other) noexcept { inner_ = other.inner_; return *this; }
    ~IOSHandle() {}

    bool partialEq(const IOSHandle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const IOSHandle& b) const;
    uint8_t cmp(const IOSHandle& b) const;
    String toDbgString() const;

    const AzIOSHandle& inner() const { return inner_; }
    AzIOSHandle& inner() { return inner_; }
    const AzIOSHandle* ptr() const { return &inner_; }
    AzIOSHandle* ptr() { return &inner_; }
    AzIOSHandle release() { AzIOSHandle result = inner_; inner_ = {}; return result; }
    operator AzIOSHandle() && noexcept { AzIOSHandle result = inner_; inner_ = {}; return result; }
};

class MacOSHandle {
private:
    AzMacOSHandle inner_;

public:
    MacOSHandle(AzMacOSHandle inner) noexcept : inner_(inner) {}
    MacOSHandle(const MacOSHandle& other) noexcept : inner_(other.inner_) {}
    MacOSHandle& operator=(const MacOSHandle& other) noexcept { inner_ = other.inner_; return *this; }
    ~MacOSHandle() {}

    bool partialEq(const MacOSHandle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const MacOSHandle& b) const;
    uint8_t cmp(const MacOSHandle& b) const;
    String toDbgString() const;

    const AzMacOSHandle& inner() const { return inner_; }
    AzMacOSHandle& inner() { return inner_; }
    const AzMacOSHandle* ptr() const { return &inner_; }
    AzMacOSHandle* ptr() { return &inner_; }
    AzMacOSHandle release() { AzMacOSHandle result = inner_; inner_ = {}; return result; }
    operator AzMacOSHandle() && noexcept { AzMacOSHandle result = inner_; inner_ = {}; return result; }
};

class XcbHandle {
private:
    AzXcbHandle inner_;

public:
    XcbHandle(AzXcbHandle inner) noexcept : inner_(inner) {}
    XcbHandle(const XcbHandle& other) noexcept : inner_(other.inner_) {}
    XcbHandle& operator=(const XcbHandle& other) noexcept { inner_ = other.inner_; return *this; }
    ~XcbHandle() {}

    bool partialEq(const XcbHandle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const XcbHandle& b) const;
    uint8_t cmp(const XcbHandle& b) const;
    String toDbgString() const;

    const AzXcbHandle& inner() const { return inner_; }
    AzXcbHandle& inner() { return inner_; }
    const AzXcbHandle* ptr() const { return &inner_; }
    AzXcbHandle* ptr() { return &inner_; }
    AzXcbHandle release() { AzXcbHandle result = inner_; inner_ = {}; return result; }
    operator AzXcbHandle() && noexcept { AzXcbHandle result = inner_; inner_ = {}; return result; }
};

class XlibHandle {
private:
    AzXlibHandle inner_;

public:
    XlibHandle(AzXlibHandle inner) noexcept : inner_(inner) {}
    XlibHandle(const XlibHandle& other) noexcept : inner_(other.inner_) {}
    XlibHandle& operator=(const XlibHandle& other) noexcept { inner_ = other.inner_; return *this; }
    ~XlibHandle() {}

    bool partialEq(const XlibHandle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const XlibHandle& b) const;
    uint8_t cmp(const XlibHandle& b) const;
    String toDbgString() const;

    const AzXlibHandle& inner() const { return inner_; }
    AzXlibHandle& inner() { return inner_; }
    const AzXlibHandle* ptr() const { return &inner_; }
    AzXlibHandle* ptr() { return &inner_; }
    AzXlibHandle release() { AzXlibHandle result = inner_; inner_ = {}; return result; }
    operator AzXlibHandle() && noexcept { AzXlibHandle result = inner_; inner_ = {}; return result; }
};

class WaylandHandle {
private:
    AzWaylandHandle inner_;

public:
    WaylandHandle(AzWaylandHandle inner) noexcept : inner_(inner) {}
    WaylandHandle(const WaylandHandle& other) noexcept : inner_(other.inner_) {}
    WaylandHandle& operator=(const WaylandHandle& other) noexcept { inner_ = other.inner_; return *this; }
    ~WaylandHandle() {}

    bool partialEq(const WaylandHandle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const WaylandHandle& b) const;
    uint8_t cmp(const WaylandHandle& b) const;
    String toDbgString() const;

    const AzWaylandHandle& inner() const { return inner_; }
    AzWaylandHandle& inner() { return inner_; }
    const AzWaylandHandle* ptr() const { return &inner_; }
    AzWaylandHandle* ptr() { return &inner_; }
    AzWaylandHandle release() { AzWaylandHandle result = inner_; inner_ = {}; return result; }
    operator AzWaylandHandle() && noexcept { AzWaylandHandle result = inner_; inner_ = {}; return result; }
};

class WindowsHandle {
private:
    AzWindowsHandle inner_;

public:
    WindowsHandle(AzWindowsHandle inner) noexcept : inner_(inner) {}
    WindowsHandle(const WindowsHandle& other) noexcept : inner_(other.inner_) {}
    WindowsHandle& operator=(const WindowsHandle& other) noexcept { inner_ = other.inner_; return *this; }
    ~WindowsHandle() {}

    bool partialEq(const WindowsHandle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const WindowsHandle& b) const;
    uint8_t cmp(const WindowsHandle& b) const;
    String toDbgString() const;

    const AzWindowsHandle& inner() const { return inner_; }
    AzWindowsHandle& inner() { return inner_; }
    const AzWindowsHandle* ptr() const { return &inner_; }
    AzWindowsHandle* ptr() { return &inner_; }
    AzWindowsHandle release() { AzWindowsHandle result = inner_; inner_ = {}; return result; }
    operator AzWindowsHandle() && noexcept { AzWindowsHandle result = inner_; inner_ = {}; return result; }
};

class WebHandle {
private:
    AzWebHandle inner_;

public:
    WebHandle(AzWebHandle inner) noexcept : inner_(inner) {}
    WebHandle(const WebHandle& other) noexcept : inner_(other.inner_) {}
    WebHandle& operator=(const WebHandle& other) noexcept { inner_ = other.inner_; return *this; }
    ~WebHandle() {}

    bool partialEq(const WebHandle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const WebHandle& b) const;
    uint8_t cmp(const WebHandle& b) const;
    String toDbgString() const;

    const AzWebHandle& inner() const { return inner_; }
    AzWebHandle& inner() { return inner_; }
    const AzWebHandle* ptr() const { return &inner_; }
    AzWebHandle* ptr() { return &inner_; }
    AzWebHandle release() { AzWebHandle result = inner_; inner_ = {}; return result; }
    operator AzWebHandle() && noexcept { AzWebHandle result = inner_; inner_ = {}; return result; }
};

class AndroidHandle {
private:
    AzAndroidHandle inner_;

public:
    AndroidHandle(AzAndroidHandle inner) noexcept : inner_(inner) {}
    AndroidHandle(const AndroidHandle& other) noexcept : inner_(other.inner_) {}
    AndroidHandle& operator=(const AndroidHandle& other) noexcept { inner_ = other.inner_; return *this; }
    ~AndroidHandle() {}

    bool partialEq(const AndroidHandle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const AndroidHandle& b) const;
    uint8_t cmp(const AndroidHandle& b) const;
    String toDbgString() const;

    const AzAndroidHandle& inner() const { return inner_; }
    AzAndroidHandle& inner() { return inner_; }
    const AzAndroidHandle* ptr() const { return &inner_; }
    AzAndroidHandle* ptr() { return &inner_; }
    AzAndroidHandle release() { AzAndroidHandle result = inner_; inner_ = {}; return result; }
    operator AzAndroidHandle() && noexcept { AzAndroidHandle result = inner_; inner_ = {}; return result; }
};

class IconProviderHandle {
private:
    AzIconProviderHandle inner_;

    IconProviderHandle(const IconProviderHandle&) = delete;
    IconProviderHandle& operator=(const IconProviderHandle&) = delete;

public:
    explicit IconProviderHandle(AzIconProviderHandle inner) noexcept : inner_(inner) {}

    IconProviderHandle(IconProviderHandle&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    IconProviderHandle& operator=(IconProviderHandle&& other) noexcept {
        if (this != &other) {
            AzIconProviderHandle_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~IconProviderHandle() { AzIconProviderHandle_delete(&inner_); }

    [[nodiscard]] static IconProviderHandle create();
    [[nodiscard]] static IconProviderHandle with_resolver(AzIconResolverCallbackType resolver);
    [[nodiscard]] static IconProviderHandle default_();

    void set_resolver(AzIconResolverCallbackType resolver);
    void register_icon(String pack_name, String icon_name, RefAny data);
    void unregister_icon(String pack_name, String icon_name);
    void unregister_pack(String pack_name);
    OptionRefAny lookup(String icon_name) const;
    bool has_icon(String icon_name) const;
    void register_image_icon(String pack_name, String icon_name, ImageRef image);
    void register_font_icon(String pack_name, String icon_name, FontRef font, String icon_char);
    String debug_lookup(String icon_name) const;
    void delete_();
    IconProviderHandle clone() const;
    String toDbgString() const;

    const AzIconProviderHandle& inner() const { return inner_; }
    AzIconProviderHandle& inner() { return inner_; }
    const AzIconProviderHandle* ptr() const { return &inner_; }
    AzIconProviderHandle* ptr() { return &inner_; }
    AzIconProviderHandle release() { AzIconProviderHandle result = inner_; inner_ = {}; return result; }
    operator AzIconProviderHandle() && noexcept { AzIconProviderHandle result = inner_; inner_ = {}; return result; }
};

class VideoModeVecSlice {
private:
    AzVideoModeVecSlice inner_;

public:
    VideoModeVecSlice(AzVideoModeVecSlice inner) noexcept : inner_(inner) {}
    VideoModeVecSlice(const VideoModeVecSlice& other) noexcept : inner_(other.inner_) {}
    VideoModeVecSlice& operator=(const VideoModeVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~VideoModeVecSlice() {}

    String toDbgString() const;

    const AzVideoModeVecSlice& inner() const { return inner_; }
    AzVideoModeVecSlice& inner() { return inner_; }
    const AzVideoModeVecSlice* ptr() const { return &inner_; }
    AzVideoModeVecSlice* ptr() { return &inner_; }
    AzVideoModeVecSlice release() { AzVideoModeVecSlice result = inner_; inner_ = {}; return result; }
    operator AzVideoModeVecSlice() && noexcept { AzVideoModeVecSlice result = inner_; inner_ = {}; return result; }
};

class MonitorVecSlice {
private:
    AzMonitorVecSlice inner_;

public:
    MonitorVecSlice(AzMonitorVecSlice inner) noexcept : inner_(inner) {}
    MonitorVecSlice(const MonitorVecSlice& other) noexcept : inner_(other.inner_) {}
    MonitorVecSlice& operator=(const MonitorVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~MonitorVecSlice() {}

    String toDbgString() const;

    const AzMonitorVecSlice& inner() const { return inner_; }
    AzMonitorVecSlice& inner() { return inner_; }
    const AzMonitorVecSlice* ptr() const { return &inner_; }
    AzMonitorVecSlice* ptr() { return &inner_; }
    AzMonitorVecSlice release() { AzMonitorVecSlice result = inner_; inner_ = {}; return result; }
    operator AzMonitorVecSlice() && noexcept { AzMonitorVecSlice result = inner_; inner_ = {}; return result; }
};

class MimeTypeDataVecSlice {
private:
    AzMimeTypeDataVecSlice inner_;

public:
    MimeTypeDataVecSlice(AzMimeTypeDataVecSlice inner) noexcept : inner_(inner) {}
    MimeTypeDataVecSlice(const MimeTypeDataVecSlice& other) noexcept : inner_(other.inner_) {}
    MimeTypeDataVecSlice& operator=(const MimeTypeDataVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~MimeTypeDataVecSlice() {}

    String toDbgString() const;

    const AzMimeTypeDataVecSlice& inner() const { return inner_; }
    AzMimeTypeDataVecSlice& inner() { return inner_; }
    const AzMimeTypeDataVecSlice* ptr() const { return &inner_; }
    AzMimeTypeDataVecSlice* ptr() { return &inner_; }
    AzMimeTypeDataVecSlice release() { AzMimeTypeDataVecSlice result = inner_; inner_ = {}; return result; }
    operator AzMimeTypeDataVecSlice() && noexcept { AzMimeTypeDataVecSlice result = inner_; inner_ = {}; return result; }
};

class TouchPointVecSlice {
private:
    AzTouchPointVecSlice inner_;

public:
    TouchPointVecSlice(AzTouchPointVecSlice inner) noexcept : inner_(inner) {}
    TouchPointVecSlice(const TouchPointVecSlice& other) noexcept : inner_(other.inner_) {}
    TouchPointVecSlice& operator=(const TouchPointVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~TouchPointVecSlice() {}

    String toDbgString() const;

    const AzTouchPointVecSlice& inner() const { return inner_; }
    AzTouchPointVecSlice& inner() { return inner_; }
    const AzTouchPointVecSlice* ptr() const { return &inner_; }
    AzTouchPointVecSlice* ptr() { return &inner_; }
    AzTouchPointVecSlice release() { AzTouchPointVecSlice result = inner_; inner_ = {}; return result; }
    operator AzTouchPointVecSlice() && noexcept { AzTouchPointVecSlice result = inner_; inner_ = {}; return result; }
};

class AudioSink {
private:
    AzAudioSink inner_;

    AudioSink(const AudioSink&) = delete;
    AudioSink& operator=(const AudioSink&) = delete;

public:
    explicit AudioSink(AzAudioSink inner) noexcept : inner_(inner) {}

    AudioSink(AudioSink&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    AudioSink& operator=(AudioSink&& other) noexcept {
        if (this != &other) {
            AzAudioSink_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~AudioSink() { AzAudioSink_delete(&inner_); }

    [[nodiscard]] static AudioSink open(AudioConfig config);
    [[nodiscard]] static AudioSink default_();

    bool is_open() const;
    void play(AudioFrame frame) const;
    uint64_t frames_played() const;
    void close();
    void delete_();
    AudioSink clone() const;

    const AzAudioSink& inner() const { return inner_; }
    AzAudioSink& inner() { return inner_; }
    const AzAudioSink* ptr() const { return &inner_; }
    AzAudioSink* ptr() { return &inner_; }
    AzAudioSink release() { AzAudioSink result = inner_; inner_ = {}; return result; }
    operator AzAudioSink() && noexcept { AzAudioSink result = inner_; inner_ = {}; return result; }
};

class HttpHeaderVecSlice {
private:
    AzHttpHeaderVecSlice inner_;

public:
    HttpHeaderVecSlice(AzHttpHeaderVecSlice inner) noexcept : inner_(inner) {}
    HttpHeaderVecSlice(const HttpHeaderVecSlice& other) noexcept : inner_(other.inner_) {}
    HttpHeaderVecSlice& operator=(const HttpHeaderVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~HttpHeaderVecSlice() {}

    String toDbgString() const;

    const AzHttpHeaderVecSlice& inner() const { return inner_; }
    AzHttpHeaderVecSlice& inner() { return inner_; }
    const AzHttpHeaderVecSlice* ptr() const { return &inner_; }
    AzHttpHeaderVecSlice* ptr() { return &inner_; }
    AzHttpHeaderVecSlice release() { AzHttpHeaderVecSlice result = inner_; inner_ = {}; return result; }
    operator AzHttpHeaderVecSlice() && noexcept { AzHttpHeaderVecSlice result = inner_; inner_ = {}; return result; }
};

class MsgBox {
private:
    AzMsgBox inner_;

public:
    MsgBox(AzMsgBox inner) noexcept : inner_(inner) {}
    MsgBox(const MsgBox& other) noexcept : inner_(other.inner_) {}
    MsgBox& operator=(const MsgBox& other) noexcept { inner_ = other.inner_; return *this; }
    ~MsgBox() {}

    [[nodiscard]] static MsgBox new_();

    static void ok(String title, String message, AzMsgBoxIcon icon);
    static AzOkCancel ok_cancel(String title, String message, AzMsgBoxIcon icon, AzOkCancel default_);
    static AzYesNo yes_no(String title, String message, AzMsgBoxIcon icon, AzYesNo default_);
    static void info(String content);
    bool partialEq(const MsgBox& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzMsgBox& inner() const { return inner_; }
    AzMsgBox& inner() { return inner_; }
    const AzMsgBox* ptr() const { return &inner_; }
    AzMsgBox* ptr() { return &inner_; }
    AzMsgBox release() { AzMsgBox result = inner_; inner_ = {}; return result; }
    operator AzMsgBox() && noexcept { AzMsgBox result = inner_; inner_ = {}; return result; }
};

class FileDialog {
private:
    AzFileDialog inner_;

public:
    FileDialog(AzFileDialog inner) noexcept : inner_(inner) {}
    FileDialog(const FileDialog& other) noexcept : inner_(other.inner_) {}
    FileDialog& operator=(const FileDialog& other) noexcept { inner_ = other.inner_; return *this; }
    ~FileDialog() {}

    [[nodiscard]] static FileDialog new_();

    static OptionString open_file(String title, OptionString default_path, OptionFileTypeList filter_list);
    static OptionString open_directory(String title, OptionString default_path);
    static OptionStringVec open_multiple_files(String title, OptionString default_path, OptionFileTypeList filter_list);
    static OptionString save_file(String title, OptionString default_path);
    bool partialEq(const FileDialog& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzFileDialog& inner() const { return inner_; }
    AzFileDialog& inner() { return inner_; }
    const AzFileDialog* ptr() const { return &inner_; }
    AzFileDialog* ptr() { return &inner_; }
    AzFileDialog release() { AzFileDialog result = inner_; inner_ = {}; return result; }
    operator AzFileDialog() && noexcept { AzFileDialog result = inner_; inner_ = {}; return result; }
};

class ColorPickerDialog {
private:
    AzColorPickerDialog inner_;

public:
    ColorPickerDialog(AzColorPickerDialog inner) noexcept : inner_(inner) {}
    ColorPickerDialog(const ColorPickerDialog& other) noexcept : inner_(other.inner_) {}
    ColorPickerDialog& operator=(const ColorPickerDialog& other) noexcept { inner_ = other.inner_; return *this; }
    ~ColorPickerDialog() {}

    [[nodiscard]] static ColorPickerDialog new_();

    static OptionColorU open(String title, OptionColorU default_value);
    bool partialEq(const ColorPickerDialog& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzColorPickerDialog& inner() const { return inner_; }
    AzColorPickerDialog& inner() { return inner_; }
    const AzColorPickerDialog* ptr() const { return &inner_; }
    AzColorPickerDialog* ptr() { return &inner_; }
    AzColorPickerDialog release() { AzColorPickerDialog result = inner_; inner_ = {}; return result; }
    operator AzColorPickerDialog() && noexcept { AzColorPickerDialog result = inner_; inner_ = {}; return result; }
};

class RefCount {
private:
    AzRefCount inner_;

    RefCount(const RefCount&) = delete;
    RefCount& operator=(const RefCount&) = delete;

public:
    explicit RefCount(AzRefCount inner) noexcept : inner_(inner) {}

    RefCount(RefCount&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RefCount& operator=(RefCount&& other) noexcept {
        if (this != &other) {
            AzRefCount_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RefCount() { AzRefCount_delete(&inner_); }

    bool can_be_shared() const;
    bool can_be_shared_mut() const;
    void increase_ref() const;
    void decrease_ref() const;
    void increase_refmut() const;
    void decrease_refmut() const;
    void delete_();
    RefCount clone() const;
    bool partialEq(const RefCount& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const RefCount& b) const;
    uint8_t cmp(const RefCount& b) const;
    String toDbgString() const;

    const AzRefCount& inner() const { return inner_; }
    AzRefCount& inner() { return inner_; }
    const AzRefCount* ptr() const { return &inner_; }
    AzRefCount* ptr() { return &inner_; }
    AzRefCount release() { AzRefCount result = inner_; inner_ = {}; return result; }
    operator AzRefCount() && noexcept { AzRefCount result = inner_; inner_ = {}; return result; }
};

class GraphemeClusterId {
private:
    AzGraphemeClusterId inner_;

public:
    GraphemeClusterId(AzGraphemeClusterId inner) noexcept : inner_(inner) {}
    GraphemeClusterId(const GraphemeClusterId& other) noexcept : inner_(other.inner_) {}
    GraphemeClusterId& operator=(const GraphemeClusterId& other) noexcept { inner_ = other.inner_; return *this; }
    ~GraphemeClusterId() {}

    bool partialEq(const GraphemeClusterId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GraphemeClusterId& b) const;
    uint8_t cmp(const GraphemeClusterId& b) const;
    String toDbgString() const;

    const AzGraphemeClusterId& inner() const { return inner_; }
    AzGraphemeClusterId& inner() { return inner_; }
    const AzGraphemeClusterId* ptr() const { return &inner_; }
    AzGraphemeClusterId* ptr() { return &inner_; }
    AzGraphemeClusterId release() { AzGraphemeClusterId result = inner_; inner_ = {}; return result; }
    operator AzGraphemeClusterId() && noexcept { AzGraphemeClusterId result = inner_; inner_ = {}; return result; }
};

class PenTilt {
private:
    AzPenTilt inner_;

public:
    PenTilt(AzPenTilt inner) noexcept : inner_(inner) {}
    PenTilt(const PenTilt& other) noexcept : inner_(other.inner_) {}
    PenTilt& operator=(const PenTilt& other) noexcept { inner_ = other.inner_; return *this; }
    ~PenTilt() {}

    bool partialEq(const PenTilt& b) const;
    uint8_t partialCmp(const PenTilt& b) const;
    String toDbgString() const;

    const AzPenTilt& inner() const { return inner_; }
    AzPenTilt& inner() { return inner_; }
    const AzPenTilt* ptr() const { return &inner_; }
    AzPenTilt* ptr() { return &inner_; }
    AzPenTilt release() { AzPenTilt result = inner_; inner_ = {}; return result; }
    operator AzPenTilt() && noexcept { AzPenTilt result = inner_; inner_ = {}; return result; }
};

class NodeFlags {
private:
    AzNodeFlags inner_;

public:
    NodeFlags(AzNodeFlags inner) noexcept : inner_(inner) {}
    NodeFlags(const NodeFlags& other) noexcept : inner_(other.inner_) {}
    NodeFlags& operator=(const NodeFlags& other) noexcept { inner_ = other.inner_; return *this; }
    ~NodeFlags() {}

    [[nodiscard]] static NodeFlags default_();

    bool partialEq(const NodeFlags& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NodeFlags& b) const;
    uint8_t cmp(const NodeFlags& b) const;
    String toDbgString() const;

    const AzNodeFlags& inner() const { return inner_; }
    AzNodeFlags& inner() { return inner_; }
    const AzNodeFlags* ptr() const { return &inner_; }
    AzNodeFlags* ptr() { return &inner_; }
    AzNodeFlags release() { AzNodeFlags result = inner_; inner_ = {}; return result; }
    operator AzNodeFlags() && noexcept { AzNodeFlags result = inner_; inner_ = {}; return result; }
};

class DomId {
private:
    AzDomId inner_;

public:
    DomId(AzDomId inner) noexcept : inner_(inner) {}
    DomId(const DomId& other) noexcept : inner_(other.inner_) {}
    DomId& operator=(const DomId& other) noexcept { inner_ = other.inner_; return *this; }
    ~DomId() {}

    [[nodiscard]] static DomId default_();

    bool partialEq(const DomId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const DomId& b) const;
    uint8_t cmp(const DomId& b) const;
    String toDbgString() const;

    const AzDomId& inner() const { return inner_; }
    AzDomId& inner() { return inner_; }
    const AzDomId* ptr() const { return &inner_; }
    AzDomId* ptr() { return &inner_; }
    AzDomId release() { AzDomId result = inner_; inner_ = {}; return result; }
    operator AzDomId() && noexcept { AzDomId result = inner_; inner_ = {}; return result; }
};

class NodeHierarchyItemId {
private:
    AzNodeHierarchyItemId inner_;

public:
    NodeHierarchyItemId(AzNodeHierarchyItemId inner) noexcept : inner_(inner) {}
    NodeHierarchyItemId(const NodeHierarchyItemId& other) noexcept : inner_(other.inner_) {}
    NodeHierarchyItemId& operator=(const NodeHierarchyItemId& other) noexcept { inner_ = other.inner_; return *this; }
    ~NodeHierarchyItemId() {}

    [[nodiscard]] static NodeHierarchyItemId from_raw(size_t value);

    size_t into_raw() const;
    bool partialEq(const NodeHierarchyItemId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NodeHierarchyItemId& b) const;
    uint8_t cmp(const NodeHierarchyItemId& b) const;
    String toDbgString() const;

    const AzNodeHierarchyItemId& inner() const { return inner_; }
    AzNodeHierarchyItemId& inner() { return inner_; }
    const AzNodeHierarchyItemId* ptr() const { return &inner_; }
    AzNodeHierarchyItemId* ptr() { return &inner_; }
    AzNodeHierarchyItemId release() { AzNodeHierarchyItemId result = inner_; inner_ = {}; return result; }
    operator AzNodeHierarchyItemId() && noexcept { AzNodeHierarchyItemId result = inner_; inner_ = {}; return result; }
};

class NodeHierarchyItem {
private:
    AzNodeHierarchyItem inner_;

public:
    NodeHierarchyItem(AzNodeHierarchyItem inner) noexcept : inner_(inner) {}
    NodeHierarchyItem(const NodeHierarchyItem& other) noexcept : inner_(other.inner_) {}
    NodeHierarchyItem& operator=(const NodeHierarchyItem& other) noexcept { inner_ = other.inner_; return *this; }
    ~NodeHierarchyItem() {}

    bool partialEq(const NodeHierarchyItem& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NodeHierarchyItem& b) const;
    uint8_t cmp(const NodeHierarchyItem& b) const;
    String toDbgString() const;

    const AzNodeHierarchyItem& inner() const { return inner_; }
    AzNodeHierarchyItem& inner() { return inner_; }
    const AzNodeHierarchyItem* ptr() const { return &inner_; }
    AzNodeHierarchyItem* ptr() { return &inner_; }
    AzNodeHierarchyItem release() { AzNodeHierarchyItem result = inner_; inner_ = {}; return result; }
    operator AzNodeHierarchyItem() && noexcept { AzNodeHierarchyItem result = inner_; inner_ = {}; return result; }
};

class TagId {
private:
    AzTagId inner_;

public:
    TagId(AzTagId inner) noexcept : inner_(inner) {}
    TagId(const TagId& other) noexcept : inner_(other.inner_) {}
    TagId& operator=(const TagId& other) noexcept { inner_ = other.inner_; return *this; }
    ~TagId() {}

    bool partialEq(const TagId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TagId& b) const;
    uint8_t cmp(const TagId& b) const;
    String toDbgString() const;

    const AzTagId& inner() const { return inner_; }
    AzTagId& inner() { return inner_; }
    const AzTagId* ptr() const { return &inner_; }
    AzTagId* ptr() { return &inner_; }
    AzTagId release() { AzTagId result = inner_; inner_ = {}; return result; }
    operator AzTagId() && noexcept { AzTagId result = inner_; inner_ = {}; return result; }
};

class DebugState {
private:
    AzDebugState inner_;

public:
    DebugState(AzDebugState inner) noexcept : inner_(inner) {}
    DebugState(const DebugState& other) noexcept : inner_(other.inner_) {}
    DebugState& operator=(const DebugState& other) noexcept { inner_ = other.inner_; return *this; }
    ~DebugState() {}

    [[nodiscard]] static DebugState default_();

    bool partialEq(const DebugState& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const DebugState& b) const;
    uint8_t cmp(const DebugState& b) const;
    String toDbgString() const;

    const AzDebugState& inner() const { return inner_; }
    AzDebugState& inner() { return inner_; }
    const AzDebugState* ptr() const { return &inner_; }
    AzDebugState* ptr() { return &inner_; }
    AzDebugState release() { AzDebugState result = inner_; inner_ = {}; return result; }
    operator AzDebugState() && noexcept { AzDebugState result = inner_; inner_ = {}; return result; }
};

class GeolocationProbeConfig {
private:
    AzGeolocationProbeConfig inner_;

public:
    GeolocationProbeConfig(AzGeolocationProbeConfig inner) noexcept : inner_(inner) {}
    GeolocationProbeConfig(const GeolocationProbeConfig& other) noexcept : inner_(other.inner_) {}
    GeolocationProbeConfig& operator=(const GeolocationProbeConfig& other) noexcept { inner_ = other.inner_; return *this; }
    ~GeolocationProbeConfig() {}

    [[nodiscard]] static GeolocationProbeConfig default_();

    bool partialEq(const GeolocationProbeConfig& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GeolocationProbeConfig& b) const;
    uint8_t cmp(const GeolocationProbeConfig& b) const;
    String toDbgString() const;

    const AzGeolocationProbeConfig& inner() const { return inner_; }
    AzGeolocationProbeConfig& inner() { return inner_; }
    const AzGeolocationProbeConfig* ptr() const { return &inner_; }
    AzGeolocationProbeConfig* ptr() { return &inner_; }
    AzGeolocationProbeConfig release() { AzGeolocationProbeConfig result = inner_; inner_ = {}; return result; }
    operator AzGeolocationProbeConfig() && noexcept { AzGeolocationProbeConfig result = inner_; inner_ = {}; return result; }
};

class LocationFix {
private:
    AzLocationFix inner_;

public:
    LocationFix(AzLocationFix inner) noexcept : inner_(inner) {}
    LocationFix(const LocationFix& other) noexcept : inner_(other.inner_) {}
    LocationFix& operator=(const LocationFix& other) noexcept { inner_ = other.inner_; return *this; }
    ~LocationFix() {}

    bool partialEq(const LocationFix& b) const;
    String toDbgString() const;

    const AzLocationFix& inner() const { return inner_; }
    AzLocationFix& inner() { return inner_; }
    const AzLocationFix* ptr() const { return &inner_; }
    AzLocationFix* ptr() { return &inner_; }
    AzLocationFix release() { AzLocationFix result = inner_; inner_ = {}; return result; }
    operator AzLocationFix() && noexcept { AzLocationFix result = inner_; inner_ = {}; return result; }
};

class NodeId {
private:
    AzNodeId inner_;

public:
    NodeId(AzNodeId inner) noexcept : inner_(inner) {}
    NodeId(const NodeId& other) noexcept : inner_(other.inner_) {}
    NodeId& operator=(const NodeId& other) noexcept { inner_ = other.inner_; return *this; }
    ~NodeId() {}

    [[nodiscard]] static NodeId create(size_t value);

    size_t index() const;
    bool partialEq(const NodeId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NodeId& b) const;
    uint8_t cmp(const NodeId& b) const;
    String toDbgString() const;

    const AzNodeId& inner() const { return inner_; }
    AzNodeId& inner() { return inner_; }
    const AzNodeId* ptr() const { return &inner_; }
    AzNodeId* ptr() { return &inner_; }
    AzNodeId release() { AzNodeId result = inner_; inner_ = {}; return result; }
    operator AzNodeId() && noexcept { AzNodeId result = inner_; inner_ = {}; return result; }
};

class SelectionId {
private:
    AzSelectionId inner_;

public:
    SelectionId(AzSelectionId inner) noexcept : inner_(inner) {}
    SelectionId(const SelectionId& other) noexcept : inner_(other.inner_) {}
    SelectionId& operator=(const SelectionId& other) noexcept { inner_ = other.inner_; return *this; }
    ~SelectionId() {}

    [[nodiscard]] static SelectionId default_();

    bool partialEq(const SelectionId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const SelectionId& b) const;
    uint8_t cmp(const SelectionId& b) const;
    String toDbgString() const;

    const AzSelectionId& inner() const { return inner_; }
    AzSelectionId& inner() { return inner_; }
    const AzSelectionId* ptr() const { return &inner_; }
    AzSelectionId* ptr() { return &inner_; }
    AzSelectionId release() { AzSelectionId result = inner_; inner_ = {}; return result; }
    operator AzSelectionId() && noexcept { AzSelectionId result = inner_; inner_ = {}; return result; }
};

class TextInputSelectionRange {
private:
    AzTextInputSelectionRange inner_;

    TextInputSelectionRange(const TextInputSelectionRange&) = delete;
    TextInputSelectionRange& operator=(const TextInputSelectionRange&) = delete;

public:
    explicit TextInputSelectionRange(AzTextInputSelectionRange inner) noexcept : inner_(inner) {}

    TextInputSelectionRange(TextInputSelectionRange&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextInputSelectionRange& operator=(TextInputSelectionRange&& other) noexcept {
        if (this != &other) {
            AzTextInputSelectionRange_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextInputSelectionRange() { AzTextInputSelectionRange_delete(&inner_); }

    void delete_();
    TextInputSelectionRange clone() const;
    bool partialEq(const TextInputSelectionRange& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzTextInputSelectionRange& inner() const { return inner_; }
    AzTextInputSelectionRange& inner() { return inner_; }
    const AzTextInputSelectionRange* ptr() const { return &inner_; }
    AzTextInputSelectionRange* ptr() { return &inner_; }
    AzTextInputSelectionRange release() { AzTextInputSelectionRange result = inner_; inner_ = {}; return result; }
    operator AzTextInputSelectionRange() && noexcept { AzTextInputSelectionRange result = inner_; inner_ = {}; return result; }
};

class TextSelectionStartEnd {
private:
    AzTextSelectionStartEnd inner_;

    TextSelectionStartEnd(const TextSelectionStartEnd&) = delete;
    TextSelectionStartEnd& operator=(const TextSelectionStartEnd&) = delete;

public:
    explicit TextSelectionStartEnd(AzTextSelectionStartEnd inner) noexcept : inner_(inner) {}

    TextSelectionStartEnd(TextSelectionStartEnd&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextSelectionStartEnd& operator=(TextSelectionStartEnd&& other) noexcept {
        if (this != &other) {
            AzTextSelectionStartEnd_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextSelectionStartEnd() { AzTextSelectionStartEnd_delete(&inner_); }

    void delete_();
    TextSelectionStartEnd clone() const;
    bool partialEq(const TextSelectionStartEnd& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TextSelectionStartEnd& b) const;
    uint8_t cmp(const TextSelectionStartEnd& b) const;
    String toDbgString() const;

    const AzTextSelectionStartEnd& inner() const { return inner_; }
    AzTextSelectionStartEnd& inner() { return inner_; }
    const AzTextSelectionStartEnd* ptr() const { return &inner_; }
    AzTextSelectionStartEnd* ptr() { return &inner_; }
    AzTextSelectionStartEnd release() { AzTextSelectionStartEnd result = inner_; inner_ = {}; return result; }
    operator AzTextSelectionStartEnd() && noexcept { AzTextSelectionStartEnd result = inner_; inner_ = {}; return result; }
};

class NodeDataVecSlice {
private:
    AzNodeDataVecSlice inner_;

public:
    NodeDataVecSlice(AzNodeDataVecSlice inner) noexcept : inner_(inner) {}
    NodeDataVecSlice(const NodeDataVecSlice& other) noexcept : inner_(other.inner_) {}
    NodeDataVecSlice& operator=(const NodeDataVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~NodeDataVecSlice() {}

    String toDbgString() const;

    const AzNodeDataVecSlice& inner() const { return inner_; }
    AzNodeDataVecSlice& inner() { return inner_; }
    const AzNodeDataVecSlice* ptr() const { return &inner_; }
    AzNodeDataVecSlice* ptr() { return &inner_; }
    AzNodeDataVecSlice release() { AzNodeDataVecSlice result = inner_; inner_ = {}; return result; }
    operator AzNodeDataVecSlice() && noexcept { AzNodeDataVecSlice result = inner_; inner_ = {}; return result; }
};

class NodeHierarchyItemVecSlice {
private:
    AzNodeHierarchyItemVecSlice inner_;

public:
    NodeHierarchyItemVecSlice(AzNodeHierarchyItemVecSlice inner) noexcept : inner_(inner) {}
    NodeHierarchyItemVecSlice(const NodeHierarchyItemVecSlice& other) noexcept : inner_(other.inner_) {}
    NodeHierarchyItemVecSlice& operator=(const NodeHierarchyItemVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~NodeHierarchyItemVecSlice() {}

    String toDbgString() const;

    const AzNodeHierarchyItemVecSlice& inner() const { return inner_; }
    AzNodeHierarchyItemVecSlice& inner() { return inner_; }
    const AzNodeHierarchyItemVecSlice* ptr() const { return &inner_; }
    AzNodeHierarchyItemVecSlice* ptr() { return &inner_; }
    AzNodeHierarchyItemVecSlice release() { AzNodeHierarchyItemVecSlice result = inner_; inner_ = {}; return result; }
    operator AzNodeHierarchyItemVecSlice() && noexcept { AzNodeHierarchyItemVecSlice result = inner_; inner_ = {}; return result; }
};

class DomIdVecSlice {
private:
    AzDomIdVecSlice inner_;

public:
    DomIdVecSlice(AzDomIdVecSlice inner) noexcept : inner_(inner) {}
    DomIdVecSlice(const DomIdVecSlice& other) noexcept : inner_(other.inner_) {}
    DomIdVecSlice& operator=(const DomIdVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~DomIdVecSlice() {}

    String toDbgString() const;

    const AzDomIdVecSlice& inner() const { return inner_; }
    AzDomIdVecSlice& inner() { return inner_; }
    const AzDomIdVecSlice* ptr() const { return &inner_; }
    AzDomIdVecSlice* ptr() { return &inner_; }
    AzDomIdVecSlice release() { AzDomIdVecSlice result = inner_; inner_ = {}; return result; }
    operator AzDomIdVecSlice() && noexcept { AzDomIdVecSlice result = inner_; inner_ = {}; return result; }
};

class TagIdToNodeIdMappingVecSlice {
private:
    AzTagIdToNodeIdMappingVecSlice inner_;

public:
    TagIdToNodeIdMappingVecSlice(AzTagIdToNodeIdMappingVecSlice inner) noexcept : inner_(inner) {}
    TagIdToNodeIdMappingVecSlice(const TagIdToNodeIdMappingVecSlice& other) noexcept : inner_(other.inner_) {}
    TagIdToNodeIdMappingVecSlice& operator=(const TagIdToNodeIdMappingVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~TagIdToNodeIdMappingVecSlice() {}

    String toDbgString() const;

    const AzTagIdToNodeIdMappingVecSlice& inner() const { return inner_; }
    AzTagIdToNodeIdMappingVecSlice& inner() { return inner_; }
    const AzTagIdToNodeIdMappingVecSlice* ptr() const { return &inner_; }
    AzTagIdToNodeIdMappingVecSlice* ptr() { return &inner_; }
    AzTagIdToNodeIdMappingVecSlice release() { AzTagIdToNodeIdMappingVecSlice result = inner_; inner_ = {}; return result; }
    operator AzTagIdToNodeIdMappingVecSlice() && noexcept { AzTagIdToNodeIdMappingVecSlice result = inner_; inner_ = {}; return result; }
};

class VertexAttributeVecSlice {
private:
    AzVertexAttributeVecSlice inner_;

public:
    VertexAttributeVecSlice(AzVertexAttributeVecSlice inner) noexcept : inner_(inner) {}
    VertexAttributeVecSlice(const VertexAttributeVecSlice& other) noexcept : inner_(other.inner_) {}
    VertexAttributeVecSlice& operator=(const VertexAttributeVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~VertexAttributeVecSlice() {}

    String toDbgString() const;

    const AzVertexAttributeVecSlice& inner() const { return inner_; }
    AzVertexAttributeVecSlice& inner() { return inner_; }
    const AzVertexAttributeVecSlice* ptr() const { return &inner_; }
    AzVertexAttributeVecSlice* ptr() { return &inner_; }
    AzVertexAttributeVecSlice release() { AzVertexAttributeVecSlice result = inner_; inner_ = {}; return result; }
    operator AzVertexAttributeVecSlice() && noexcept { AzVertexAttributeVecSlice result = inner_; inner_ = {}; return result; }
};

class NodeHierarchyItemIdVecSlice {
private:
    AzNodeHierarchyItemIdVecSlice inner_;

public:
    NodeHierarchyItemIdVecSlice(AzNodeHierarchyItemIdVecSlice inner) noexcept : inner_(inner) {}
    NodeHierarchyItemIdVecSlice(const NodeHierarchyItemIdVecSlice& other) noexcept : inner_(other.inner_) {}
    NodeHierarchyItemIdVecSlice& operator=(const NodeHierarchyItemIdVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~NodeHierarchyItemIdVecSlice() {}

    String toDbgString() const;

    const AzNodeHierarchyItemIdVecSlice& inner() const { return inner_; }
    AzNodeHierarchyItemIdVecSlice& inner() { return inner_; }
    const AzNodeHierarchyItemIdVecSlice* ptr() const { return &inner_; }
    AzNodeHierarchyItemIdVecSlice* ptr() { return &inner_; }
    AzNodeHierarchyItemIdVecSlice release() { AzNodeHierarchyItemIdVecSlice result = inner_; inner_ = {}; return result; }
    operator AzNodeHierarchyItemIdVecSlice() && noexcept { AzNodeHierarchyItemIdVecSlice result = inner_; inner_ = {}; return result; }
};

class IdOrClassVecSlice {
private:
    AzIdOrClassVecSlice inner_;

public:
    IdOrClassVecSlice(AzIdOrClassVecSlice inner) noexcept : inner_(inner) {}
    IdOrClassVecSlice(const IdOrClassVecSlice& other) noexcept : inner_(other.inner_) {}
    IdOrClassVecSlice& operator=(const IdOrClassVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~IdOrClassVecSlice() {}

    String toDbgString() const;

    const AzIdOrClassVecSlice& inner() const { return inner_; }
    AzIdOrClassVecSlice& inner() { return inner_; }
    const AzIdOrClassVecSlice* ptr() const { return &inner_; }
    AzIdOrClassVecSlice* ptr() { return &inner_; }
    AzIdOrClassVecSlice release() { AzIdOrClassVecSlice result = inner_; inner_ = {}; return result; }
    operator AzIdOrClassVecSlice() && noexcept { AzIdOrClassVecSlice result = inner_; inner_ = {}; return result; }
};

class SelectionRangeVecSlice {
private:
    AzSelectionRangeVecSlice inner_;

public:
    SelectionRangeVecSlice(AzSelectionRangeVecSlice inner) noexcept : inner_(inner) {}
    SelectionRangeVecSlice(const SelectionRangeVecSlice& other) noexcept : inner_(other.inner_) {}
    SelectionRangeVecSlice& operator=(const SelectionRangeVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~SelectionRangeVecSlice() {}

    String toDbgString() const;

    const AzSelectionRangeVecSlice& inner() const { return inner_; }
    AzSelectionRangeVecSlice& inner() { return inner_; }
    const AzSelectionRangeVecSlice* ptr() const { return &inner_; }
    AzSelectionRangeVecSlice* ptr() { return &inner_; }
    AzSelectionRangeVecSlice release() { AzSelectionRangeVecSlice result = inner_; inner_ = {}; return result; }
    operator AzSelectionRangeVecSlice() && noexcept { AzSelectionRangeVecSlice result = inner_; inner_ = {}; return result; }
};

class SelectionVecSlice {
private:
    AzSelectionVecSlice inner_;

public:
    SelectionVecSlice(AzSelectionVecSlice inner) noexcept : inner_(inner) {}
    SelectionVecSlice(const SelectionVecSlice& other) noexcept : inner_(other.inner_) {}
    SelectionVecSlice& operator=(const SelectionVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~SelectionVecSlice() {}

    String toDbgString() const;

    const AzSelectionVecSlice& inner() const { return inner_; }
    AzSelectionVecSlice& inner() { return inner_; }
    const AzSelectionVecSlice* ptr() const { return &inner_; }
    AzSelectionVecSlice* ptr() { return &inner_; }
    AzSelectionVecSlice release() { AzSelectionVecSlice result = inner_; inner_ = {}; return result; }
    operator AzSelectionVecSlice() && noexcept { AzSelectionVecSlice result = inner_; inner_ = {}; return result; }
};

class DomVecSlice {
private:
    AzDomVecSlice inner_;

public:
    DomVecSlice(AzDomVecSlice inner) noexcept : inner_(inner) {}
    DomVecSlice(const DomVecSlice& other) noexcept : inner_(other.inner_) {}
    DomVecSlice& operator=(const DomVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~DomVecSlice() {}

    String toDbgString() const;

    const AzDomVecSlice& inner() const { return inner_; }
    AzDomVecSlice& inner() { return inner_; }
    const AzDomVecSlice* ptr() const { return &inner_; }
    AzDomVecSlice* ptr() { return &inner_; }
    AzDomVecSlice release() { AzDomVecSlice result = inner_; inner_ = {}; return result; }
    operator AzDomVecSlice() && noexcept { AzDomVecSlice result = inner_; inner_ = {}; return result; }
};

class AttributeTypeVecSlice {
private:
    AzAttributeTypeVecSlice inner_;

public:
    AttributeTypeVecSlice(AzAttributeTypeVecSlice inner) noexcept : inner_(inner) {}
    AttributeTypeVecSlice(const AttributeTypeVecSlice& other) noexcept : inner_(other.inner_) {}
    AttributeTypeVecSlice& operator=(const AttributeTypeVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~AttributeTypeVecSlice() {}

    String toDbgString() const;

    const AzAttributeTypeVecSlice& inner() const { return inner_; }
    AzAttributeTypeVecSlice& inner() { return inner_; }
    const AzAttributeTypeVecSlice* ptr() const { return &inner_; }
    AzAttributeTypeVecSlice* ptr() { return &inner_; }
    AzAttributeTypeVecSlice release() { AzAttributeTypeVecSlice result = inner_; inner_ = {}; return result; }
    operator AzAttributeTypeVecSlice() && noexcept { AzAttributeTypeVecSlice result = inner_; inner_ = {}; return result; }
};

class AccessibilityActionVecSlice {
private:
    AzAccessibilityActionVecSlice inner_;

public:
    AccessibilityActionVecSlice(AzAccessibilityActionVecSlice inner) noexcept : inner_(inner) {}
    AccessibilityActionVecSlice(const AccessibilityActionVecSlice& other) noexcept : inner_(other.inner_) {}
    AccessibilityActionVecSlice& operator=(const AccessibilityActionVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~AccessibilityActionVecSlice() {}

    String toDbgString() const;

    const AzAccessibilityActionVecSlice& inner() const { return inner_; }
    AzAccessibilityActionVecSlice& inner() { return inner_; }
    const AzAccessibilityActionVecSlice* ptr() const { return &inner_; }
    AzAccessibilityActionVecSlice* ptr() { return &inner_; }
    AzAccessibilityActionVecSlice release() { AzAccessibilityActionVecSlice result = inner_; inner_ = {}; return result; }
    operator AzAccessibilityActionVecSlice() && noexcept { AzAccessibilityActionVecSlice result = inner_; inner_ = {}; return result; }
};

class CoreCallbackDataVecSlice {
private:
    AzCoreCallbackDataVecSlice inner_;

public:
    CoreCallbackDataVecSlice(AzCoreCallbackDataVecSlice inner) noexcept : inner_(inner) {}
    CoreCallbackDataVecSlice(const CoreCallbackDataVecSlice& other) noexcept : inner_(other.inner_) {}
    CoreCallbackDataVecSlice& operator=(const CoreCallbackDataVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~CoreCallbackDataVecSlice() {}

    String toDbgString() const;

    const AzCoreCallbackDataVecSlice& inner() const { return inner_; }
    AzCoreCallbackDataVecSlice& inner() { return inner_; }
    const AzCoreCallbackDataVecSlice* ptr() const { return &inner_; }
    AzCoreCallbackDataVecSlice* ptr() { return &inner_; }
    AzCoreCallbackDataVecSlice release() { AzCoreCallbackDataVecSlice result = inner_; inner_ = {}; return result; }
    operator AzCoreCallbackDataVecSlice() && noexcept { AzCoreCallbackDataVecSlice result = inner_; inner_ = {}; return result; }
};

class ParentWithNodeDepthVecSlice {
private:
    AzParentWithNodeDepthVecSlice inner_;

public:
    ParentWithNodeDepthVecSlice(AzParentWithNodeDepthVecSlice inner) noexcept : inner_(inner) {}
    ParentWithNodeDepthVecSlice(const ParentWithNodeDepthVecSlice& other) noexcept : inner_(other.inner_) {}
    ParentWithNodeDepthVecSlice& operator=(const ParentWithNodeDepthVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ParentWithNodeDepthVecSlice() {}

    String toDbgString() const;

    const AzParentWithNodeDepthVecSlice& inner() const { return inner_; }
    AzParentWithNodeDepthVecSlice& inner() { return inner_; }
    const AzParentWithNodeDepthVecSlice* ptr() const { return &inner_; }
    AzParentWithNodeDepthVecSlice* ptr() { return &inner_; }
    AzParentWithNodeDepthVecSlice release() { AzParentWithNodeDepthVecSlice result = inner_; inner_ = {}; return result; }
    operator AzParentWithNodeDepthVecSlice() && noexcept { AzParentWithNodeDepthVecSlice result = inner_; inner_ = {}; return result; }
};

class XmlNodeChildVecSlice {
private:
    AzXmlNodeChildVecSlice inner_;

public:
    XmlNodeChildVecSlice(AzXmlNodeChildVecSlice inner) noexcept : inner_(inner) {}
    XmlNodeChildVecSlice(const XmlNodeChildVecSlice& other) noexcept : inner_(other.inner_) {}
    XmlNodeChildVecSlice& operator=(const XmlNodeChildVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~XmlNodeChildVecSlice() {}

    String toDbgString() const;

    const AzXmlNodeChildVecSlice& inner() const { return inner_; }
    AzXmlNodeChildVecSlice& inner() { return inner_; }
    const AzXmlNodeChildVecSlice* ptr() const { return &inner_; }
    AzXmlNodeChildVecSlice* ptr() { return &inner_; }
    AzXmlNodeChildVecSlice release() { AzXmlNodeChildVecSlice result = inner_; inner_ = {}; return result; }
    operator AzXmlNodeChildVecSlice() && noexcept { AzXmlNodeChildVecSlice result = inner_; inner_ = {}; return result; }
};

class AccessibilitySettings {
private:
    AzAccessibilitySettings inner_;

    AccessibilitySettings(const AccessibilitySettings&) = delete;
    AccessibilitySettings& operator=(const AccessibilitySettings&) = delete;

public:
    explicit AccessibilitySettings(AzAccessibilitySettings inner) noexcept : inner_(inner) {}

    AccessibilitySettings(AccessibilitySettings&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    AccessibilitySettings& operator=(AccessibilitySettings&& other) noexcept {
        if (this != &other) {
            AzAccessibilitySettings_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~AccessibilitySettings() { AzAccessibilitySettings_delete(&inner_); }

    [[nodiscard]] static AccessibilitySettings default_();

    void delete_();
    AccessibilitySettings clone() const;
    bool partialEq(const AccessibilitySettings& b) const;
    String toDbgString() const;

    const AzAccessibilitySettings& inner() const { return inner_; }
    AzAccessibilitySettings& inner() { return inner_; }
    const AzAccessibilitySettings* ptr() const { return &inner_; }
    AzAccessibilitySettings* ptr() { return &inner_; }
    AzAccessibilitySettings release() { AzAccessibilitySettings result = inner_; inner_ = {}; return result; }
    operator AzAccessibilitySettings() && noexcept { AzAccessibilitySettings result = inner_; inner_ = {}; return result; }
};

class InputMetrics {
private:
    AzInputMetrics inner_;

public:
    InputMetrics(AzInputMetrics inner) noexcept : inner_(inner) {}
    InputMetrics(const InputMetrics& other) noexcept : inner_(other.inner_) {}
    InputMetrics& operator=(const InputMetrics& other) noexcept { inner_ = other.inner_; return *this; }
    ~InputMetrics() {}

    [[nodiscard]] static InputMetrics default_();

    bool partialEq(const InputMetrics& b) const;
    String toDbgString() const;

    const AzInputMetrics& inner() const { return inner_; }
    AzInputMetrics& inner() { return inner_; }
    const AzInputMetrics* ptr() const { return &inner_; }
    AzInputMetrics* ptr() { return &inner_; }
    AzInputMetrics release() { AzInputMetrics result = inner_; inner_ = {}; return result; }
    operator AzInputMetrics() && noexcept { AzInputMetrics result = inner_; inner_ = {}; return result; }
};

class DragDelta {
private:
    AzDragDelta inner_;

public:
    DragDelta(AzDragDelta inner) noexcept : inner_(inner) {}
    DragDelta(const DragDelta& other) noexcept : inner_(other.inner_) {}
    DragDelta& operator=(const DragDelta& other) noexcept { inner_ = other.inner_; return *this; }
    ~DragDelta() {}

    [[nodiscard]] static DragDelta create(float dx, float dy);
    [[nodiscard]] static DragDelta zero();
    [[nodiscard]] static DragDelta default_();

    bool partialEq(const DragDelta& b) const;
    uint8_t partialCmp(const DragDelta& b) const;
    String toDbgString() const;

    const AzDragDelta& inner() const { return inner_; }
    AzDragDelta& inner() { return inner_; }
    const AzDragDelta* ptr() const { return &inner_; }
    AzDragDelta* ptr() { return &inner_; }
    AzDragDelta release() { AzDragDelta result = inner_; inner_ = {}; return result; }
    operator AzDragDelta() && noexcept { AzDragDelta result = inner_; inner_ = {}; return result; }
};

class MenuItemVecSlice {
private:
    AzMenuItemVecSlice inner_;

public:
    MenuItemVecSlice(AzMenuItemVecSlice inner) noexcept : inner_(inner) {}
    MenuItemVecSlice(const MenuItemVecSlice& other) noexcept : inner_(other.inner_) {}
    MenuItemVecSlice& operator=(const MenuItemVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~MenuItemVecSlice() {}

    String toDbgString() const;

    const AzMenuItemVecSlice& inner() const { return inner_; }
    AzMenuItemVecSlice& inner() { return inner_; }
    const AzMenuItemVecSlice* ptr() const { return &inner_; }
    AzMenuItemVecSlice* ptr() { return &inner_; }
    AzMenuItemVecSlice release() { AzMenuItemVecSlice result = inner_; inner_ = {}; return result; }
    operator AzMenuItemVecSlice() && noexcept { AzMenuItemVecSlice result = inner_; inner_ = {}; return result; }
};

class CssNthChildPattern {
private:
    AzCssNthChildPattern inner_;

public:
    CssNthChildPattern(AzCssNthChildPattern inner) noexcept : inner_(inner) {}
    CssNthChildPattern(const CssNthChildPattern& other) noexcept : inner_(other.inner_) {}
    CssNthChildPattern& operator=(const CssNthChildPattern& other) noexcept { inner_ = other.inner_; return *this; }
    ~CssNthChildPattern() {}

    bool partialEq(const CssNthChildPattern& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CssNthChildPattern& b) const;
    uint8_t cmp(const CssNthChildPattern& b) const;
    String toDbgString() const;

    const AzCssNthChildPattern& inner() const { return inner_; }
    AzCssNthChildPattern& inner() { return inner_; }
    const AzCssNthChildPattern* ptr() const { return &inner_; }
    AzCssNthChildPattern* ptr() { return &inner_; }
    AzCssNthChildPattern release() { AzCssNthChildPattern result = inner_; inner_ = {}; return result; }
    operator AzCssNthChildPattern() && noexcept { AzCssNthChildPattern result = inner_; inner_ = {}; return result; }
};

class ColorU {
private:
    AzColorU inner_;

public:
    ColorU(AzColorU inner) noexcept : inner_(inner) {}
    ColorU(const ColorU& other) noexcept : inner_(other.inner_) {}
    ColorU& operator=(const ColorU& other) noexcept { inner_ = other.inner_; return *this; }
    ~ColorU() {}

    [[nodiscard]] static ColorU from_str(String string);
    [[nodiscard]] static ColorU transparent();
    [[nodiscard]] static ColorU white();
    [[nodiscard]] static ColorU black();
    [[nodiscard]] static ColorU create(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
    [[nodiscard]] static ColorU rgb(uint8_t r, uint8_t g, uint8_t b);
    [[nodiscard]] static ColorU red();
    [[nodiscard]] static ColorU green();
    [[nodiscard]] static ColorU blue();
    [[nodiscard]] static ColorU yellow();
    [[nodiscard]] static ColorU cyan();
    [[nodiscard]] static ColorU magenta();
    [[nodiscard]] static ColorU orange();
    [[nodiscard]] static ColorU pink();
    [[nodiscard]] static ColorU purple();
    [[nodiscard]] static ColorU brown();
    [[nodiscard]] static ColorU gray();
    [[nodiscard]] static ColorU light_gray();
    [[nodiscard]] static ColorU dark_gray();
    [[nodiscard]] static ColorU navy();
    [[nodiscard]] static ColorU teal();
    [[nodiscard]] static ColorU olive();
    [[nodiscard]] static ColorU maroon();
    [[nodiscard]] static ColorU lime();
    [[nodiscard]] static ColorU aqua();
    [[nodiscard]] static ColorU silver();
    [[nodiscard]] static ColorU fuchsia();
    [[nodiscard]] static ColorU indigo();
    [[nodiscard]] static ColorU gold();
    [[nodiscard]] static ColorU coral();
    [[nodiscard]] static ColorU salmon();
    [[nodiscard]] static ColorU turquoise();
    [[nodiscard]] static ColorU violet();
    [[nodiscard]] static ColorU crimson();
    [[nodiscard]] static ColorU chocolate();
    [[nodiscard]] static ColorU sky_blue();
    [[nodiscard]] static ColorU forest_green();
    [[nodiscard]] static ColorU sea_green();
    [[nodiscard]] static ColorU slate_gray();
    [[nodiscard]] static ColorU midnight_blue();
    [[nodiscard]] static ColorU dark_red();
    [[nodiscard]] static ColorU dark_green();
    [[nodiscard]] static ColorU dark_blue();
    [[nodiscard]] static ColorU light_blue();
    [[nodiscard]] static ColorU light_green();
    [[nodiscard]] static ColorU light_yellow();
    [[nodiscard]] static ColorU light_pink();
    [[nodiscard]] static ColorU rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
    [[nodiscard]] static ColorU new_(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
    [[nodiscard]] static ColorU new_rgb(uint8_t r, uint8_t g, uint8_t b);
    [[nodiscard]] static ColorU strawberry(size_t shade);
    [[nodiscard]] static ColorU palette_orange(size_t shade);
    [[nodiscard]] static ColorU banana(size_t shade);
    [[nodiscard]] static ColorU palette_lime(size_t shade);
    [[nodiscard]] static ColorU mint(size_t shade);
    [[nodiscard]] static ColorU blueberry(size_t shade);
    [[nodiscard]] static ColorU grape(size_t shade);
    [[nodiscard]] static ColorU bubblegum(size_t shade);
    [[nodiscard]] static ColorU cocoa(size_t shade);
    [[nodiscard]] static ColorU palette_silver(size_t shade);
    [[nodiscard]] static ColorU slate(size_t shade);
    [[nodiscard]] static ColorU dark(size_t shade);
    [[nodiscard]] static ColorU apple_red();
    [[nodiscard]] static ColorU apple_red_dark();
    [[nodiscard]] static ColorU apple_orange();
    [[nodiscard]] static ColorU apple_orange_dark();
    [[nodiscard]] static ColorU apple_yellow();
    [[nodiscard]] static ColorU apple_yellow_dark();
    [[nodiscard]] static ColorU apple_green();
    [[nodiscard]] static ColorU apple_green_dark();
    [[nodiscard]] static ColorU apple_mint();
    [[nodiscard]] static ColorU apple_mint_dark();
    [[nodiscard]] static ColorU apple_teal();
    [[nodiscard]] static ColorU apple_teal_dark();
    [[nodiscard]] static ColorU apple_cyan();
    [[nodiscard]] static ColorU apple_cyan_dark();
    [[nodiscard]] static ColorU apple_blue();
    [[nodiscard]] static ColorU apple_blue_dark();
    [[nodiscard]] static ColorU apple_indigo();
    [[nodiscard]] static ColorU apple_indigo_dark();
    [[nodiscard]] static ColorU apple_purple();
    [[nodiscard]] static ColorU apple_purple_dark();
    [[nodiscard]] static ColorU apple_pink();
    [[nodiscard]] static ColorU apple_pink_dark();
    [[nodiscard]] static ColorU apple_brown();
    [[nodiscard]] static ColorU apple_brown_dark();
    [[nodiscard]] static ColorU apple_gray();
    [[nodiscard]] static ColorU apple_gray_dark();
    [[nodiscard]] static ColorU bootstrap_primary();
    [[nodiscard]] static ColorU bootstrap_primary_hover();
    [[nodiscard]] static ColorU bootstrap_primary_active();
    [[nodiscard]] static ColorU bootstrap_secondary();
    [[nodiscard]] static ColorU bootstrap_secondary_hover();
    [[nodiscard]] static ColorU bootstrap_secondary_active();
    [[nodiscard]] static ColorU bootstrap_success();
    [[nodiscard]] static ColorU bootstrap_success_hover();
    [[nodiscard]] static ColorU bootstrap_success_active();
    [[nodiscard]] static ColorU bootstrap_danger();
    [[nodiscard]] static ColorU bootstrap_danger_hover();
    [[nodiscard]] static ColorU bootstrap_danger_active();
    [[nodiscard]] static ColorU bootstrap_warning();
    [[nodiscard]] static ColorU bootstrap_warning_hover();
    [[nodiscard]] static ColorU bootstrap_warning_active();
    [[nodiscard]] static ColorU bootstrap_info();
    [[nodiscard]] static ColorU bootstrap_info_hover();
    [[nodiscard]] static ColorU bootstrap_info_active();
    [[nodiscard]] static ColorU bootstrap_light();
    [[nodiscard]] static ColorU bootstrap_light_hover();
    [[nodiscard]] static ColorU bootstrap_light_active();
    [[nodiscard]] static ColorU bootstrap_dark();
    [[nodiscard]] static ColorU bootstrap_dark_hover();
    [[nodiscard]] static ColorU bootstrap_dark_active();
    [[nodiscard]] static ColorU bootstrap_link();
    [[nodiscard]] static ColorU bootstrap_link_hover();
    [[nodiscard]] static ColorU default_();

    String to_hash() const;
    bool has_alpha() const;
    ColorU interpolate(ColorU other, float t) const;
    ColorU lighten(float amount) const;
    ColorU darken(float amount) const;
    ColorU mix(ColorU other, float ratio) const;
    ColorU hover_variant() const;
    ColorU active_variant() const;
    float luminance() const;
    float relative_luminance() const;
    ColorU contrast_text() const;
    ColorU best_contrast_text() const;
    float contrast_ratio(ColorU other) const;
    bool meets_wcag_aa(ColorU other) const;
    bool meets_wcag_aa_large(ColorU other) const;
    bool meets_wcag_aaa(ColorU other) const;
    bool meets_wcag_aaa_large(ColorU other) const;
    float apca_contrast(ColorU background) const;
    bool meets_apca_body(ColorU background) const;
    bool meets_apca_large(ColorU background) const;
    bool is_light() const;
    bool is_dark() const;
    ColorU ensure_contrast(ColorU background, float min_ratio) const;
    ColorU with_alpha(uint8_t a) const;
    ColorU with_alpha_f32(float a) const;
    ColorU invert() const;
    ColorU to_grayscale() const;
    bool partialEq(const ColorU& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ColorU& b) const;
    uint8_t cmp(const ColorU& b) const;
    String toDbgString() const;

    const AzColorU& inner() const { return inner_; }
    AzColorU& inner() { return inner_; }
    const AzColorU* ptr() const { return &inner_; }
    AzColorU* ptr() { return &inner_; }
    AzColorU release() { AzColorU result = inner_; inner_ = {}; return result; }
    operator AzColorU() && noexcept { AzColorU result = inner_; inner_ = {}; return result; }
};

class FloatValue {
private:
    AzFloatValue inner_;

public:
    FloatValue(AzFloatValue inner) noexcept : inner_(inner) {}
    FloatValue(const FloatValue& other) noexcept : inner_(other.inner_) {}
    FloatValue& operator=(const FloatValue& other) noexcept { inner_ = other.inner_; return *this; }
    ~FloatValue() {}

    [[nodiscard]] static FloatValue create(float value);
    [[nodiscard]] static FloatValue default_();

    float get() const;
    bool partialEq(const FloatValue& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const FloatValue& b) const;
    uint8_t cmp(const FloatValue& b) const;
    String toDbgString() const;

    const AzFloatValue& inner() const { return inner_; }
    AzFloatValue& inner() { return inner_; }
    const AzFloatValue* ptr() const { return &inner_; }
    AzFloatValue* ptr() { return &inner_; }
    AzFloatValue release() { AzFloatValue result = inner_; inner_ = {}; return result; }
    operator AzFloatValue() && noexcept { AzFloatValue result = inner_; inner_ = {}; return result; }
};

class LayoutSize {
private:
    AzLayoutSize inner_;

public:
    LayoutSize(AzLayoutSize inner) noexcept : inner_(inner) {}
    LayoutSize(const LayoutSize& other) noexcept : inner_(other.inner_) {}
    LayoutSize& operator=(const LayoutSize& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutSize() {}

    [[nodiscard]] static LayoutSize create(ptrdiff_t width, ptrdiff_t height);
    [[nodiscard]] static LayoutSize zero();
    [[nodiscard]] static LayoutSize default_();

    bool partialEq(const LayoutSize& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutSize& b) const;
    uint8_t cmp(const LayoutSize& b) const;
    String toDbgString() const;

    const AzLayoutSize& inner() const { return inner_; }
    AzLayoutSize& inner() { return inner_; }
    const AzLayoutSize* ptr() const { return &inner_; }
    AzLayoutSize* ptr() { return &inner_; }
    AzLayoutSize release() { AzLayoutSize result = inner_; inner_ = {}; return result; }
    operator AzLayoutSize() && noexcept { AzLayoutSize result = inner_; inner_ = {}; return result; }
};

class StyleLineClamp {
private:
    AzStyleLineClamp inner_;

public:
    StyleLineClamp(AzStyleLineClamp inner) noexcept : inner_(inner) {}
    StyleLineClamp(const StyleLineClamp& other) noexcept : inner_(other.inner_) {}
    StyleLineClamp& operator=(const StyleLineClamp& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleLineClamp() {}

    bool partialEq(const StyleLineClamp& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleLineClamp& b) const;
    uint8_t cmp(const StyleLineClamp& b) const;
    String toDbgString() const;

    const AzStyleLineClamp& inner() const { return inner_; }
    AzStyleLineClamp& inner() { return inner_; }
    const AzStyleLineClamp* ptr() const { return &inner_; }
    AzStyleLineClamp* ptr() { return &inner_; }
    AzStyleLineClamp release() { AzStyleLineClamp result = inner_; inner_ = {}; return result; }
    operator AzStyleLineClamp() && noexcept { AzStyleLineClamp result = inner_; inner_ = {}; return result; }
};

class Orphans {
private:
    AzOrphans inner_;

public:
    Orphans(AzOrphans inner) noexcept : inner_(inner) {}
    Orphans(const Orphans& other) noexcept : inner_(other.inner_) {}
    Orphans& operator=(const Orphans& other) noexcept { inner_ = other.inner_; return *this; }
    ~Orphans() {}

    [[nodiscard]] static Orphans default_();

    bool partialEq(const Orphans& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const Orphans& b) const;
    uint8_t cmp(const Orphans& b) const;
    String toDbgString() const;

    const AzOrphans& inner() const { return inner_; }
    AzOrphans& inner() { return inner_; }
    const AzOrphans* ptr() const { return &inner_; }
    AzOrphans* ptr() { return &inner_; }
    AzOrphans release() { AzOrphans result = inner_; inner_ = {}; return result; }
    operator AzOrphans() && noexcept { AzOrphans result = inner_; inner_ = {}; return result; }
};

class Widows {
private:
    AzWidows inner_;

public:
    Widows(AzWidows inner) noexcept : inner_(inner) {}
    Widows(const Widows& other) noexcept : inner_(other.inner_) {}
    Widows& operator=(const Widows& other) noexcept { inner_ = other.inner_; return *this; }
    ~Widows() {}

    [[nodiscard]] static Widows default_();

    bool partialEq(const Widows& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const Widows& b) const;
    uint8_t cmp(const Widows& b) const;
    String toDbgString() const;

    const AzWidows& inner() const { return inner_; }
    AzWidows& inner() { return inner_; }
    const AzWidows* ptr() const { return &inner_; }
    AzWidows* ptr() { return &inner_; }
    AzWidows release() { AzWidows result = inner_; inner_ = {}; return result; }
    operator AzWidows() && noexcept { AzWidows result = inner_; inner_ = {}; return result; }
};

class StyleHangingPunctuation {
private:
    AzStyleHangingPunctuation inner_;

public:
    StyleHangingPunctuation(AzStyleHangingPunctuation inner) noexcept : inner_(inner) {}
    StyleHangingPunctuation(const StyleHangingPunctuation& other) noexcept : inner_(other.inner_) {}
    StyleHangingPunctuation& operator=(const StyleHangingPunctuation& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleHangingPunctuation() {}

    [[nodiscard]] static StyleHangingPunctuation default_();

    bool partialEq(const StyleHangingPunctuation& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleHangingPunctuation& b) const;
    uint8_t cmp(const StyleHangingPunctuation& b) const;
    String toDbgString() const;

    const AzStyleHangingPunctuation& inner() const { return inner_; }
    AzStyleHangingPunctuation& inner() { return inner_; }
    const AzStyleHangingPunctuation* ptr() const { return &inner_; }
    AzStyleHangingPunctuation* ptr() { return &inner_; }
    AzStyleHangingPunctuation release() { AzStyleHangingPunctuation result = inner_; inner_ = {}; return result; }
    operator AzStyleHangingPunctuation() && noexcept { AzStyleHangingPunctuation result = inner_; inner_ = {}; return result; }
};

class XmlTextPos {
private:
    AzXmlTextPos inner_;

    XmlTextPos(const XmlTextPos&) = delete;
    XmlTextPos& operator=(const XmlTextPos&) = delete;

public:
    explicit XmlTextPos(AzXmlTextPos inner) noexcept : inner_(inner) {}

    XmlTextPos(XmlTextPos&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    XmlTextPos& operator=(XmlTextPos&& other) noexcept {
        if (this != &other) {
            AzXmlTextPos_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~XmlTextPos() { AzXmlTextPos_delete(&inner_); }

    void delete_();
    XmlTextPos clone() const;
    bool partialEq(const XmlTextPos& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const XmlTextPos& b) const;
    uint8_t cmp(const XmlTextPos& b) const;
    String toDbgString() const;

    const AzXmlTextPos& inner() const { return inner_; }
    AzXmlTextPos& inner() { return inner_; }
    const AzXmlTextPos* ptr() const { return &inner_; }
    AzXmlTextPos* ptr() { return &inner_; }
    AzXmlTextPos release() { AzXmlTextPos result = inner_; inner_ = {}; return result; }
    operator AzXmlTextPos() && noexcept { AzXmlTextPos result = inner_; inner_ = {}; return result; }
};

class LogicalSize {
private:
    AzLogicalSize inner_;

public:
    LogicalSize(AzLogicalSize inner) noexcept : inner_(inner) {}
    LogicalSize(const LogicalSize& other) noexcept : inner_(other.inner_) {}
    LogicalSize& operator=(const LogicalSize& other) noexcept { inner_ = other.inner_; return *this; }
    ~LogicalSize() {}

    [[nodiscard]] static LogicalSize create(float width, float height);
    [[nodiscard]] static LogicalSize zero();
    [[nodiscard]] static LogicalSize default_();

    bool partialEq(const LogicalSize& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LogicalSize& b) const;
    uint8_t cmp(const LogicalSize& b) const;
    String toDbgString() const;

    const AzLogicalSize& inner() const { return inner_; }
    AzLogicalSize& inner() { return inner_; }
    const AzLogicalSize* ptr() const { return &inner_; }
    AzLogicalSize* ptr() { return &inner_; }
    AzLogicalSize release() { AzLogicalSize result = inner_; inner_ = {}; return result; }
    operator AzLogicalSize() && noexcept { AzLogicalSize result = inner_; inner_ = {}; return result; }
};

class StyledNodeState {
private:
    AzStyledNodeState inner_;

public:
    StyledNodeState(AzStyledNodeState inner) noexcept : inner_(inner) {}
    StyledNodeState(const StyledNodeState& other) noexcept : inner_(other.inner_) {}
    StyledNodeState& operator=(const StyledNodeState& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyledNodeState() {}

    [[nodiscard]] static StyledNodeState default_();

    bool partialEq(const StyledNodeState& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyledNodeState& b) const;
    uint8_t cmp(const StyledNodeState& b) const;
    String toDbgString() const;

    const AzStyledNodeState& inner() const { return inner_; }
    AzStyledNodeState& inner() { return inner_; }
    const AzStyledNodeState* ptr() const { return &inner_; }
    AzStyledNodeState* ptr() { return &inner_; }
    AzStyledNodeState release() { AzStyledNodeState result = inner_; inner_ = {}; return result; }
    operator AzStyledNodeState() && noexcept { AzStyledNodeState result = inner_; inner_ = {}; return result; }
};

class CssPropertyCachePtr {
private:
    AzCssPropertyCachePtr inner_;

    CssPropertyCachePtr(const CssPropertyCachePtr&) = delete;
    CssPropertyCachePtr& operator=(const CssPropertyCachePtr&) = delete;

public:
    explicit CssPropertyCachePtr(AzCssPropertyCachePtr inner) noexcept : inner_(inner) {}

    CssPropertyCachePtr(CssPropertyCachePtr&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssPropertyCachePtr& operator=(CssPropertyCachePtr&& other) noexcept {
        if (this != &other) {
            AzCssPropertyCachePtr_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssPropertyCachePtr() { AzCssPropertyCachePtr_delete(&inner_); }

    void delete_();
    CssPropertyCachePtr clone() const;
    bool partialEq(const CssPropertyCachePtr& b) const;
    String toDbgString() const;

    const AzCssPropertyCachePtr& inner() const { return inner_; }
    AzCssPropertyCachePtr& inner() { return inner_; }
    const AzCssPropertyCachePtr* ptr() const { return &inner_; }
    AzCssPropertyCachePtr* ptr() { return &inner_; }
    AzCssPropertyCachePtr release() { AzCssPropertyCachePtr result = inner_; inner_ = {}; return result; }
    operator AzCssPropertyCachePtr() && noexcept { AzCssPropertyCachePtr result = inner_; inner_ = {}; return result; }
};

class SvgRenderTransform {
private:
    AzSvgRenderTransform inner_;

public:
    SvgRenderTransform(AzSvgRenderTransform inner) noexcept : inner_(inner) {}
    SvgRenderTransform(const SvgRenderTransform& other) noexcept : inner_(other.inner_) {}
    SvgRenderTransform& operator=(const SvgRenderTransform& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgRenderTransform() {}

    [[nodiscard]] static SvgRenderTransform default_();

    bool partialEq(const SvgRenderTransform& b) const;
    uint8_t partialCmp(const SvgRenderTransform& b) const;
    String toDbgString() const;

    const AzSvgRenderTransform& inner() const { return inner_; }
    AzSvgRenderTransform& inner() { return inner_; }
    const AzSvgRenderTransform* ptr() const { return &inner_; }
    AzSvgRenderTransform* ptr() { return &inner_; }
    AzSvgRenderTransform release() { AzSvgRenderTransform result = inner_; inner_ = {}; return result; }
    operator AzSvgRenderTransform() && noexcept { AzSvgRenderTransform result = inner_; inner_ = {}; return result; }
};

class LogicalPosition {
private:
    AzLogicalPosition inner_;

public:
    LogicalPosition(AzLogicalPosition inner) noexcept : inner_(inner) {}
    LogicalPosition(const LogicalPosition& other) noexcept : inner_(other.inner_) {}
    LogicalPosition& operator=(const LogicalPosition& other) noexcept { inner_ = other.inner_; return *this; }
    ~LogicalPosition() {}

    [[nodiscard]] static LogicalPosition create(float x, float y);
    [[nodiscard]] static LogicalPosition zero();
    [[nodiscard]] static LogicalPosition default_();

    bool partialEq(const LogicalPosition& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LogicalPosition& b) const;
    uint8_t cmp(const LogicalPosition& b) const;
    String toDbgString() const;

    const AzLogicalPosition& inner() const { return inner_; }
    AzLogicalPosition& inner() { return inner_; }
    const AzLogicalPosition* ptr() const { return &inner_; }
    AzLogicalPosition* ptr() { return &inner_; }
    AzLogicalPosition release() { AzLogicalPosition result = inner_; inner_ = {}; return result; }
    operator AzLogicalPosition() && noexcept { AzLogicalPosition result = inner_; inner_ = {}; return result; }
};

class ScreenPosition {
private:
    AzScreenPosition inner_;

public:
    ScreenPosition(AzScreenPosition inner) noexcept : inner_(inner) {}
    ScreenPosition(const ScreenPosition& other) noexcept : inner_(other.inner_) {}
    ScreenPosition& operator=(const ScreenPosition& other) noexcept { inner_ = other.inner_; return *this; }
    ~ScreenPosition() {}

    [[nodiscard]] static ScreenPosition create(float x, float y);
    [[nodiscard]] static ScreenPosition zero();
    [[nodiscard]] static ScreenPosition default_();

    bool partialEq(const ScreenPosition& b) const;
    uint8_t partialCmp(const ScreenPosition& b) const;
    String toDbgString() const;

    const AzScreenPosition& inner() const { return inner_; }
    AzScreenPosition& inner() { return inner_; }
    const AzScreenPosition* ptr() const { return &inner_; }
    AzScreenPosition* ptr() { return &inner_; }
    AzScreenPosition release() { AzScreenPosition result = inner_; inner_ = {}; return result; }
    operator AzScreenPosition() && noexcept { AzScreenPosition result = inner_; inner_ = {}; return result; }
};

class CursorNodePosition {
private:
    AzCursorNodePosition inner_;

public:
    CursorNodePosition(AzCursorNodePosition inner) noexcept : inner_(inner) {}
    CursorNodePosition(const CursorNodePosition& other) noexcept : inner_(other.inner_) {}
    CursorNodePosition& operator=(const CursorNodePosition& other) noexcept { inner_ = other.inner_; return *this; }
    ~CursorNodePosition() {}

    [[nodiscard]] static CursorNodePosition create(float x, float y);
    [[nodiscard]] static CursorNodePosition zero();
    [[nodiscard]] static CursorNodePosition default_();

    bool partialEq(const CursorNodePosition& b) const;
    uint8_t partialCmp(const CursorNodePosition& b) const;
    String toDbgString() const;

    const AzCursorNodePosition& inner() const { return inner_; }
    AzCursorNodePosition& inner() { return inner_; }
    const AzCursorNodePosition* ptr() const { return &inner_; }
    AzCursorNodePosition* ptr() { return &inner_; }
    AzCursorNodePosition release() { AzCursorNodePosition result = inner_; inner_ = {}; return result; }
    operator AzCursorNodePosition() && noexcept { AzCursorNodePosition result = inner_; inner_ = {}; return result; }
};

class GridMinMax {
private:
    AzGridMinMax inner_;

    GridMinMax(const GridMinMax&) = delete;
    GridMinMax& operator=(const GridMinMax&) = delete;

public:
    explicit GridMinMax(AzGridMinMax inner) noexcept : inner_(inner) {}

    GridMinMax(GridMinMax&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GridMinMax& operator=(GridMinMax&& other) noexcept {
        if (this != &other) {
            AzGridMinMax_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GridMinMax() { AzGridMinMax_delete(&inner_); }

    void delete_();
    GridMinMax clone() const;
    bool partialEq(const GridMinMax& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GridMinMax& b) const;
    uint8_t cmp(const GridMinMax& b) const;
    String toDbgString() const;

    const AzGridMinMax& inner() const { return inner_; }
    AzGridMinMax& inner() { return inner_; }
    const AzGridMinMax* ptr() const { return &inner_; }
    AzGridMinMax* ptr() { return &inner_; }
    AzGridMinMax release() { AzGridMinMax result = inner_; inner_ = {}; return result; }
    operator AzGridMinMax() && noexcept { AzGridMinMax result = inner_; inner_ = {}; return result; }
};

class ShapePoint {
private:
    AzShapePoint inner_;

public:
    ShapePoint(AzShapePoint inner) noexcept : inner_(inner) {}
    ShapePoint(const ShapePoint& other) noexcept : inner_(other.inner_) {}
    ShapePoint& operator=(const ShapePoint& other) noexcept { inner_ = other.inner_; return *this; }
    ~ShapePoint() {}

    bool partialEq(const ShapePoint& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ShapePoint& b) const;
    uint8_t cmp(const ShapePoint& b) const;
    String toDbgString() const;

    const AzShapePoint& inner() const { return inner_; }
    AzShapePoint& inner() { return inner_; }
    const AzShapePoint* ptr() const { return &inner_; }
    AzShapePoint* ptr() { return &inner_; }
    AzShapePoint release() { AzShapePoint result = inner_; inner_ = {}; return result; }
    operator AzShapePoint() && noexcept { AzShapePoint result = inner_; inner_ = {}; return result; }
};

class LayoutRectVecSlice {
private:
    AzLayoutRectVecSlice inner_;

public:
    LayoutRectVecSlice(AzLayoutRectVecSlice inner) noexcept : inner_(inner) {}
    LayoutRectVecSlice(const LayoutRectVecSlice& other) noexcept : inner_(other.inner_) {}
    LayoutRectVecSlice& operator=(const LayoutRectVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutRectVecSlice() {}

    String toDbgString() const;

    const AzLayoutRectVecSlice& inner() const { return inner_; }
    AzLayoutRectVecSlice& inner() { return inner_; }
    const AzLayoutRectVecSlice* ptr() const { return &inner_; }
    AzLayoutRectVecSlice* ptr() { return &inner_; }
    AzLayoutRectVecSlice release() { AzLayoutRectVecSlice result = inner_; inner_ = {}; return result; }
    operator AzLayoutRectVecSlice() && noexcept { AzLayoutRectVecSlice result = inner_; inner_ = {}; return result; }
};

class LayoutPoint {
private:
    AzLayoutPoint inner_;

public:
    LayoutPoint(AzLayoutPoint inner) noexcept : inner_(inner) {}
    LayoutPoint(const LayoutPoint& other) noexcept : inner_(other.inner_) {}
    LayoutPoint& operator=(const LayoutPoint& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutPoint() {}

    [[nodiscard]] static LayoutPoint create(ptrdiff_t x, ptrdiff_t y);
    [[nodiscard]] static LayoutPoint zero();
    [[nodiscard]] static LayoutPoint default_();

    bool partialEq(const LayoutPoint& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutPoint& b) const;
    uint8_t cmp(const LayoutPoint& b) const;
    String toDbgString() const;

    const AzLayoutPoint& inner() const { return inner_; }
    AzLayoutPoint& inner() { return inner_; }
    const AzLayoutPoint* ptr() const { return &inner_; }
    AzLayoutPoint* ptr() { return &inner_; }
    AzLayoutPoint release() { AzLayoutPoint result = inner_; inner_ = {}; return result; }
    operator AzLayoutPoint() && noexcept { AzLayoutPoint result = inner_; inner_ = {}; return result; }
};

class LinuxDecorationsState {
private:
    AzLinuxDecorationsState inner_;

public:
    LinuxDecorationsState(AzLinuxDecorationsState inner) noexcept : inner_(inner) {}
    LinuxDecorationsState(const LinuxDecorationsState& other) noexcept : inner_(other.inner_) {}
    LinuxDecorationsState& operator=(const LinuxDecorationsState& other) noexcept { inner_ = other.inner_; return *this; }
    ~LinuxDecorationsState() {}

    [[nodiscard]] static LinuxDecorationsState default_();

    bool partialEq(const LinuxDecorationsState& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LinuxDecorationsState& b) const;
    uint8_t cmp(const LinuxDecorationsState& b) const;
    String toDbgString() const;

    const AzLinuxDecorationsState& inner() const { return inner_; }
    AzLinuxDecorationsState& inner() { return inner_; }
    const AzLinuxDecorationsState* ptr() const { return &inner_; }
    AzLinuxDecorationsState* ptr() { return &inner_; }
    AzLinuxDecorationsState release() { AzLinuxDecorationsState result = inner_; inner_ = {}; return result; }
    operator AzLinuxDecorationsState() && noexcept { AzLinuxDecorationsState result = inner_; inner_ = {}; return result; }
};

class CascadeInfo {
private:
    AzCascadeInfo inner_;

public:
    CascadeInfo(AzCascadeInfo inner) noexcept : inner_(inner) {}
    CascadeInfo(const CascadeInfo& other) noexcept : inner_(other.inner_) {}
    CascadeInfo& operator=(const CascadeInfo& other) noexcept { inner_ = other.inner_; return *this; }
    ~CascadeInfo() {}

    [[nodiscard]] static CascadeInfo default_();

    bool partialEq(const CascadeInfo& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CascadeInfo& b) const;
    uint8_t cmp(const CascadeInfo& b) const;
    String toDbgString() const;

    const AzCascadeInfo& inner() const { return inner_; }
    AzCascadeInfo& inner() { return inner_; }
    const AzCascadeInfo* ptr() const { return &inner_; }
    AzCascadeInfo* ptr() { return &inner_; }
    AzCascadeInfo release() { AzCascadeInfo result = inner_; inner_ = {}; return result; }
    operator AzCascadeInfo() && noexcept { AzCascadeInfo result = inner_; inner_ = {}; return result; }
};

class GridTrackSizingVecSlice {
private:
    AzGridTrackSizingVecSlice inner_;

public:
    GridTrackSizingVecSlice(AzGridTrackSizingVecSlice inner) noexcept : inner_(inner) {}
    GridTrackSizingVecSlice(const GridTrackSizingVecSlice& other) noexcept : inner_(other.inner_) {}
    GridTrackSizingVecSlice& operator=(const GridTrackSizingVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~GridTrackSizingVecSlice() {}

    String toDbgString() const;

    const AzGridTrackSizingVecSlice& inner() const { return inner_; }
    AzGridTrackSizingVecSlice& inner() { return inner_; }
    const AzGridTrackSizingVecSlice* ptr() const { return &inner_; }
    AzGridTrackSizingVecSlice* ptr() { return &inner_; }
    AzGridTrackSizingVecSlice release() { AzGridTrackSizingVecSlice result = inner_; inner_ = {}; return result; }
    operator AzGridTrackSizingVecSlice() && noexcept { AzGridTrackSizingVecSlice result = inner_; inner_ = {}; return result; }
};

class ContentGroupVecSlice {
private:
    AzContentGroupVecSlice inner_;

public:
    ContentGroupVecSlice(AzContentGroupVecSlice inner) noexcept : inner_(inner) {}
    ContentGroupVecSlice(const ContentGroupVecSlice& other) noexcept : inner_(other.inner_) {}
    ContentGroupVecSlice& operator=(const ContentGroupVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ContentGroupVecSlice() {}

    String toDbgString() const;

    const AzContentGroupVecSlice& inner() const { return inner_; }
    AzContentGroupVecSlice& inner() { return inner_; }
    const AzContentGroupVecSlice* ptr() const { return &inner_; }
    AzContentGroupVecSlice* ptr() { return &inner_; }
    AzContentGroupVecSlice release() { AzContentGroupVecSlice result = inner_; inner_ = {}; return result; }
    operator AzContentGroupVecSlice() && noexcept { AzContentGroupVecSlice result = inner_; inner_ = {}; return result; }
};

class StyledTextRunVecSlice {
private:
    AzStyledTextRunVecSlice inner_;

public:
    StyledTextRunVecSlice(AzStyledTextRunVecSlice inner) noexcept : inner_(inner) {}
    StyledTextRunVecSlice(const StyledTextRunVecSlice& other) noexcept : inner_(other.inner_) {}
    StyledTextRunVecSlice& operator=(const StyledTextRunVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyledTextRunVecSlice() {}

    String toDbgString() const;

    const AzStyledTextRunVecSlice& inner() const { return inner_; }
    AzStyledTextRunVecSlice& inner() { return inner_; }
    const AzStyledTextRunVecSlice* ptr() const { return &inner_; }
    AzStyledTextRunVecSlice* ptr() { return &inner_; }
    AzStyledTextRunVecSlice release() { AzStyledTextRunVecSlice result = inner_; inner_ = {}; return result; }
    operator AzStyledTextRunVecSlice() && noexcept { AzStyledTextRunVecSlice result = inner_; inner_ = {}; return result; }
};

class CssRuleBlockVecSlice {
private:
    AzCssRuleBlockVecSlice inner_;

public:
    CssRuleBlockVecSlice(AzCssRuleBlockVecSlice inner) noexcept : inner_(inner) {}
    CssRuleBlockVecSlice(const CssRuleBlockVecSlice& other) noexcept : inner_(other.inner_) {}
    CssRuleBlockVecSlice& operator=(const CssRuleBlockVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~CssRuleBlockVecSlice() {}

    String toDbgString() const;

    const AzCssRuleBlockVecSlice& inner() const { return inner_; }
    AzCssRuleBlockVecSlice& inner() { return inner_; }
    const AzCssRuleBlockVecSlice* ptr() const { return &inner_; }
    AzCssRuleBlockVecSlice* ptr() { return &inner_; }
    AzCssRuleBlockVecSlice release() { AzCssRuleBlockVecSlice result = inner_; inner_ = {}; return result; }
    operator AzCssRuleBlockVecSlice() && noexcept { AzCssRuleBlockVecSlice result = inner_; inner_ = {}; return result; }
};

class CascadeInfoVecSlice {
private:
    AzCascadeInfoVecSlice inner_;

public:
    CascadeInfoVecSlice(AzCascadeInfoVecSlice inner) noexcept : inner_(inner) {}
    CascadeInfoVecSlice(const CascadeInfoVecSlice& other) noexcept : inner_(other.inner_) {}
    CascadeInfoVecSlice& operator=(const CascadeInfoVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~CascadeInfoVecSlice() {}

    String toDbgString() const;

    const AzCascadeInfoVecSlice& inner() const { return inner_; }
    AzCascadeInfoVecSlice& inner() { return inner_; }
    const AzCascadeInfoVecSlice* ptr() const { return &inner_; }
    AzCascadeInfoVecSlice* ptr() { return &inner_; }
    AzCascadeInfoVecSlice release() { AzCascadeInfoVecSlice result = inner_; inner_ = {}; return result; }
    operator AzCascadeInfoVecSlice() && noexcept { AzCascadeInfoVecSlice result = inner_; inner_ = {}; return result; }
};

class NormalizedRadialColorStopVecSlice {
private:
    AzNormalizedRadialColorStopVecSlice inner_;

public:
    NormalizedRadialColorStopVecSlice(AzNormalizedRadialColorStopVecSlice inner) noexcept : inner_(inner) {}
    NormalizedRadialColorStopVecSlice(const NormalizedRadialColorStopVecSlice& other) noexcept : inner_(other.inner_) {}
    NormalizedRadialColorStopVecSlice& operator=(const NormalizedRadialColorStopVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~NormalizedRadialColorStopVecSlice() {}

    String toDbgString() const;

    const AzNormalizedRadialColorStopVecSlice& inner() const { return inner_; }
    AzNormalizedRadialColorStopVecSlice& inner() { return inner_; }
    const AzNormalizedRadialColorStopVecSlice* ptr() const { return &inner_; }
    AzNormalizedRadialColorStopVecSlice* ptr() { return &inner_; }
    AzNormalizedRadialColorStopVecSlice release() { AzNormalizedRadialColorStopVecSlice result = inner_; inner_ = {}; return result; }
    operator AzNormalizedRadialColorStopVecSlice() && noexcept { AzNormalizedRadialColorStopVecSlice result = inner_; inner_ = {}; return result; }
};

class StyleFontFamilyVecSlice {
private:
    AzStyleFontFamilyVecSlice inner_;

public:
    StyleFontFamilyVecSlice(AzStyleFontFamilyVecSlice inner) noexcept : inner_(inner) {}
    StyleFontFamilyVecSlice(const StyleFontFamilyVecSlice& other) noexcept : inner_(other.inner_) {}
    StyleFontFamilyVecSlice& operator=(const StyleFontFamilyVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleFontFamilyVecSlice() {}

    String toDbgString() const;

    const AzStyleFontFamilyVecSlice& inner() const { return inner_; }
    AzStyleFontFamilyVecSlice& inner() { return inner_; }
    const AzStyleFontFamilyVecSlice* ptr() const { return &inner_; }
    AzStyleFontFamilyVecSlice* ptr() { return &inner_; }
    AzStyleFontFamilyVecSlice release() { AzStyleFontFamilyVecSlice result = inner_; inner_ = {}; return result; }
    operator AzStyleFontFamilyVecSlice() && noexcept { AzStyleFontFamilyVecSlice result = inner_; inner_ = {}; return result; }
};

class StyleFilterVecSlice {
private:
    AzStyleFilterVecSlice inner_;

public:
    StyleFilterVecSlice(AzStyleFilterVecSlice inner) noexcept : inner_(inner) {}
    StyleFilterVecSlice(const StyleFilterVecSlice& other) noexcept : inner_(other.inner_) {}
    StyleFilterVecSlice& operator=(const StyleFilterVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleFilterVecSlice() {}

    String toDbgString() const;

    const AzStyleFilterVecSlice& inner() const { return inner_; }
    AzStyleFilterVecSlice& inner() { return inner_; }
    const AzStyleFilterVecSlice* ptr() const { return &inner_; }
    AzStyleFilterVecSlice* ptr() { return &inner_; }
    AzStyleFilterVecSlice release() { AzStyleFilterVecSlice result = inner_; inner_ = {}; return result; }
    operator AzStyleFilterVecSlice() && noexcept { AzStyleFilterVecSlice result = inner_; inner_ = {}; return result; }
};

class StyleBackgroundSizeVecSlice {
private:
    AzStyleBackgroundSizeVecSlice inner_;

public:
    StyleBackgroundSizeVecSlice(AzStyleBackgroundSizeVecSlice inner) noexcept : inner_(inner) {}
    StyleBackgroundSizeVecSlice(const StyleBackgroundSizeVecSlice& other) noexcept : inner_(other.inner_) {}
    StyleBackgroundSizeVecSlice& operator=(const StyleBackgroundSizeVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBackgroundSizeVecSlice() {}

    String toDbgString() const;

    const AzStyleBackgroundSizeVecSlice& inner() const { return inner_; }
    AzStyleBackgroundSizeVecSlice& inner() { return inner_; }
    const AzStyleBackgroundSizeVecSlice* ptr() const { return &inner_; }
    AzStyleBackgroundSizeVecSlice* ptr() { return &inner_; }
    AzStyleBackgroundSizeVecSlice release() { AzStyleBackgroundSizeVecSlice result = inner_; inner_ = {}; return result; }
    operator AzStyleBackgroundSizeVecSlice() && noexcept { AzStyleBackgroundSizeVecSlice result = inner_; inner_ = {}; return result; }
};

class StyleBackgroundContentVecSlice {
private:
    AzStyleBackgroundContentVecSlice inner_;

public:
    StyleBackgroundContentVecSlice(AzStyleBackgroundContentVecSlice inner) noexcept : inner_(inner) {}
    StyleBackgroundContentVecSlice(const StyleBackgroundContentVecSlice& other) noexcept : inner_(other.inner_) {}
    StyleBackgroundContentVecSlice& operator=(const StyleBackgroundContentVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBackgroundContentVecSlice() {}

    String toDbgString() const;

    const AzStyleBackgroundContentVecSlice& inner() const { return inner_; }
    AzStyleBackgroundContentVecSlice& inner() { return inner_; }
    const AzStyleBackgroundContentVecSlice* ptr() const { return &inner_; }
    AzStyleBackgroundContentVecSlice* ptr() { return &inner_; }
    AzStyleBackgroundContentVecSlice release() { AzStyleBackgroundContentVecSlice result = inner_; inner_ = {}; return result; }
    operator AzStyleBackgroundContentVecSlice() && noexcept { AzStyleBackgroundContentVecSlice result = inner_; inner_ = {}; return result; }
};

class CssDeclarationVecSlice {
private:
    AzCssDeclarationVecSlice inner_;

public:
    CssDeclarationVecSlice(AzCssDeclarationVecSlice inner) noexcept : inner_(inner) {}
    CssDeclarationVecSlice(const CssDeclarationVecSlice& other) noexcept : inner_(other.inner_) {}
    CssDeclarationVecSlice& operator=(const CssDeclarationVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~CssDeclarationVecSlice() {}

    String toDbgString() const;

    const AzCssDeclarationVecSlice& inner() const { return inner_; }
    AzCssDeclarationVecSlice& inner() { return inner_; }
    const AzCssDeclarationVecSlice* ptr() const { return &inner_; }
    AzCssDeclarationVecSlice* ptr() { return &inner_; }
    AzCssDeclarationVecSlice release() { AzCssDeclarationVecSlice result = inner_; inner_ = {}; return result; }
    operator AzCssDeclarationVecSlice() && noexcept { AzCssDeclarationVecSlice result = inner_; inner_ = {}; return result; }
};

class StyleBackgroundPositionVecSlice {
private:
    AzStyleBackgroundPositionVecSlice inner_;

public:
    StyleBackgroundPositionVecSlice(AzStyleBackgroundPositionVecSlice inner) noexcept : inner_(inner) {}
    StyleBackgroundPositionVecSlice(const StyleBackgroundPositionVecSlice& other) noexcept : inner_(other.inner_) {}
    StyleBackgroundPositionVecSlice& operator=(const StyleBackgroundPositionVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBackgroundPositionVecSlice() {}

    String toDbgString() const;

    const AzStyleBackgroundPositionVecSlice& inner() const { return inner_; }
    AzStyleBackgroundPositionVecSlice& inner() { return inner_; }
    const AzStyleBackgroundPositionVecSlice* ptr() const { return &inner_; }
    AzStyleBackgroundPositionVecSlice* ptr() { return &inner_; }
    AzStyleBackgroundPositionVecSlice release() { AzStyleBackgroundPositionVecSlice result = inner_; inner_ = {}; return result; }
    operator AzStyleBackgroundPositionVecSlice() && noexcept { AzStyleBackgroundPositionVecSlice result = inner_; inner_ = {}; return result; }
};

class NormalizedLinearColorStopVecSlice {
private:
    AzNormalizedLinearColorStopVecSlice inner_;

public:
    NormalizedLinearColorStopVecSlice(AzNormalizedLinearColorStopVecSlice inner) noexcept : inner_(inner) {}
    NormalizedLinearColorStopVecSlice(const NormalizedLinearColorStopVecSlice& other) noexcept : inner_(other.inner_) {}
    NormalizedLinearColorStopVecSlice& operator=(const NormalizedLinearColorStopVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~NormalizedLinearColorStopVecSlice() {}

    String toDbgString() const;

    const AzNormalizedLinearColorStopVecSlice& inner() const { return inner_; }
    AzNormalizedLinearColorStopVecSlice& inner() { return inner_; }
    const AzNormalizedLinearColorStopVecSlice* ptr() const { return &inner_; }
    AzNormalizedLinearColorStopVecSlice* ptr() { return &inner_; }
    AzNormalizedLinearColorStopVecSlice release() { AzNormalizedLinearColorStopVecSlice result = inner_; inner_ = {}; return result; }
    operator AzNormalizedLinearColorStopVecSlice() && noexcept { AzNormalizedLinearColorStopVecSlice result = inner_; inner_ = {}; return result; }
};

class CssPropertyWithConditionsVecSlice {
private:
    AzCssPropertyWithConditionsVecSlice inner_;

public:
    CssPropertyWithConditionsVecSlice(AzCssPropertyWithConditionsVecSlice inner) noexcept : inner_(inner) {}
    CssPropertyWithConditionsVecSlice(const CssPropertyWithConditionsVecSlice& other) noexcept : inner_(other.inner_) {}
    CssPropertyWithConditionsVecSlice& operator=(const CssPropertyWithConditionsVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~CssPropertyWithConditionsVecSlice() {}

    String toDbgString() const;

    const AzCssPropertyWithConditionsVecSlice& inner() const { return inner_; }
    AzCssPropertyWithConditionsVecSlice& inner() { return inner_; }
    const AzCssPropertyWithConditionsVecSlice* ptr() const { return &inner_; }
    AzCssPropertyWithConditionsVecSlice* ptr() { return &inner_; }
    AzCssPropertyWithConditionsVecSlice release() { AzCssPropertyWithConditionsVecSlice result = inner_; inner_ = {}; return result; }
    operator AzCssPropertyWithConditionsVecSlice() && noexcept { AzCssPropertyWithConditionsVecSlice result = inner_; inner_ = {}; return result; }
};

class CssVecSlice {
private:
    AzCssVecSlice inner_;

public:
    CssVecSlice(AzCssVecSlice inner) noexcept : inner_(inner) {}
    CssVecSlice(const CssVecSlice& other) noexcept : inner_(other.inner_) {}
    CssVecSlice& operator=(const CssVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~CssVecSlice() {}

    String toDbgString() const;

    const AzCssVecSlice& inner() const { return inner_; }
    AzCssVecSlice& inner() { return inner_; }
    const AzCssVecSlice* ptr() const { return &inner_; }
    AzCssVecSlice* ptr() { return &inner_; }
    AzCssVecSlice release() { AzCssVecSlice result = inner_; inner_ = {}; return result; }
    operator AzCssVecSlice() && noexcept { AzCssVecSlice result = inner_; inner_ = {}; return result; }
};

class StyleTransformVecSlice {
private:
    AzStyleTransformVecSlice inner_;

public:
    StyleTransformVecSlice(AzStyleTransformVecSlice inner) noexcept : inner_(inner) {}
    StyleTransformVecSlice(const StyleTransformVecSlice& other) noexcept : inner_(other.inner_) {}
    StyleTransformVecSlice& operator=(const StyleTransformVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleTransformVecSlice() {}

    String toDbgString() const;

    const AzStyleTransformVecSlice& inner() const { return inner_; }
    AzStyleTransformVecSlice& inner() { return inner_; }
    const AzStyleTransformVecSlice* ptr() const { return &inner_; }
    AzStyleTransformVecSlice* ptr() { return &inner_; }
    AzStyleTransformVecSlice release() { AzStyleTransformVecSlice result = inner_; inner_ = {}; return result; }
    operator AzStyleTransformVecSlice() && noexcept { AzStyleTransformVecSlice result = inner_; inner_ = {}; return result; }
};

class StyledNodeVecSlice {
private:
    AzStyledNodeVecSlice inner_;

public:
    StyledNodeVecSlice(AzStyledNodeVecSlice inner) noexcept : inner_(inner) {}
    StyledNodeVecSlice(const StyledNodeVecSlice& other) noexcept : inner_(other.inner_) {}
    StyledNodeVecSlice& operator=(const StyledNodeVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyledNodeVecSlice() {}

    String toDbgString() const;

    const AzStyledNodeVecSlice& inner() const { return inner_; }
    AzStyledNodeVecSlice& inner() { return inner_; }
    const AzStyledNodeVecSlice* ptr() const { return &inner_; }
    AzStyledNodeVecSlice* ptr() { return &inner_; }
    AzStyledNodeVecSlice release() { AzStyledNodeVecSlice result = inner_; inner_ = {}; return result; }
    operator AzStyledNodeVecSlice() && noexcept { AzStyledNodeVecSlice result = inner_; inner_ = {}; return result; }
};

class ShapePointVecSlice {
private:
    AzShapePointVecSlice inner_;

public:
    ShapePointVecSlice(AzShapePointVecSlice inner) noexcept : inner_(inner) {}
    ShapePointVecSlice(const ShapePointVecSlice& other) noexcept : inner_(other.inner_) {}
    ShapePointVecSlice& operator=(const ShapePointVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ShapePointVecSlice() {}

    String toDbgString() const;

    const AzShapePointVecSlice& inner() const { return inner_; }
    AzShapePointVecSlice& inner() { return inner_; }
    const AzShapePointVecSlice* ptr() const { return &inner_; }
    AzShapePointVecSlice* ptr() { return &inner_; }
    AzShapePointVecSlice release() { AzShapePointVecSlice result = inner_; inner_ = {}; return result; }
    operator AzShapePointVecSlice() && noexcept { AzShapePointVecSlice result = inner_; inner_ = {}; return result; }
};

class NamedFontVecSlice {
private:
    AzNamedFontVecSlice inner_;

public:
    NamedFontVecSlice(AzNamedFontVecSlice inner) noexcept : inner_(inner) {}
    NamedFontVecSlice(const NamedFontVecSlice& other) noexcept : inner_(other.inner_) {}
    NamedFontVecSlice& operator=(const NamedFontVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~NamedFontVecSlice() {}

    String toDbgString() const;

    const AzNamedFontVecSlice& inner() const { return inner_; }
    AzNamedFontVecSlice& inner() { return inner_; }
    const AzNamedFontVecSlice* ptr() const { return &inner_; }
    AzNamedFontVecSlice* ptr() { return &inner_; }
    AzNamedFontVecSlice release() { AzNamedFontVecSlice result = inner_; inner_ = {}; return result; }
    operator AzNamedFontVecSlice() && noexcept { AzNamedFontVecSlice result = inner_; inner_ = {}; return result; }
};

class GridAreaDefinitionVecSlice {
private:
    AzGridAreaDefinitionVecSlice inner_;

public:
    GridAreaDefinitionVecSlice(AzGridAreaDefinitionVecSlice inner) noexcept : inner_(inner) {}
    GridAreaDefinitionVecSlice(const GridAreaDefinitionVecSlice& other) noexcept : inner_(other.inner_) {}
    GridAreaDefinitionVecSlice& operator=(const GridAreaDefinitionVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~GridAreaDefinitionVecSlice() {}

    String toDbgString() const;

    const AzGridAreaDefinitionVecSlice& inner() const { return inner_; }
    AzGridAreaDefinitionVecSlice& inner() { return inner_; }
    const AzGridAreaDefinitionVecSlice* ptr() const { return &inner_; }
    AzGridAreaDefinitionVecSlice* ptr() { return &inner_; }
    AzGridAreaDefinitionVecSlice release() { AzGridAreaDefinitionVecSlice result = inner_; inner_ = {}; return result; }
    operator AzGridAreaDefinitionVecSlice() && noexcept { AzGridAreaDefinitionVecSlice result = inner_; inner_ = {}; return result; }
};

class SvgTransform {
private:
    AzSvgTransform inner_;

public:
    SvgTransform(AzSvgTransform inner) noexcept : inner_(inner) {}
    SvgTransform(const SvgTransform& other) noexcept : inner_(other.inner_) {}
    SvgTransform& operator=(const SvgTransform& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgTransform() {}

    [[nodiscard]] static SvgTransform default_();

    bool partialEq(const SvgTransform& b) const;
    uint8_t partialCmp(const SvgTransform& b) const;
    String toDbgString() const;

    const AzSvgTransform& inner() const { return inner_; }
    AzSvgTransform& inner() { return inner_; }
    const AzSvgTransform* ptr() const { return &inner_; }
    AzSvgTransform* ptr() { return &inner_; }
    AzSvgTransform release() { AzSvgTransform result = inner_; inner_ = {}; return result; }
    operator AzSvgTransform() && noexcept { AzSvgTransform result = inner_; inner_ = {}; return result; }
};

class ScrollbarFadeDuration {
private:
    AzScrollbarFadeDuration inner_;

public:
    ScrollbarFadeDuration(AzScrollbarFadeDuration inner) noexcept : inner_(inner) {}
    ScrollbarFadeDuration(const ScrollbarFadeDuration& other) noexcept : inner_(other.inner_) {}
    ScrollbarFadeDuration& operator=(const ScrollbarFadeDuration& other) noexcept { inner_ = other.inner_; return *this; }
    ~ScrollbarFadeDuration() {}

    [[nodiscard]] static ScrollbarFadeDuration default_();

    bool partialEq(const ScrollbarFadeDuration& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ScrollbarFadeDuration& b) const;
    uint8_t cmp(const ScrollbarFadeDuration& b) const;
    String toDbgString() const;

    const AzScrollbarFadeDuration& inner() const { return inner_; }
    AzScrollbarFadeDuration& inner() { return inner_; }
    const AzScrollbarFadeDuration* ptr() const { return &inner_; }
    AzScrollbarFadeDuration* ptr() { return &inner_; }
    AzScrollbarFadeDuration release() { AzScrollbarFadeDuration result = inner_; inner_ = {}; return result; }
    operator AzScrollbarFadeDuration() && noexcept { AzScrollbarFadeDuration result = inner_; inner_ = {}; return result; }
};

class ScrollbarFadeDelay {
private:
    AzScrollbarFadeDelay inner_;

public:
    ScrollbarFadeDelay(AzScrollbarFadeDelay inner) noexcept : inner_(inner) {}
    ScrollbarFadeDelay(const ScrollbarFadeDelay& other) noexcept : inner_(other.inner_) {}
    ScrollbarFadeDelay& operator=(const ScrollbarFadeDelay& other) noexcept { inner_ = other.inner_; return *this; }
    ~ScrollbarFadeDelay() {}

    [[nodiscard]] static ScrollbarFadeDelay default_();

    bool partialEq(const ScrollbarFadeDelay& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ScrollbarFadeDelay& b) const;
    uint8_t cmp(const ScrollbarFadeDelay& b) const;
    String toDbgString() const;

    const AzScrollbarFadeDelay& inner() const { return inner_; }
    AzScrollbarFadeDelay& inner() { return inner_; }
    const AzScrollbarFadeDelay* ptr() const { return &inner_; }
    AzScrollbarFadeDelay* ptr() { return &inner_; }
    AzScrollbarFadeDelay release() { AzScrollbarFadeDelay result = inner_; inner_ = {}; return result; }
    operator AzScrollbarFadeDelay() && noexcept { AzScrollbarFadeDelay result = inner_; inner_ = {}; return result; }
};

class U16VecSlice {
private:
    AzU16VecSlice inner_;

public:
    U16VecSlice(AzU16VecSlice inner) noexcept : inner_(inner) {}
    U16VecSlice(const U16VecSlice& other) noexcept : inner_(other.inner_) {}
    U16VecSlice& operator=(const U16VecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~U16VecSlice() {}

    String toDbgString() const;

    const AzU16VecSlice& inner() const { return inner_; }
    AzU16VecSlice& inner() { return inner_; }
    const AzU16VecSlice* ptr() const { return &inner_; }
    AzU16VecSlice* ptr() { return &inner_; }
    AzU16VecSlice release() { AzU16VecSlice result = inner_; inner_ = {}; return result; }
    operator AzU16VecSlice() && noexcept { AzU16VecSlice result = inner_; inner_ = {}; return result; }
};

class AudioMetrics {
private:
    AzAudioMetrics inner_;

public:
    AudioMetrics(AzAudioMetrics inner) noexcept : inner_(inner) {}
    AudioMetrics(const AudioMetrics& other) noexcept : inner_(other.inner_) {}
    AudioMetrics& operator=(const AudioMetrics& other) noexcept { inner_ = other.inner_; return *this; }
    ~AudioMetrics() {}

    [[nodiscard]] static AudioMetrics default_();

    bool partialEq(const AudioMetrics& b) const;
    String toDbgString() const;

    const AzAudioMetrics& inner() const { return inner_; }
    AzAudioMetrics& inner() { return inner_; }
    const AzAudioMetrics* ptr() const { return &inner_; }
    AzAudioMetrics* ptr() { return &inner_; }
    AzAudioMetrics release() { AzAudioMetrics result = inner_; inner_ = {}; return result; }
    operator AzAudioMetrics() && noexcept { AzAudioMetrics result = inner_; inner_ = {}; return result; }
};

class ScrollPhysics {
private:
    AzScrollPhysics inner_;

    ScrollPhysics(const ScrollPhysics&) = delete;
    ScrollPhysics& operator=(const ScrollPhysics&) = delete;

public:
    explicit ScrollPhysics(AzScrollPhysics inner) noexcept : inner_(inner) {}

    ScrollPhysics(ScrollPhysics&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ScrollPhysics& operator=(ScrollPhysics&& other) noexcept {
        if (this != &other) {
            AzScrollPhysics_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ScrollPhysics() { AzScrollPhysics_delete(&inner_); }

    [[nodiscard]] static ScrollPhysics default_();

    void delete_();
    ScrollPhysics clone() const;
    bool partialEq(const ScrollPhysics& b) const;
    uint8_t partialCmp(const ScrollPhysics& b) const;
    String toDbgString() const;

    const AzScrollPhysics& inner() const { return inner_; }
    AzScrollPhysics& inner() { return inner_; }
    const AzScrollPhysics* ptr() const { return &inner_; }
    AzScrollPhysics* ptr() { return &inner_; }
    AzScrollPhysics release() { AzScrollPhysics result = inner_; inner_ = {}; return result; }
    operator AzScrollPhysics() && noexcept { AzScrollPhysics result = inner_; inner_ = {}; return result; }
};

class CalcAstItemVecSlice {
private:
    AzCalcAstItemVecSlice inner_;

public:
    CalcAstItemVecSlice(AzCalcAstItemVecSlice inner) noexcept : inner_(inner) {}
    CalcAstItemVecSlice(const CalcAstItemVecSlice& other) noexcept : inner_(other.inner_) {}
    CalcAstItemVecSlice& operator=(const CalcAstItemVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~CalcAstItemVecSlice() {}

    String toDbgString() const;

    const AzCalcAstItemVecSlice& inner() const { return inner_; }
    AzCalcAstItemVecSlice& inner() { return inner_; }
    const AzCalcAstItemVecSlice* ptr() const { return &inner_; }
    AzCalcAstItemVecSlice* ptr() { return &inner_; }
    AzCalcAstItemVecSlice release() { AzCalcAstItemVecSlice result = inner_; inner_ = {}; return result; }
    operator AzCalcAstItemVecSlice() && noexcept { AzCalcAstItemVecSlice result = inner_; inner_ = {}; return result; }
};

class MinMaxRange {
private:
    AzMinMaxRange inner_;

public:
    MinMaxRange(AzMinMaxRange inner) noexcept : inner_(inner) {}
    MinMaxRange(const MinMaxRange& other) noexcept : inner_(other.inner_) {}
    MinMaxRange& operator=(const MinMaxRange& other) noexcept { inner_ = other.inner_; return *this; }
    ~MinMaxRange() {}

    bool partialEq(const MinMaxRange& b) const;
    uint8_t partialCmp(const MinMaxRange& b) const;
    String toDbgString() const;

    const AzMinMaxRange& inner() const { return inner_; }
    AzMinMaxRange& inner() { return inner_; }
    const AzMinMaxRange* ptr() const { return &inner_; }
    AzMinMaxRange* ptr() { return &inner_; }
    AzMinMaxRange release() { AzMinMaxRange result = inner_; inner_ = {}; return result; }
    operator AzMinMaxRange() && noexcept { AzMinMaxRange result = inner_; inner_ = {}; return result; }
};

class AspectRatioValue {
private:
    AzAspectRatioValue inner_;

public:
    AspectRatioValue(AzAspectRatioValue inner) noexcept : inner_(inner) {}
    AspectRatioValue(const AspectRatioValue& other) noexcept : inner_(other.inner_) {}
    AspectRatioValue& operator=(const AspectRatioValue& other) noexcept { inner_ = other.inner_; return *this; }
    ~AspectRatioValue() {}

    bool partialEq(const AspectRatioValue& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const AspectRatioValue& b) const;
    uint8_t cmp(const AspectRatioValue& b) const;
    String toDbgString() const;

    const AzAspectRatioValue& inner() const { return inner_; }
    AzAspectRatioValue& inner() { return inner_; }
    const AzAspectRatioValue* ptr() const { return &inner_; }
    AzAspectRatioValue* ptr() { return &inner_; }
    AzAspectRatioValue release() { AzAspectRatioValue result = inner_; inner_ = {}; return result; }
    operator AzAspectRatioValue() && noexcept { AzAspectRatioValue result = inner_; inner_ = {}; return result; }
};

class F32VecSlice {
private:
    AzF32VecSlice inner_;

public:
    F32VecSlice(AzF32VecSlice inner) noexcept : inner_(inner) {}
    F32VecSlice(const F32VecSlice& other) noexcept : inner_(other.inner_) {}
    F32VecSlice& operator=(const F32VecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~F32VecSlice() {}

    String toDbgString() const;

    const AzF32VecSlice& inner() const { return inner_; }
    AzF32VecSlice& inner() { return inner_; }
    const AzF32VecSlice* ptr() const { return &inner_; }
    AzF32VecSlice* ptr() { return &inner_; }
    AzF32VecSlice release() { AzF32VecSlice result = inner_; inner_ = {}; return result; }
    operator AzF32VecSlice() && noexcept { AzF32VecSlice result = inner_; inner_ = {}; return result; }
};

class EmptyStruct {
private:
    AzEmptyStruct inner_;

public:
    EmptyStruct(AzEmptyStruct inner) noexcept : inner_(inner) {}
    EmptyStruct(const EmptyStruct& other) noexcept : inner_(other.inner_) {}
    EmptyStruct& operator=(const EmptyStruct& other) noexcept { inner_ = other.inner_; return *this; }
    ~EmptyStruct() {}

    [[nodiscard]] static EmptyStruct create();
    [[nodiscard]] static EmptyStruct default_();

    bool partialEq(const EmptyStruct& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const EmptyStruct& b) const;
    uint8_t cmp(const EmptyStruct& b) const;
    String toDbgString() const;

    const AzEmptyStruct& inner() const { return inner_; }
    AzEmptyStruct& inner() { return inner_; }
    const AzEmptyStruct* ptr() const { return &inner_; }
    AzEmptyStruct* ptr() { return &inner_; }
    AzEmptyStruct release() { AzEmptyStruct result = inner_; inner_ = {}; return result; }
    operator AzEmptyStruct() && noexcept { AzEmptyStruct result = inner_; inner_ = {}; return result; }
};

class U32VecSlice {
private:
    AzU32VecSlice inner_;

public:
    U32VecSlice(AzU32VecSlice inner) noexcept : inner_(inner) {}
    U32VecSlice(const U32VecSlice& other) noexcept : inner_(other.inner_) {}
    U32VecSlice& operator=(const U32VecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~U32VecSlice() {}

    String toDbgString() const;

    const AzU32VecSlice& inner() const { return inner_; }
    AzU32VecSlice& inner() { return inner_; }
    const AzU32VecSlice* ptr() const { return &inner_; }
    AzU32VecSlice* ptr() { return &inner_; }
    AzU32VecSlice release() { AzU32VecSlice result = inner_; inner_ = {}; return result; }
    operator AzU32VecSlice() && noexcept { AzU32VecSlice result = inner_; inner_ = {}; return result; }
};

class DynamicSelectorVecSlice {
private:
    AzDynamicSelectorVecSlice inner_;

public:
    DynamicSelectorVecSlice(AzDynamicSelectorVecSlice inner) noexcept : inner_(inner) {}
    DynamicSelectorVecSlice(const DynamicSelectorVecSlice& other) noexcept : inner_(other.inner_) {}
    DynamicSelectorVecSlice& operator=(const DynamicSelectorVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~DynamicSelectorVecSlice() {}

    String toDbgString() const;

    const AzDynamicSelectorVecSlice& inner() const { return inner_; }
    AzDynamicSelectorVecSlice& inner() { return inner_; }
    const AzDynamicSelectorVecSlice* ptr() const { return &inner_; }
    AzDynamicSelectorVecSlice* ptr() { return &inner_; }
    AzDynamicSelectorVecSlice release() { AzDynamicSelectorVecSlice result = inner_; inner_ = {}; return result; }
    operator AzDynamicSelectorVecSlice() && noexcept { AzDynamicSelectorVecSlice result = inner_; inner_ = {}; return result; }
};

class U8VecSlice {
private:
    AzU8VecSlice inner_;

public:
    U8VecSlice(AzU8VecSlice inner) noexcept : inner_(inner) {}
    U8VecSlice(const U8VecSlice& other) noexcept : inner_(other.inner_) {}
    U8VecSlice& operator=(const U8VecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~U8VecSlice() {}

    String toDbgString() const;

    const AzU8VecSlice& inner() const { return inner_; }
    AzU8VecSlice& inner() { return inner_; }
    const AzU8VecSlice* ptr() const { return &inner_; }
    AzU8VecSlice* ptr() { return &inner_; }
    AzU8VecSlice release() { AzU8VecSlice result = inner_; inner_ = {}; return result; }
    operator AzU8VecSlice() && noexcept { AzU8VecSlice result = inner_; inner_ = {}; return result; }
};

class MapTileId {
private:
    AzMapTileId inner_;

public:
    MapTileId(AzMapTileId inner) noexcept : inner_(inner) {}
    MapTileId(const MapTileId& other) noexcept : inner_(other.inner_) {}
    MapTileId& operator=(const MapTileId& other) noexcept { inner_ = other.inner_; return *this; }
    ~MapTileId() {}

    bool partialEq(const MapTileId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const MapTileId& b) const;
    uint8_t cmp(const MapTileId& b) const;
    String toDbgString() const;

    const AzMapTileId& inner() const { return inner_; }
    AzMapTileId& inner() { return inner_; }
    const AzMapTileId* ptr() const { return &inner_; }
    AzMapTileId* ptr() { return &inner_; }
    AzMapTileId release() { AzMapTileId result = inner_; inner_ = {}; return result; }
    operator AzMapTileId() && noexcept { AzMapTileId result = inner_; inner_ = {}; return result; }
};

class MapViewport {
private:
    AzMapViewport inner_;

public:
    MapViewport(AzMapViewport inner) noexcept : inner_(inner) {}
    MapViewport(const MapViewport& other) noexcept : inner_(other.inner_) {}
    MapViewport& operator=(const MapViewport& other) noexcept { inner_ = other.inner_; return *this; }
    ~MapViewport() {}

    [[nodiscard]] static MapViewport default_();

    bool partialEq(const MapViewport& b) const;
    String toDbgString() const;

    const AzMapViewport& inner() const { return inner_; }
    AzMapViewport& inner() { return inner_; }
    const AzMapViewport* ptr() const { return &inner_; }
    AzMapViewport* ptr() { return &inner_; }
    AzMapViewport release() { AzMapViewport result = inner_; inner_ = {}; return result; }
    operator AzMapViewport() && noexcept { AzMapViewport result = inner_; inner_ = {}; return result; }
};

class CheckBoxState {
private:
    AzCheckBoxState inner_;

    CheckBoxState(const CheckBoxState&) = delete;
    CheckBoxState& operator=(const CheckBoxState&) = delete;

public:
    explicit CheckBoxState(AzCheckBoxState inner) noexcept : inner_(inner) {}

    CheckBoxState(CheckBoxState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CheckBoxState& operator=(CheckBoxState&& other) noexcept {
        if (this != &other) {
            AzCheckBoxState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CheckBoxState() { AzCheckBoxState_delete(&inner_); }

    [[nodiscard]] static CheckBoxState default_();

    void delete_();
    CheckBoxState clone() const;
    bool partialEq(const CheckBoxState& b) const;
    String toDbgString() const;

    const AzCheckBoxState& inner() const { return inner_; }
    AzCheckBoxState& inner() { return inner_; }
    const AzCheckBoxState* ptr() const { return &inner_; }
    AzCheckBoxState* ptr() { return &inner_; }
    AzCheckBoxState release() { AzCheckBoxState result = inner_; inner_ = {}; return result; }
    operator AzCheckBoxState() && noexcept { AzCheckBoxState result = inner_; inner_ = {}; return result; }
};

class NumberInputState {
private:
    AzNumberInputState inner_;

    NumberInputState(const NumberInputState&) = delete;
    NumberInputState& operator=(const NumberInputState&) = delete;

public:
    explicit NumberInputState(AzNumberInputState inner) noexcept : inner_(inner) {}

    NumberInputState(NumberInputState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NumberInputState& operator=(NumberInputState&& other) noexcept {
        if (this != &other) {
            AzNumberInputState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NumberInputState() { AzNumberInputState_delete(&inner_); }

    [[nodiscard]] static NumberInputState default_();

    void delete_();
    NumberInputState clone() const;
    bool partialEq(const NumberInputState& b) const;
    String toDbgString() const;

    const AzNumberInputState& inner() const { return inner_; }
    AzNumberInputState& inner() { return inner_; }
    const AzNumberInputState* ptr() const { return &inner_; }
    AzNumberInputState* ptr() { return &inner_; }
    AzNumberInputState release() { AzNumberInputState result = inner_; inner_ = {}; return result; }
    operator AzNumberInputState() && noexcept { AzNumberInputState result = inner_; inner_ = {}; return result; }
};

class ProgressBarState {
private:
    AzProgressBarState inner_;

    ProgressBarState(const ProgressBarState&) = delete;
    ProgressBarState& operator=(const ProgressBarState&) = delete;

public:
    explicit ProgressBarState(AzProgressBarState inner) noexcept : inner_(inner) {}

    ProgressBarState(ProgressBarState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ProgressBarState& operator=(ProgressBarState&& other) noexcept {
        if (this != &other) {
            AzProgressBarState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ProgressBarState() { AzProgressBarState_delete(&inner_); }

    void delete_();
    ProgressBarState clone() const;
    String toDbgString() const;

    const AzProgressBarState& inner() const { return inner_; }
    AzProgressBarState& inner() { return inner_; }
    const AzProgressBarState* ptr() const { return &inner_; }
    AzProgressBarState* ptr() { return &inner_; }
    AzProgressBarState release() { AzProgressBarState result = inner_; inner_ = {}; return result; }
    operator AzProgressBarState() && noexcept { AzProgressBarState result = inner_; inner_ = {}; return result; }
};

class TabHeaderState {
private:
    AzTabHeaderState inner_;

public:
    TabHeaderState(AzTabHeaderState inner) noexcept : inner_(inner) {}
    TabHeaderState(const TabHeaderState& other) noexcept : inner_(other.inner_) {}
    TabHeaderState& operator=(const TabHeaderState& other) noexcept { inner_ = other.inner_; return *this; }
    ~TabHeaderState() {}

    bool partialEq(const TabHeaderState& b) const;
    String toDbgString() const;

    const AzTabHeaderState& inner() const { return inner_; }
    AzTabHeaderState& inner() { return inner_; }
    const AzTabHeaderState* ptr() const { return &inner_; }
    AzTabHeaderState* ptr() { return &inner_; }
    AzTabHeaderState release() { AzTabHeaderState result = inner_; inner_ = {}; return result; }
    operator AzTabHeaderState() && noexcept { AzTabHeaderState result = inner_; inner_ = {}; return result; }
};

class ListViewRowVecSlice {
private:
    AzListViewRowVecSlice inner_;

public:
    ListViewRowVecSlice(AzListViewRowVecSlice inner) noexcept : inner_(inner) {}
    ListViewRowVecSlice(const ListViewRowVecSlice& other) noexcept : inner_(other.inner_) {}
    ListViewRowVecSlice& operator=(const ListViewRowVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ListViewRowVecSlice() {}

    String toDbgString() const;

    const AzListViewRowVecSlice& inner() const { return inner_; }
    AzListViewRowVecSlice& inner() { return inner_; }
    const AzListViewRowVecSlice* ptr() const { return &inner_; }
    AzListViewRowVecSlice* ptr() { return &inner_; }
    AzListViewRowVecSlice release() { AzListViewRowVecSlice result = inner_; inner_ = {}; return result; }
    operator AzListViewRowVecSlice() && noexcept { AzListViewRowVecSlice result = inner_; inner_ = {}; return result; }
};

class TitlebarButtons {
private:
    AzTitlebarButtons inner_;

public:
    TitlebarButtons(AzTitlebarButtons inner) noexcept : inner_(inner) {}
    TitlebarButtons(const TitlebarButtons& other) noexcept : inner_(other.inner_) {}
    TitlebarButtons& operator=(const TitlebarButtons& other) noexcept { inner_ = other.inner_; return *this; }
    ~TitlebarButtons() {}

    [[nodiscard]] static TitlebarButtons default_();

    bool partialEq(const TitlebarButtons& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TitlebarButtons& b) const;
    uint8_t cmp(const TitlebarButtons& b) const;
    String toDbgString() const;

    const AzTitlebarButtons& inner() const { return inner_; }
    AzTitlebarButtons& inner() { return inner_; }
    const AzTitlebarButtons* ptr() const { return &inner_; }
    AzTitlebarButtons* ptr() { return &inner_; }
    AzTitlebarButtons release() { AzTitlebarButtons result = inner_; inner_ = {}; return result; }
    operator AzTitlebarButtons() && noexcept { AzTitlebarButtons result = inner_; inner_ = {}; return result; }
};

class RibbonSectionVecSlice {
private:
    AzRibbonSectionVecSlice inner_;

public:
    RibbonSectionVecSlice(AzRibbonSectionVecSlice inner) noexcept : inner_(inner) {}
    RibbonSectionVecSlice(const RibbonSectionVecSlice& other) noexcept : inner_(other.inner_) {}
    RibbonSectionVecSlice& operator=(const RibbonSectionVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~RibbonSectionVecSlice() {}

    String toDbgString() const;

    const AzRibbonSectionVecSlice& inner() const { return inner_; }
    AzRibbonSectionVecSlice& inner() { return inner_; }
    const AzRibbonSectionVecSlice* ptr() const { return &inner_; }
    AzRibbonSectionVecSlice* ptr() { return &inner_; }
    AzRibbonSectionVecSlice release() { AzRibbonSectionVecSlice result = inner_; inner_ = {}; return result; }
    operator AzRibbonSectionVecSlice() && noexcept { AzRibbonSectionVecSlice result = inner_; inner_ = {}; return result; }
};

class RibbonTabVecSlice {
private:
    AzRibbonTabVecSlice inner_;

public:
    RibbonTabVecSlice(AzRibbonTabVecSlice inner) noexcept : inner_(inner) {}
    RibbonTabVecSlice(const RibbonTabVecSlice& other) noexcept : inner_(other.inner_) {}
    RibbonTabVecSlice& operator=(const RibbonTabVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~RibbonTabVecSlice() {}

    String toDbgString() const;

    const AzRibbonTabVecSlice& inner() const { return inner_; }
    AzRibbonTabVecSlice& inner() { return inner_; }
    const AzRibbonTabVecSlice* ptr() const { return &inner_; }
    AzRibbonTabVecSlice* ptr() { return &inner_; }
    AzRibbonTabVecSlice release() { AzRibbonTabVecSlice result = inner_; inner_ = {}; return result; }
    operator AzRibbonTabVecSlice() && noexcept { AzRibbonTabVecSlice result = inner_; inner_ = {}; return result; }
};

class TreeViewNodeVecSlice {
private:
    AzTreeViewNodeVecSlice inner_;

public:
    TreeViewNodeVecSlice(AzTreeViewNodeVecSlice inner) noexcept : inner_(inner) {}
    TreeViewNodeVecSlice(const TreeViewNodeVecSlice& other) noexcept : inner_(other.inner_) {}
    TreeViewNodeVecSlice& operator=(const TreeViewNodeVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~TreeViewNodeVecSlice() {}

    String toDbgString() const;

    const AzTreeViewNodeVecSlice& inner() const { return inner_; }
    AzTreeViewNodeVecSlice& inner() { return inner_; }
    const AzTreeViewNodeVecSlice* ptr() const { return &inner_; }
    AzTreeViewNodeVecSlice* ptr() { return &inner_; }
    AzTreeViewNodeVecSlice release() { AzTreeViewNodeVecSlice result = inner_; inner_ = {}; return result; }
    operator AzTreeViewNodeVecSlice() && noexcept { AzTreeViewNodeVecSlice result = inner_; inner_ = {}; return result; }
};

class MapLatLon {
private:
    AzMapLatLon inner_;

public:
    MapLatLon(AzMapLatLon inner) noexcept : inner_(inner) {}
    MapLatLon(const MapLatLon& other) noexcept : inner_(other.inner_) {}
    MapLatLon& operator=(const MapLatLon& other) noexcept { inner_ = other.inner_; return *this; }
    ~MapLatLon() {}

    bool partialEq(const MapLatLon& b) const;
    String toDbgString() const;

    const AzMapLatLon& inner() const { return inner_; }
    AzMapLatLon& inner() { return inner_; }
    const AzMapLatLon* ptr() const { return &inner_; }
    AzMapLatLon* ptr() { return &inner_; }
    AzMapLatLon release() { AzMapLatLon result = inner_; inner_ = {}; return result; }
    operator AzMapLatLon() && noexcept { AzMapLatLon result = inner_; inner_ = {}; return result; }
};

class GlVoidPtrConst {
private:
    AzGlVoidPtrConst inner_;

    GlVoidPtrConst(const GlVoidPtrConst&) = delete;
    GlVoidPtrConst& operator=(const GlVoidPtrConst&) = delete;

public:
    explicit GlVoidPtrConst(AzGlVoidPtrConst inner) noexcept : inner_(inner) {}

    GlVoidPtrConst(GlVoidPtrConst&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GlVoidPtrConst& operator=(GlVoidPtrConst&& other) noexcept {
        if (this != &other) {
            AzGlVoidPtrConst_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GlVoidPtrConst() { AzGlVoidPtrConst_delete(&inner_); }

    void delete_();
    GlVoidPtrConst clone() const;
    String toDbgString() const;

    const AzGlVoidPtrConst& inner() const { return inner_; }
    AzGlVoidPtrConst& inner() { return inner_; }
    const AzGlVoidPtrConst* ptr() const { return &inner_; }
    AzGlVoidPtrConst* ptr() { return &inner_; }
    AzGlVoidPtrConst release() { AzGlVoidPtrConst result = inner_; inner_ = {}; return result; }
    operator AzGlVoidPtrConst() && noexcept { AzGlVoidPtrConst result = inner_; inner_ = {}; return result; }
};

class GlVoidPtrMut {
private:
    AzGlVoidPtrMut inner_;

    GlVoidPtrMut(const GlVoidPtrMut&) = delete;
    GlVoidPtrMut& operator=(const GlVoidPtrMut&) = delete;

public:
    explicit GlVoidPtrMut(AzGlVoidPtrMut inner) noexcept : inner_(inner) {}

    GlVoidPtrMut(GlVoidPtrMut&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GlVoidPtrMut& operator=(GlVoidPtrMut&& other) noexcept {
        if (this != &other) {
            AzGlVoidPtrMut_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GlVoidPtrMut() { AzGlVoidPtrMut_delete(&inner_); }

    void delete_();
    GlVoidPtrMut clone() const;
    String toDbgString() const;

    const AzGlVoidPtrMut& inner() const { return inner_; }
    AzGlVoidPtrMut& inner() { return inner_; }
    const AzGlVoidPtrMut* ptr() const { return &inner_; }
    AzGlVoidPtrMut* ptr() { return &inner_; }
    AzGlVoidPtrMut release() { AzGlVoidPtrMut result = inner_; inner_ = {}; return result; }
    operator AzGlVoidPtrMut() && noexcept { AzGlVoidPtrMut result = inner_; inner_ = {}; return result; }
};

class TextureFlags {
private:
    AzTextureFlags inner_;

public:
    TextureFlags(AzTextureFlags inner) noexcept : inner_(inner) {}
    TextureFlags(const TextureFlags& other) noexcept : inner_(other.inner_) {}
    TextureFlags& operator=(const TextureFlags& other) noexcept { inner_ = other.inner_; return *this; }
    ~TextureFlags() {}

    [[nodiscard]] static TextureFlags default_();

    bool partialEq(const TextureFlags& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TextureFlags& b) const;
    uint8_t cmp(const TextureFlags& b) const;
    String toDbgString() const;

    const AzTextureFlags& inner() const { return inner_; }
    AzTextureFlags& inner() { return inner_; }
    const AzTextureFlags* ptr() const { return &inner_; }
    AzTextureFlags* ptr() { return &inner_; }
    AzTextureFlags release() { AzTextureFlags result = inner_; inner_ = {}; return result; }
    operator AzTextureFlags() && noexcept { AzTextureFlags result = inner_; inner_ = {}; return result; }
};

class GLsyncPtr {
private:
    AzGLsyncPtr inner_;

    GLsyncPtr(const GLsyncPtr&) = delete;
    GLsyncPtr& operator=(const GLsyncPtr&) = delete;

public:
    explicit GLsyncPtr(AzGLsyncPtr inner) noexcept : inner_(inner) {}

    GLsyncPtr(GLsyncPtr&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GLsyncPtr& operator=(GLsyncPtr&& other) noexcept {
        if (this != &other) {
            AzGLsyncPtr_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GLsyncPtr() { AzGLsyncPtr_delete(&inner_); }

    void delete_();
    GLsyncPtr clone() const;
    String toDbgString() const;

    const AzGLsyncPtr& inner() const { return inner_; }
    AzGLsyncPtr& inner() { return inner_; }
    const AzGLsyncPtr* ptr() const { return &inner_; }
    AzGLsyncPtr* ptr() { return &inner_; }
    AzGLsyncPtr release() { AzGLsyncPtr result = inner_; inner_ = {}; return result; }
    operator AzGLsyncPtr() && noexcept { AzGLsyncPtr result = inner_; inner_ = {}; return result; }
};

class SvgVertex {
private:
    AzSvgVertex inner_;

public:
    SvgVertex(AzSvgVertex inner) noexcept : inner_(inner) {}
    SvgVertex(const SvgVertex& other) noexcept : inner_(other.inner_) {}
    SvgVertex& operator=(const SvgVertex& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgVertex() {}

    bool partialEq(const SvgVertex& b) const;
    uint8_t partialCmp(const SvgVertex& b) const;
    String toDbgString() const;

    const AzSvgVertex& inner() const { return inner_; }
    AzSvgVertex& inner() { return inner_; }
    const AzSvgVertex* ptr() const { return &inner_; }
    AzSvgVertex* ptr() { return &inner_; }
    AzSvgVertex release() { AzSvgVertex result = inner_; inner_ = {}; return result; }
    operator AzSvgVertex() && noexcept { AzSvgVertex result = inner_; inner_ = {}; return result; }
};

class SvgVertexVecSlice {
private:
    AzSvgVertexVecSlice inner_;

public:
    SvgVertexVecSlice(AzSvgVertexVecSlice inner) noexcept : inner_(inner) {}
    SvgVertexVecSlice(const SvgVertexVecSlice& other) noexcept : inner_(other.inner_) {}
    SvgVertexVecSlice& operator=(const SvgVertexVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgVertexVecSlice() {}

    String toDbgString() const;

    const AzSvgVertexVecSlice& inner() const { return inner_; }
    AzSvgVertexVecSlice& inner() { return inner_; }
    const AzSvgVertexVecSlice* ptr() const { return &inner_; }
    AzSvgVertexVecSlice* ptr() { return &inner_; }
    AzSvgVertexVecSlice release() { AzSvgVertexVecSlice result = inner_; inner_ = {}; return result; }
    operator AzSvgVertexVecSlice() && noexcept { AzSvgVertexVecSlice result = inner_; inner_ = {}; return result; }
};

class DebugMessageVecSlice {
private:
    AzDebugMessageVecSlice inner_;

public:
    DebugMessageVecSlice(AzDebugMessageVecSlice inner) noexcept : inner_(inner) {}
    DebugMessageVecSlice(const DebugMessageVecSlice& other) noexcept : inner_(other.inner_) {}
    DebugMessageVecSlice& operator=(const DebugMessageVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~DebugMessageVecSlice() {}

    String toDbgString() const;

    const AzDebugMessageVecSlice& inner() const { return inner_; }
    AzDebugMessageVecSlice& inner() { return inner_; }
    const AzDebugMessageVecSlice* ptr() const { return &inner_; }
    AzDebugMessageVecSlice* ptr() { return &inner_; }
    AzDebugMessageVecSlice release() { AzDebugMessageVecSlice result = inner_; inner_ = {}; return result; }
    operator AzDebugMessageVecSlice() && noexcept { AzDebugMessageVecSlice result = inner_; inner_ = {}; return result; }
};

class ImageRef {
private:
    AzImageRef inner_;

    ImageRef(const ImageRef&) = delete;
    ImageRef& operator=(const ImageRef&) = delete;

public:
    explicit ImageRef(AzImageRef inner) noexcept : inner_(inner) {}

    ImageRef(ImageRef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ImageRef& operator=(ImageRef&& other) noexcept {
        if (this != &other) {
            AzImageRef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ImageRef() { AzImageRef_delete(&inner_); }

    [[nodiscard]] static ImageRef gl_texture(Texture texture);
    [[nodiscard]] static ImageRef callback(CoreRenderImageCallback callback, RefAny data);
    [[nodiscard]] static ImageRef new_gltexture(Texture texture);
    [[nodiscard]] static ImageRef null_image(size_t width, size_t height, AzRawImageFormat format, U8VecRef tag);
    [[nodiscard]] static OptionImageRef raw_image(RawImage data);
    [[nodiscard]] static OptionImageRef new_rawimage(RawImage image_data);

    bool is_invalid() const;
    bool is_gl_texture() const;
    bool is_raw_image() const;
    bool is_callback() const;
    OptionRawImage get_raw_image() const;
    bool is_null_image() const;
    OptionRawImage get_rawimage() const;
    OptionU8VecRef get_bytes() const;
    LogicalSize get_size() const;
    ImageRefHash get_hash() const;
    OptionCoreImageCallback get_image_callback() const;
    OptionCoreImageCallback get_image_callback_mut();
    ImageRef deep_copy() const;
    const uint8_t* get_bytes_ptr() const;
    void delete_();
    ImageRef clone() const;
    bool partialEq(const ImageRef& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ImageRef& b) const;
    uint8_t cmp(const ImageRef& b) const;
    String toDbgString() const;

    const AzImageRef& inner() const { return inner_; }
    AzImageRef& inner() { return inner_; }
    const AzImageRef* ptr() const { return &inner_; }
    AzImageRef* ptr() { return &inner_; }
    AzImageRef release() { AzImageRef result = inner_; inner_ = {}; return result; }
    operator AzImageRef() && noexcept { AzImageRef result = inner_; inner_ = {}; return result; }
};

class ImageDescriptorFlags {
private:
    AzImageDescriptorFlags inner_;

public:
    ImageDescriptorFlags(AzImageDescriptorFlags inner) noexcept : inner_(inner) {}
    ImageDescriptorFlags(const ImageDescriptorFlags& other) noexcept : inner_(other.inner_) {}
    ImageDescriptorFlags& operator=(const ImageDescriptorFlags& other) noexcept { inner_ = other.inner_; return *this; }
    ~ImageDescriptorFlags() {}

    bool partialEq(const ImageDescriptorFlags& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ImageDescriptorFlags& b) const;
    uint8_t cmp(const ImageDescriptorFlags& b) const;
    String toDbgString() const;

    const AzImageDescriptorFlags& inner() const { return inner_; }
    AzImageDescriptorFlags& inner() { return inner_; }
    const AzImageDescriptorFlags* ptr() const { return &inner_; }
    AzImageDescriptorFlags* ptr() { return &inner_; }
    AzImageDescriptorFlags release() { AzImageDescriptorFlags result = inner_; inner_ = {}; return result; }
    operator AzImageDescriptorFlags() && noexcept { AzImageDescriptorFlags result = inner_; inner_ = {}; return result; }
};

class ImageRefHash {
private:
    AzImageRefHash inner_;

public:
    ImageRefHash(AzImageRefHash inner) noexcept : inner_(inner) {}
    ImageRefHash(const ImageRefHash& other) noexcept : inner_(other.inner_) {}
    ImageRefHash& operator=(const ImageRefHash& other) noexcept { inner_ = other.inner_; return *this; }
    ~ImageRefHash() {}

    bool partialEq(const ImageRefHash& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ImageRefHash& b) const;
    uint8_t cmp(const ImageRefHash& b) const;
    String toDbgString() const;

    const AzImageRefHash& inner() const { return inner_; }
    AzImageRefHash& inner() { return inner_; }
    const AzImageRefHash* ptr() const { return &inner_; }
    AzImageRefHash* ptr() { return &inner_; }
    AzImageRefHash release() { AzImageRefHash result = inner_; inner_ = {}; return result; }
    operator AzImageRefHash() && noexcept { AzImageRefHash result = inner_; inner_ = {}; return result; }
};

class RouteVecSlice {
private:
    AzRouteVecSlice inner_;

public:
    RouteVecSlice(AzRouteVecSlice inner) noexcept : inner_(inner) {}
    RouteVecSlice(const RouteVecSlice& other) noexcept : inner_(other.inner_) {}
    RouteVecSlice& operator=(const RouteVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~RouteVecSlice() {}

    String toDbgString() const;

    const AzRouteVecSlice& inner() const { return inner_; }
    AzRouteVecSlice& inner() { return inner_; }
    const AzRouteVecSlice* ptr() const { return &inner_; }
    AzRouteVecSlice* ptr() { return &inner_; }
    AzRouteVecSlice release() { AzRouteVecSlice result = inner_; inner_ = {}; return result; }
    operator AzRouteVecSlice() && noexcept { AzRouteVecSlice result = inner_; inner_ = {}; return result; }
};

class VideoEncoder {
private:
    AzVideoEncoder inner_;

    VideoEncoder(const VideoEncoder&) = delete;
    VideoEncoder& operator=(const VideoEncoder&) = delete;

public:
    explicit VideoEncoder(AzVideoEncoder inner) noexcept : inner_(inner) {}

    VideoEncoder(VideoEncoder&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VideoEncoder& operator=(VideoEncoder&& other) noexcept {
        if (this != &other) {
            AzVideoEncoder_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VideoEncoder() { AzVideoEncoder_delete(&inner_); }

    [[nodiscard]] static VideoEncoder open(uint32_t width, uint32_t height, bool h265, uint32_t bitrate_kbps);
    [[nodiscard]] static VideoEncoder default_();

    static String backend_name();
    bool is_open() const;
    U8Vec encode(VideoFrame frame, bool force_keyframe) const;
    uint64_t frames_encoded() const;
    void close();
    void delete_();
    VideoEncoder clone() const;

    const AzVideoEncoder& inner() const { return inner_; }
    AzVideoEncoder& inner() { return inner_; }
    const AzVideoEncoder* ptr() const { return &inner_; }
    AzVideoEncoder* ptr() { return &inner_; }
    AzVideoEncoder release() { AzVideoEncoder result = inner_; inner_ = {}; return result; }
    operator AzVideoEncoder() && noexcept { AzVideoEncoder result = inner_; inner_ = {}; return result; }
};

class VideoDecoder {
private:
    AzVideoDecoder inner_;

    VideoDecoder(const VideoDecoder&) = delete;
    VideoDecoder& operator=(const VideoDecoder&) = delete;

public:
    explicit VideoDecoder(AzVideoDecoder inner) noexcept : inner_(inner) {}

    VideoDecoder(VideoDecoder&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VideoDecoder& operator=(VideoDecoder&& other) noexcept {
        if (this != &other) {
            AzVideoDecoder_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VideoDecoder() { AzVideoDecoder_delete(&inner_); }

    [[nodiscard]] static VideoDecoder open(bool h265);
    [[nodiscard]] static VideoDecoder default_();

    bool is_open() const;
    OptionVideoFrame decode(U8Vec data) const;
    void close();
    void delete_();
    VideoDecoder clone() const;

    const AzVideoDecoder& inner() const { return inner_; }
    AzVideoDecoder& inner() { return inner_; }
    const AzVideoDecoder* ptr() const { return &inner_; }
    AzVideoDecoder* ptr() { return &inner_; }
    AzVideoDecoder release() { AzVideoDecoder result = inner_; inner_ = {}; return result; }
    operator AzVideoDecoder() && noexcept { AzVideoDecoder result = inner_; inner_ = {}; return result; }
};

class Panose {
private:
    AzPanose inner_;

public:
    Panose(AzPanose inner) noexcept : inner_(inner) {}
    Panose(const Panose& other) noexcept : inner_(other.inner_) {}
    Panose& operator=(const Panose& other) noexcept { inner_ = other.inner_; return *this; }
    ~Panose() {}

    [[nodiscard]] static Panose default_();

    bool partialEq(const Panose& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const Panose& b) const;
    uint8_t cmp(const Panose& b) const;
    String toDbgString() const;

    const AzPanose& inner() const { return inner_; }
    AzPanose& inner() { return inner_; }
    const AzPanose* ptr() const { return &inner_; }
    AzPanose* ptr() { return &inner_; }
    AzPanose release() { AzPanose result = inner_; inner_ = {}; return result; }
    operator AzPanose() && noexcept { AzPanose result = inner_; inner_ = {}; return result; }
};

class LoadedFontVecSlice {
private:
    AzLoadedFontVecSlice inner_;

public:
    LoadedFontVecSlice(AzLoadedFontVecSlice inner) noexcept : inner_(inner) {}
    LoadedFontVecSlice(const LoadedFontVecSlice& other) noexcept : inner_(other.inner_) {}
    LoadedFontVecSlice& operator=(const LoadedFontVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~LoadedFontVecSlice() {}

    String toDbgString() const;

    const AzLoadedFontVecSlice& inner() const { return inner_; }
    AzLoadedFontVecSlice& inner() { return inner_; }
    const AzLoadedFontVecSlice* ptr() const { return &inner_; }
    AzLoadedFontVecSlice* ptr() { return &inner_; }
    AzLoadedFontVecSlice release() { AzLoadedFontVecSlice result = inner_; inner_ = {}; return result; }
    operator AzLoadedFontVecSlice() && noexcept { AzLoadedFontVecSlice result = inner_; inner_ = {}; return result; }
};

class Svg {
private:
    AzSvg inner_;

    Svg(const Svg&) = delete;
    Svg& operator=(const Svg&) = delete;

public:
    explicit Svg(AzSvg inner) noexcept : inner_(inner) {}

    Svg(Svg&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Svg& operator=(Svg&& other) noexcept {
        if (this != &other) {
            AzSvg_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Svg() { AzSvg_delete(&inner_); }
    [[nodiscard]] static ResultSvgSvgParseError from_string(String svg_string, SvgParseOptions parse_options);
    [[nodiscard]] static ResultSvgSvgParseError from_bytes(U8VecRef svg_bytes, SvgParseOptions parse_options);

    void delete_();
    Svg clone() const;
    String toDbgString() const;

    const AzSvg& inner() const { return inner_; }
    AzSvg& inner() { return inner_; }
    const AzSvg* ptr() const { return &inner_; }
    AzSvg* ptr() { return &inner_; }
    AzSvg release() { AzSvg result = inner_; inner_ = {}; return result; }
    operator AzSvg() && noexcept { AzSvg result = inner_; inner_ = {}; return result; }
};

class CssPathSelectorVecSlice {
private:
    AzCssPathSelectorVecSlice inner_;

public:
    CssPathSelectorVecSlice(AzCssPathSelectorVecSlice inner) noexcept : inner_(inner) {}
    CssPathSelectorVecSlice(const CssPathSelectorVecSlice& other) noexcept : inner_(other.inner_) {}
    CssPathSelectorVecSlice& operator=(const CssPathSelectorVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~CssPathSelectorVecSlice() {}

    String toDbgString() const;

    const AzCssPathSelectorVecSlice& inner() const { return inner_; }
    AzCssPathSelectorVecSlice& inner() { return inner_; }
    const AzCssPathSelectorVecSlice* ptr() const { return &inner_; }
    AzCssPathSelectorVecSlice* ptr() { return &inner_; }
    AzCssPathSelectorVecSlice release() { AzCssPathSelectorVecSlice result = inner_; inner_ = {}; return result; }
    operator AzCssPathSelectorVecSlice() && noexcept { AzCssPathSelectorVecSlice result = inner_; inner_ = {}; return result; }
};

class SvgDashPattern {
private:
    AzSvgDashPattern inner_;

public:
    SvgDashPattern(AzSvgDashPattern inner) noexcept : inner_(inner) {}
    SvgDashPattern(const SvgDashPattern& other) noexcept : inner_(other.inner_) {}
    SvgDashPattern& operator=(const SvgDashPattern& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgDashPattern() {}

    bool partialEq(const SvgDashPattern& b) const;
    uint8_t partialCmp(const SvgDashPattern& b) const;
    String toDbgString() const;

    const AzSvgDashPattern& inner() const { return inner_; }
    AzSvgDashPattern& inner() { return inner_; }
    const AzSvgDashPattern* ptr() const { return &inner_; }
    AzSvgDashPattern* ptr() { return &inner_; }
    AzSvgDashPattern release() { AzSvgDashPattern result = inner_; inner_ = {}; return result; }
    operator AzSvgDashPattern() && noexcept { AzSvgDashPattern result = inner_; inner_ = {}; return result; }
};

class SvgVector {
private:
    AzSvgVector inner_;

public:
    SvgVector(AzSvgVector inner) noexcept : inner_(inner) {}
    SvgVector(const SvgVector& other) noexcept : inner_(other.inner_) {}
    SvgVector& operator=(const SvgVector& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgVector() {}

    double angle_degrees() const;
    SvgVector rotate_90deg_ccw() const;
    bool partialEq(const SvgVector& b) const;
    uint8_t partialCmp(const SvgVector& b) const;
    String toDbgString() const;

    const AzSvgVector& inner() const { return inner_; }
    AzSvgVector& inner() { return inner_; }
    const AzSvgVector* ptr() const { return &inner_; }
    AzSvgVector* ptr() { return &inner_; }
    AzSvgVector release() { AzSvgVector result = inner_; inner_ = {}; return result; }
    operator AzSvgVector() && noexcept { AzSvgVector result = inner_; inner_ = {}; return result; }
};

class SvgRect {
private:
    AzSvgRect inner_;

public:
    SvgRect(AzSvgRect inner) noexcept : inner_(inner) {}
    SvgRect(const SvgRect& other) noexcept : inner_(other.inner_) {}
    SvgRect& operator=(const SvgRect& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgRect() {}

    [[nodiscard]] static SvgRect default_();

    SvgRect expand(float padding_top, float padding_bottom, float padding_left, float padding_right) const;
    SvgPoint get_center() const;
    bool partialEq(const SvgRect& b) const;
    uint8_t partialCmp(const SvgRect& b) const;
    String toDbgString() const;

    const AzSvgRect& inner() const { return inner_; }
    AzSvgRect& inner() { return inner_; }
    const AzSvgRect* ptr() const { return &inner_; }
    AzSvgRect* ptr() { return &inner_; }
    AzSvgRect release() { AzSvgRect result = inner_; inner_ = {}; return result; }
    operator AzSvgRect() && noexcept { AzSvgRect result = inner_; inner_ = {}; return result; }
};

class SvgPoint {
private:
    AzSvgPoint inner_;

public:
    SvgPoint(AzSvgPoint inner) noexcept : inner_(inner) {}
    SvgPoint(const SvgPoint& other) noexcept : inner_(other.inner_) {}
    SvgPoint& operator=(const SvgPoint& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgPoint() {}

    [[nodiscard]] static SvgPoint default_();

    bool partialEq(const SvgPoint& b) const;
    uint8_t partialCmp(const SvgPoint& b) const;
    String toDbgString() const;

    const AzSvgPoint& inner() const { return inner_; }
    AzSvgPoint& inner() { return inner_; }
    const AzSvgPoint* ptr() const { return &inner_; }
    AzSvgPoint* ptr() { return &inner_; }
    AzSvgPoint release() { AzSvgPoint result = inner_; inner_ = {}; return result; }
    operator AzSvgPoint() && noexcept { AzSvgPoint result = inner_; inner_ = {}; return result; }
};

class SvgPathVecSlice {
private:
    AzSvgPathVecSlice inner_;

public:
    SvgPathVecSlice(AzSvgPathVecSlice inner) noexcept : inner_(inner) {}
    SvgPathVecSlice(const SvgPathVecSlice& other) noexcept : inner_(other.inner_) {}
    SvgPathVecSlice& operator=(const SvgPathVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgPathVecSlice() {}

    String toDbgString() const;

    const AzSvgPathVecSlice& inner() const { return inner_; }
    AzSvgPathVecSlice& inner() { return inner_; }
    const AzSvgPathVecSlice* ptr() const { return &inner_; }
    AzSvgPathVecSlice* ptr() { return &inner_; }
    AzSvgPathVecSlice release() { AzSvgPathVecSlice result = inner_; inner_ = {}; return result; }
    operator AzSvgPathVecSlice() && noexcept { AzSvgPathVecSlice result = inner_; inner_ = {}; return result; }
};

class SvgPathElementVecSlice {
private:
    AzSvgPathElementVecSlice inner_;

public:
    SvgPathElementVecSlice(AzSvgPathElementVecSlice inner) noexcept : inner_(inner) {}
    SvgPathElementVecSlice(const SvgPathElementVecSlice& other) noexcept : inner_(other.inner_) {}
    SvgPathElementVecSlice& operator=(const SvgPathElementVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgPathElementVecSlice() {}

    String toDbgString() const;

    const AzSvgPathElementVecSlice& inner() const { return inner_; }
    AzSvgPathElementVecSlice& inner() { return inner_; }
    const AzSvgPathElementVecSlice* ptr() const { return &inner_; }
    AzSvgPathElementVecSlice* ptr() { return &inner_; }
    AzSvgPathElementVecSlice release() { AzSvgPathElementVecSlice result = inner_; inner_ = {}; return result; }
    operator AzSvgPathElementVecSlice() && noexcept { AzSvgPathElementVecSlice result = inner_; inner_ = {}; return result; }
};

class SystemTickDiff {
private:
    AzSystemTickDiff inner_;

public:
    SystemTickDiff(AzSystemTickDiff inner) noexcept : inner_(inner) {}
    SystemTickDiff(const SystemTickDiff& other) noexcept : inner_(other.inner_) {}
    SystemTickDiff& operator=(const SystemTickDiff& other) noexcept { inner_ = other.inner_; return *this; }
    ~SystemTickDiff() {}

    double div(SystemTickDiff other) const;
    bool partialEq(const SystemTickDiff& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const SystemTickDiff& b) const;
    uint8_t cmp(const SystemTickDiff& b) const;
    String toDbgString() const;

    const AzSystemTickDiff& inner() const { return inner_; }
    AzSystemTickDiff& inner() { return inner_; }
    const AzSystemTickDiff* ptr() const { return &inner_; }
    AzSystemTickDiff* ptr() { return &inner_; }
    AzSystemTickDiff release() { AzSystemTickDiff result = inner_; inner_ = {}; return result; }
    operator AzSystemTickDiff() && noexcept { AzSystemTickDiff result = inner_; inner_ = {}; return result; }
};

class SystemTick {
private:
    AzSystemTick inner_;

public:
    SystemTick(AzSystemTick inner) noexcept : inner_(inner) {}
    SystemTick(const SystemTick& other) noexcept : inner_(other.inner_) {}
    SystemTick& operator=(const SystemTick& other) noexcept { inner_ = other.inner_; return *this; }
    ~SystemTick() {}

    bool partialEq(const SystemTick& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const SystemTick& b) const;
    uint8_t cmp(const SystemTick& b) const;
    String toDbgString() const;

    const AzSystemTick& inner() const { return inner_; }
    AzSystemTick& inner() { return inner_; }
    const AzSystemTick* ptr() const { return &inner_; }
    AzSystemTick* ptr() { return &inner_; }
    AzSystemTick release() { AzSystemTick result = inner_; inner_ = {}; return result; }
    operator AzSystemTick() && noexcept { AzSystemTick result = inner_; inner_ = {}; return result; }
};

class SystemTimeDiff {
private:
    AzSystemTimeDiff inner_;

public:
    SystemTimeDiff(AzSystemTimeDiff inner) noexcept : inner_(inner) {}
    SystemTimeDiff(const SystemTimeDiff& other) noexcept : inner_(other.inner_) {}
    SystemTimeDiff& operator=(const SystemTimeDiff& other) noexcept { inner_ = other.inner_; return *this; }
    ~SystemTimeDiff() {}

    [[nodiscard]] static SystemTimeDiff from_secs(uint64_t secs);
    [[nodiscard]] static SystemTimeDiff from_millis(uint64_t millis);
    [[nodiscard]] static SystemTimeDiff from_nanos(uint64_t nanos);

    uint64_t millis() const;
    double div(SystemTimeDiff other) const;
    bool partialEq(const SystemTimeDiff& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const SystemTimeDiff& b) const;
    uint8_t cmp(const SystemTimeDiff& b) const;
    String toDbgString() const;

    const AzSystemTimeDiff& inner() const { return inner_; }
    AzSystemTimeDiff& inner() { return inner_; }
    const AzSystemTimeDiff* ptr() const { return &inner_; }
    AzSystemTimeDiff* ptr() { return &inner_; }
    AzSystemTimeDiff release() { AzSystemTimeDiff result = inner_; inner_ = {}; return result; }
    operator AzSystemTimeDiff() && noexcept { AzSystemTimeDiff result = inner_; inner_ = {}; return result; }
};

class CssDuration {
private:
    AzCssDuration inner_;

public:
    CssDuration(AzCssDuration inner) noexcept : inner_(inner) {}
    CssDuration(const CssDuration& other) noexcept : inner_(other.inner_) {}
    CssDuration& operator=(const CssDuration& other) noexcept { inner_ = other.inner_; return *this; }
    ~CssDuration() {}

    [[nodiscard]] static CssDuration default_();

    bool partialEq(const CssDuration& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CssDuration& b) const;
    uint8_t cmp(const CssDuration& b) const;
    String toDbgString() const;

    const AzCssDuration& inner() const { return inner_; }
    AzCssDuration& inner() { return inner_; }
    const AzCssDuration* ptr() const { return &inner_; }
    AzCssDuration* ptr() { return &inner_; }
    AzCssDuration release() { AzCssDuration result = inner_; inner_ = {}; return result; }
    operator AzCssDuration() && noexcept { AzCssDuration result = inner_; inner_ = {}; return result; }
};

class IcuTime {
private:
    AzIcuTime inner_;

public:
    IcuTime(AzIcuTime inner) noexcept : inner_(inner) {}
    IcuTime(const IcuTime& other) noexcept : inner_(other.inner_) {}
    IcuTime& operator=(const IcuTime& other) noexcept { inner_ = other.inner_; return *this; }
    ~IcuTime() {}

    bool partialEq(const IcuTime& b) const;
    String toDbgString() const;

    const AzIcuTime& inner() const { return inner_; }
    AzIcuTime& inner() { return inner_; }
    const AzIcuTime* ptr() const { return &inner_; }
    AzIcuTime* ptr() { return &inner_; }
    AzIcuTime release() { AzIcuTime result = inner_; inner_ = {}; return result; }
    operator AzIcuTime() && noexcept { AzIcuTime result = inner_; inner_ = {}; return result; }
};

class StringPairVecSlice {
private:
    AzStringPairVecSlice inner_;

public:
    StringPairVecSlice(AzStringPairVecSlice inner) noexcept : inner_(inner) {}
    StringPairVecSlice(const StringPairVecSlice& other) noexcept : inner_(other.inner_) {}
    StringPairVecSlice& operator=(const StringPairVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~StringPairVecSlice() {}

    String toDbgString() const;

    const AzStringPairVecSlice& inner() const { return inner_; }
    AzStringPairVecSlice& inner() { return inner_; }
    const AzStringPairVecSlice* ptr() const { return &inner_; }
    AzStringPairVecSlice* ptr() { return &inner_; }
    AzStringPairVecSlice release() { AzStringPairVecSlice result = inner_; inner_ = {}; return result; }
    operator AzStringPairVecSlice() && noexcept { AzStringPairVecSlice result = inner_; inner_ = {}; return result; }
};

class StringVecSlice {
private:
    AzStringVecSlice inner_;

public:
    StringVecSlice(AzStringVecSlice inner) noexcept : inner_(inner) {}
    StringVecSlice(const StringVecSlice& other) noexcept : inner_(other.inner_) {}
    StringVecSlice& operator=(const StringVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~StringVecSlice() {}

    String toDbgString() const;

    const AzStringVecSlice& inner() const { return inner_; }
    AzStringVecSlice& inner() { return inner_; }
    const AzStringVecSlice* ptr() const { return &inner_; }
    AzStringVecSlice* ptr() { return &inner_; }
    AzStringVecSlice release() { AzStringVecSlice result = inner_; inner_ = {}; return result; }
    operator AzStringVecSlice() && noexcept { AzStringVecSlice result = inner_; inner_ = {}; return result; }
};

class GLbooleanVecRefMut {
private:
    AzGLbooleanVecRefMut inner_;

    GLbooleanVecRefMut(const GLbooleanVecRefMut&) = delete;
    GLbooleanVecRefMut& operator=(const GLbooleanVecRefMut&) = delete;

public:
    explicit GLbooleanVecRefMut(AzGLbooleanVecRefMut inner) noexcept : inner_(inner) {}

    GLbooleanVecRefMut(GLbooleanVecRefMut&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GLbooleanVecRefMut& operator=(GLbooleanVecRefMut&& other) noexcept {
        if (this != &other) {
            AzGLbooleanVecRefMut_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GLbooleanVecRefMut() { AzGLbooleanVecRefMut_delete(&inner_); }

    void delete_();
    GLbooleanVecRefMut clone() const;
    String toDbgString() const;

    const AzGLbooleanVecRefMut& inner() const { return inner_; }
    AzGLbooleanVecRefMut& inner() { return inner_; }
    const AzGLbooleanVecRefMut* ptr() const { return &inner_; }
    AzGLbooleanVecRefMut* ptr() { return &inner_; }
    AzGLbooleanVecRefMut release() { AzGLbooleanVecRefMut result = inner_; inner_ = {}; return result; }
    operator AzGLbooleanVecRefMut() && noexcept { AzGLbooleanVecRefMut result = inner_; inner_ = {}; return result; }
};

class GLfloatVecRefMut {
private:
    AzGLfloatVecRefMut inner_;

    GLfloatVecRefMut(const GLfloatVecRefMut&) = delete;
    GLfloatVecRefMut& operator=(const GLfloatVecRefMut&) = delete;

public:
    explicit GLfloatVecRefMut(AzGLfloatVecRefMut inner) noexcept : inner_(inner) {}

    GLfloatVecRefMut(GLfloatVecRefMut&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GLfloatVecRefMut& operator=(GLfloatVecRefMut&& other) noexcept {
        if (this != &other) {
            AzGLfloatVecRefMut_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GLfloatVecRefMut() { AzGLfloatVecRefMut_delete(&inner_); }

    void delete_();
    GLfloatVecRefMut clone() const;
    String toDbgString() const;

    const AzGLfloatVecRefMut& inner() const { return inner_; }
    AzGLfloatVecRefMut& inner() { return inner_; }
    const AzGLfloatVecRefMut* ptr() const { return &inner_; }
    AzGLfloatVecRefMut* ptr() { return &inner_; }
    AzGLfloatVecRefMut release() { AzGLfloatVecRefMut result = inner_; inner_ = {}; return result; }
    operator AzGLfloatVecRefMut() && noexcept { AzGLfloatVecRefMut result = inner_; inner_ = {}; return result; }
};

class U8VecRefMut {
private:
    AzU8VecRefMut inner_;

    U8VecRefMut(const U8VecRefMut&) = delete;
    U8VecRefMut& operator=(const U8VecRefMut&) = delete;

public:
    explicit U8VecRefMut(AzU8VecRefMut inner) noexcept : inner_(inner) {}

    U8VecRefMut(U8VecRefMut&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    U8VecRefMut& operator=(U8VecRefMut&& other) noexcept {
        if (this != &other) {
            AzU8VecRefMut_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~U8VecRefMut() { AzU8VecRefMut_delete(&inner_); }

    void delete_();
    U8VecRefMut clone() const;
    String toDbgString() const;

    const AzU8VecRefMut& inner() const { return inner_; }
    AzU8VecRefMut& inner() { return inner_; }
    const AzU8VecRefMut* ptr() const { return &inner_; }
    AzU8VecRefMut* ptr() { return &inner_; }
    AzU8VecRefMut release() { AzU8VecRefMut result = inner_; inner_ = {}; return result; }
    operator AzU8VecRefMut() && noexcept { AzU8VecRefMut result = inner_; inner_ = {}; return result; }
};

class TessellatedSvgNodeVecRef {
private:
    AzTessellatedSvgNodeVecRef inner_;

    TessellatedSvgNodeVecRef(const TessellatedSvgNodeVecRef&) = delete;
    TessellatedSvgNodeVecRef& operator=(const TessellatedSvgNodeVecRef&) = delete;

public:
    explicit TessellatedSvgNodeVecRef(AzTessellatedSvgNodeVecRef inner) noexcept : inner_(inner) {}

    TessellatedSvgNodeVecRef(TessellatedSvgNodeVecRef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TessellatedSvgNodeVecRef& operator=(TessellatedSvgNodeVecRef&& other) noexcept {
        if (this != &other) {
            AzTessellatedSvgNodeVecRef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TessellatedSvgNodeVecRef() { AzTessellatedSvgNodeVecRef_delete(&inner_); }

    void delete_();
    TessellatedSvgNodeVecRef clone() const;
    String toDbgString() const;

    const AzTessellatedSvgNodeVecRef& inner() const { return inner_; }
    AzTessellatedSvgNodeVecRef& inner() { return inner_; }
    const AzTessellatedSvgNodeVecRef* ptr() const { return &inner_; }
    AzTessellatedSvgNodeVecRef* ptr() { return &inner_; }
    AzTessellatedSvgNodeVecRef release() { AzTessellatedSvgNodeVecRef result = inner_; inner_ = {}; return result; }
    operator AzTessellatedSvgNodeVecRef() && noexcept { AzTessellatedSvgNodeVecRef result = inner_; inner_ = {}; return result; }
};

class F32VecRef {
private:
    AzF32VecRef inner_;

    F32VecRef(const F32VecRef&) = delete;
    F32VecRef& operator=(const F32VecRef&) = delete;

public:
    explicit F32VecRef(AzF32VecRef inner) noexcept : inner_(inner) {}

    F32VecRef(F32VecRef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    F32VecRef& operator=(F32VecRef&& other) noexcept {
        if (this != &other) {
            AzF32VecRef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~F32VecRef() { AzF32VecRef_delete(&inner_); }

    void delete_();
    F32VecRef clone() const;
    String toDbgString() const;

    const AzF32VecRef& inner() const { return inner_; }
    AzF32VecRef& inner() { return inner_; }
    const AzF32VecRef* ptr() const { return &inner_; }
    AzF32VecRef* ptr() { return &inner_; }
    AzF32VecRef release() { AzF32VecRef result = inner_; inner_ = {}; return result; }
    operator AzF32VecRef() && noexcept { AzF32VecRef result = inner_; inner_ = {}; return result; }
};

class GLuintVecRef {
private:
    AzGLuintVecRef inner_;

    GLuintVecRef(const GLuintVecRef&) = delete;
    GLuintVecRef& operator=(const GLuintVecRef&) = delete;

public:
    explicit GLuintVecRef(AzGLuintVecRef inner) noexcept : inner_(inner) {}

    GLuintVecRef(GLuintVecRef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GLuintVecRef& operator=(GLuintVecRef&& other) noexcept {
        if (this != &other) {
            AzGLuintVecRef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GLuintVecRef() { AzGLuintVecRef_delete(&inner_); }

    void delete_();
    GLuintVecRef clone() const;
    String toDbgString() const;

    const AzGLuintVecRef& inner() const { return inner_; }
    AzGLuintVecRef& inner() { return inner_; }
    const AzGLuintVecRef* ptr() const { return &inner_; }
    AzGLuintVecRef* ptr() { return &inner_; }
    AzGLuintVecRef release() { AzGLuintVecRef result = inner_; inner_ = {}; return result; }
    operator AzGLuintVecRef() && noexcept { AzGLuintVecRef result = inner_; inner_ = {}; return result; }
};

class I32VecRef {
private:
    AzI32VecRef inner_;

    I32VecRef(const I32VecRef&) = delete;
    I32VecRef& operator=(const I32VecRef&) = delete;

public:
    explicit I32VecRef(AzI32VecRef inner) noexcept : inner_(inner) {}

    I32VecRef(I32VecRef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    I32VecRef& operator=(I32VecRef&& other) noexcept {
        if (this != &other) {
            AzI32VecRef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~I32VecRef() { AzI32VecRef_delete(&inner_); }

    void delete_();
    I32VecRef clone() const;
    String toDbgString() const;

    const AzI32VecRef& inner() const { return inner_; }
    AzI32VecRef& inner() { return inner_; }
    const AzI32VecRef* ptr() const { return &inner_; }
    AzI32VecRef* ptr() { return &inner_; }
    AzI32VecRef release() { AzI32VecRef result = inner_; inner_ = {}; return result; }
    operator AzI32VecRef() && noexcept { AzI32VecRef result = inner_; inner_ = {}; return result; }
};

class U8VecRef {
private:
    AzU8VecRef inner_;

    U8VecRef(const U8VecRef&) = delete;
    U8VecRef& operator=(const U8VecRef&) = delete;

public:
    explicit U8VecRef(AzU8VecRef inner) noexcept : inner_(inner) {}

    U8VecRef(U8VecRef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    U8VecRef& operator=(U8VecRef&& other) noexcept {
        if (this != &other) {
            AzU8VecRef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~U8VecRef() { AzU8VecRef_delete(&inner_); }

    void delete_();
    U8VecRef clone() const;
    bool partialEq(const U8VecRef& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const U8VecRef& b) const;
    uint8_t cmp(const U8VecRef& b) const;
    String toDbgString() const;

    const AzU8VecRef& inner() const { return inner_; }
    AzU8VecRef& inner() { return inner_; }
    const AzU8VecRef* ptr() const { return &inner_; }
    AzU8VecRef* ptr() { return &inner_; }
    AzU8VecRef release() { AzU8VecRef result = inner_; inner_ = {}; return result; }
    operator AzU8VecRef() && noexcept { AzU8VecRef result = inner_; inner_ = {}; return result; }
};

class GLintVecRefMut {
private:
    AzGLintVecRefMut inner_;

    GLintVecRefMut(const GLintVecRefMut&) = delete;
    GLintVecRefMut& operator=(const GLintVecRefMut&) = delete;

public:
    explicit GLintVecRefMut(AzGLintVecRefMut inner) noexcept : inner_(inner) {}

    GLintVecRefMut(GLintVecRefMut&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GLintVecRefMut& operator=(GLintVecRefMut&& other) noexcept {
        if (this != &other) {
            AzGLintVecRefMut_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GLintVecRefMut() { AzGLintVecRefMut_delete(&inner_); }

    void delete_();
    GLintVecRefMut clone() const;
    String toDbgString() const;

    const AzGLintVecRefMut& inner() const { return inner_; }
    AzGLintVecRefMut& inner() { return inner_; }
    const AzGLintVecRefMut* ptr() const { return &inner_; }
    AzGLintVecRefMut* ptr() { return &inner_; }
    AzGLintVecRefMut release() { AzGLintVecRefMut result = inner_; inner_ = {}; return result; }
    operator AzGLintVecRefMut() && noexcept { AzGLintVecRefMut result = inner_; inner_ = {}; return result; }
};

class GLenumVecRef {
private:
    AzGLenumVecRef inner_;

    GLenumVecRef(const GLenumVecRef&) = delete;
    GLenumVecRef& operator=(const GLenumVecRef&) = delete;

public:
    explicit GLenumVecRef(AzGLenumVecRef inner) noexcept : inner_(inner) {}

    GLenumVecRef(GLenumVecRef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GLenumVecRef& operator=(GLenumVecRef&& other) noexcept {
        if (this != &other) {
            AzGLenumVecRef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GLenumVecRef() { AzGLenumVecRef_delete(&inner_); }

    void delete_();
    GLenumVecRef clone() const;
    String toDbgString() const;

    const AzGLenumVecRef& inner() const { return inner_; }
    AzGLenumVecRef& inner() { return inner_; }
    const AzGLenumVecRef* ptr() const { return &inner_; }
    AzGLenumVecRef* ptr() { return &inner_; }
    AzGLenumVecRef release() { AzGLenumVecRef result = inner_; inner_ = {}; return result; }
    operator AzGLenumVecRef() && noexcept { AzGLenumVecRef result = inner_; inner_ = {}; return result; }
};

class GLint64VecRefMut {
private:
    AzGLint64VecRefMut inner_;

    GLint64VecRefMut(const GLint64VecRefMut&) = delete;
    GLint64VecRefMut& operator=(const GLint64VecRefMut&) = delete;

public:
    explicit GLint64VecRefMut(AzGLint64VecRefMut inner) noexcept : inner_(inner) {}

    GLint64VecRefMut(GLint64VecRefMut&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GLint64VecRefMut& operator=(GLint64VecRefMut&& other) noexcept {
        if (this != &other) {
            AzGLint64VecRefMut_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GLint64VecRefMut() { AzGLint64VecRefMut_delete(&inner_); }

    void delete_();
    GLint64VecRefMut clone() const;
    String toDbgString() const;

    const AzGLint64VecRefMut& inner() const { return inner_; }
    AzGLint64VecRefMut& inner() { return inner_; }
    const AzGLint64VecRefMut* ptr() const { return &inner_; }
    AzGLint64VecRefMut* ptr() { return &inner_; }
    AzGLint64VecRefMut release() { AzGLint64VecRefMut result = inner_; inner_ = {}; return result; }
    operator AzGLint64VecRefMut() && noexcept { AzGLint64VecRefMut result = inner_; inner_ = {}; return result; }
};

class RefstrVecRef {
private:
    AzRefstrVecRef inner_;

    RefstrVecRef(const RefstrVecRef&) = delete;
    RefstrVecRef& operator=(const RefstrVecRef&) = delete;

public:
    explicit RefstrVecRef(AzRefstrVecRef inner) noexcept : inner_(inner) {}

    RefstrVecRef(RefstrVecRef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RefstrVecRef& operator=(RefstrVecRef&& other) noexcept {
        if (this != &other) {
            AzRefstrVecRef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RefstrVecRef() { AzRefstrVecRef_delete(&inner_); }

    void delete_();
    RefstrVecRef clone() const;
    String toDbgString() const;

    const AzRefstrVecRef& inner() const { return inner_; }
    AzRefstrVecRef& inner() { return inner_; }
    const AzRefstrVecRef* ptr() const { return &inner_; }
    AzRefstrVecRef* ptr() { return &inner_; }
    AzRefstrVecRef release() { AzRefstrVecRef result = inner_; inner_ = {}; return result; }
    operator AzRefstrVecRef() && noexcept { AzRefstrVecRef result = inner_; inner_ = {}; return result; }
};

class HttpResponseTooLargeError {
private:
    AzHttpResponseTooLargeError inner_;

    HttpResponseTooLargeError(const HttpResponseTooLargeError&) = delete;
    HttpResponseTooLargeError& operator=(const HttpResponseTooLargeError&) = delete;

public:
    explicit HttpResponseTooLargeError(AzHttpResponseTooLargeError inner) noexcept : inner_(inner) {}

    HttpResponseTooLargeError(HttpResponseTooLargeError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    HttpResponseTooLargeError& operator=(HttpResponseTooLargeError&& other) noexcept {
        if (this != &other) {
            AzHttpResponseTooLargeError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~HttpResponseTooLargeError() { AzHttpResponseTooLargeError_delete(&inner_); }

    void delete_();
    HttpResponseTooLargeError clone() const;
    bool partialEq(const HttpResponseTooLargeError& b) const;
    String toDbgString() const;

    const AzHttpResponseTooLargeError& inner() const { return inner_; }
    AzHttpResponseTooLargeError& inner() { return inner_; }
    const AzHttpResponseTooLargeError* ptr() const { return &inner_; }
    AzHttpResponseTooLargeError* ptr() { return &inner_; }
    AzHttpResponseTooLargeError release() { AzHttpResponseTooLargeError result = inner_; inner_ = {}; return result; }
    operator AzHttpResponseTooLargeError() && noexcept { AzHttpResponseTooLargeError result = inner_; inner_ = {}; return result; }
};

class ErrorLocation {
private:
    AzErrorLocation inner_;

public:
    ErrorLocation(AzErrorLocation inner) noexcept : inner_(inner) {}
    ErrorLocation(const ErrorLocation& other) noexcept : inner_(other.inner_) {}
    ErrorLocation& operator=(const ErrorLocation& other) noexcept { inner_ = other.inner_; return *this; }
    ~ErrorLocation() {}

    [[nodiscard]] static ErrorLocation default_();

    bool partialEq(const ErrorLocation& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ErrorLocation& b) const;
    uint8_t cmp(const ErrorLocation& b) const;
    String toDbgString() const;

    const AzErrorLocation& inner() const { return inner_; }
    AzErrorLocation& inner() { return inner_; }
    const AzErrorLocation* ptr() const { return &inner_; }
    AzErrorLocation* ptr() { return &inner_; }
    AzErrorLocation release() { AzErrorLocation result = inner_; inner_ = {}; return result; }
    operator AzErrorLocation() && noexcept { AzErrorLocation result = inner_; inner_ = {}; return result; }
};

class CssSyntaxErrorPos {
private:
    AzCssSyntaxErrorPos inner_;

public:
    CssSyntaxErrorPos(AzCssSyntaxErrorPos inner) noexcept : inner_(inner) {}
    CssSyntaxErrorPos(const CssSyntaxErrorPos& other) noexcept : inner_(other.inner_) {}
    CssSyntaxErrorPos& operator=(const CssSyntaxErrorPos& other) noexcept { inner_ = other.inner_; return *this; }
    ~CssSyntaxErrorPos() {}

    bool partialEq(const CssSyntaxErrorPos& b) const;
    String toDbgString() const;

    const AzCssSyntaxErrorPos& inner() const { return inner_; }
    AzCssSyntaxErrorPos& inner() { return inner_; }
    const AzCssSyntaxErrorPos* ptr() const { return &inner_; }
    AzCssSyntaxErrorPos* ptr() { return &inner_; }
    AzCssSyntaxErrorPos release() { AzCssSyntaxErrorPos result = inner_; inner_ = {}; return result; }
    operator AzCssSyntaxErrorPos() && noexcept { AzCssSyntaxErrorPos result = inner_; inner_ = {}; return result; }
};

class App {
private:
    AzApp inner_;

    App(const App&) = delete;
    App& operator=(const App&) = delete;

public:
    explicit App(AzApp inner) noexcept : inner_(inner) {}

    App(App&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    App& operator=(App&& other) noexcept {
        if (this != &other) {
            AzApp_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~App() { AzApp_delete(&inner_); }

    [[nodiscard]] static App create(RefAny initial_data, AppConfig app_config);
    [[nodiscard]] static App default_();

    void add_window(WindowCreateOptions create_options);
    MonitorVec get_monitors() const;
    void run(WindowCreateOptions root_window) const;
    void delete_();
    App clone() const;
    String toDbgString() const;

    const AzApp& inner() const { return inner_; }
    AzApp& inner() { return inner_; }
    const AzApp* ptr() const { return &inner_; }
    AzApp* ptr() { return &inner_; }
    AzApp release() { AzApp result = inner_; inner_ = {}; return result; }
    operator AzApp() && noexcept { AzApp result = inner_; inner_ = {}; return result; }
};

class TimerId {
private:
    AzTimerId inner_;

public:
    TimerId(AzTimerId inner) noexcept : inner_(inner) {}
    TimerId(const TimerId& other) noexcept : inner_(other.inner_) {}
    TimerId& operator=(const TimerId& other) noexcept { inner_ = other.inner_; return *this; }
    ~TimerId() {}

    [[nodiscard]] static TimerId unique();

    bool partialEq(const TimerId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TimerId& b) const;
    uint8_t cmp(const TimerId& b) const;
    String toDbgString() const;

    const AzTimerId& inner() const { return inner_; }
    AzTimerId& inner() { return inner_; }
    const AzTimerId* ptr() const { return &inner_; }
    AzTimerId* ptr() { return &inner_; }
    AzTimerId release() { AzTimerId result = inner_; inner_ = {}; return result; }
    operator AzTimerId() && noexcept { AzTimerId result = inner_; inner_ = {}; return result; }
};

class Thread {
private:
    AzThread inner_;

    Thread(const Thread&) = delete;
    Thread& operator=(const Thread&) = delete;

public:
    explicit Thread(AzThread inner) noexcept : inner_(inner) {}

    Thread(Thread&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Thread& operator=(Thread&& other) noexcept {
        if (this != &other) {
            AzThread_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Thread() { AzThread_delete(&inner_); }

    [[nodiscard]] static Thread create(RefAny thread_initialize_data, RefAny writeback_data, AzThreadCallbackType callback);
    [[nodiscard]] static EmptyStruct sleep_ms(uint64_t milliseconds);
    [[nodiscard]] static EmptyStruct sleep_us(uint64_t microseconds);
    [[nodiscard]] static EmptyStruct sleep_ns(uint64_t nanoseconds);

    void delete_();
    Thread clone() const;
    String toDbgString() const;

    const AzThread& inner() const { return inner_; }
    AzThread& inner() { return inner_; }
    const AzThread* ptr() const { return &inner_; }
    AzThread* ptr() { return &inner_; }
    AzThread release() { AzThread result = inner_; inner_ = {}; return result; }
    operator AzThread() && noexcept { AzThread result = inner_; inner_ = {}; return result; }
};

class ThreadId {
private:
    AzThreadId inner_;

public:
    ThreadId(AzThreadId inner) noexcept : inner_(inner) {}
    ThreadId(const ThreadId& other) noexcept : inner_(other.inner_) {}
    ThreadId& operator=(const ThreadId& other) noexcept { inner_ = other.inner_; return *this; }
    ~ThreadId() {}

    [[nodiscard]] static ThreadId unique();

    bool partialEq(const ThreadId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ThreadId& b) const;
    uint8_t cmp(const ThreadId& b) const;
    String toDbgString() const;

    const AzThreadId& inner() const { return inner_; }
    AzThreadId& inner() { return inner_; }
    const AzThreadId* ptr() const { return &inner_; }
    AzThreadId* ptr() { return &inner_; }
    AzThreadId release() { AzThreadId result = inner_; inner_ = {}; return result; }
    operator AzThreadId() && noexcept { AzThreadId result = inner_; inner_ = {}; return result; }
};

class TimerIdVecSlice {
private:
    AzTimerIdVecSlice inner_;

public:
    TimerIdVecSlice(AzTimerIdVecSlice inner) noexcept : inner_(inner) {}
    TimerIdVecSlice(const TimerIdVecSlice& other) noexcept : inner_(other.inner_) {}
    TimerIdVecSlice& operator=(const TimerIdVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~TimerIdVecSlice() {}

    String toDbgString() const;

    const AzTimerIdVecSlice& inner() const { return inner_; }
    AzTimerIdVecSlice& inner() { return inner_; }
    const AzTimerIdVecSlice* ptr() const { return &inner_; }
    AzTimerIdVecSlice* ptr() { return &inner_; }
    AzTimerIdVecSlice release() { AzTimerIdVecSlice result = inner_; inner_ = {}; return result; }
    operator AzTimerIdVecSlice() && noexcept { AzTimerIdVecSlice result = inner_; inner_ = {}; return result; }
};

class ThreadIdVecSlice {
private:
    AzThreadIdVecSlice inner_;

public:
    ThreadIdVecSlice(AzThreadIdVecSlice inner) noexcept : inner_(inner) {}
    ThreadIdVecSlice(const ThreadIdVecSlice& other) noexcept : inner_(other.inner_) {}
    ThreadIdVecSlice& operator=(const ThreadIdVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ThreadIdVecSlice() {}

    String toDbgString() const;

    const AzThreadIdVecSlice& inner() const { return inner_; }
    AzThreadIdVecSlice& inner() { return inner_; }
    const AzThreadIdVecSlice* ptr() const { return &inner_; }
    AzThreadIdVecSlice* ptr() { return &inner_; }
    AzThreadIdVecSlice release() { AzThreadIdVecSlice result = inner_; inner_ = {}; return result; }
    operator AzThreadIdVecSlice() && noexcept { AzThreadIdVecSlice result = inner_; inner_ = {}; return result; }
};

class ExternalResourceVecSlice {
private:
    AzExternalResourceVecSlice inner_;

public:
    ExternalResourceVecSlice(AzExternalResourceVecSlice inner) noexcept : inner_(inner) {}
    ExternalResourceVecSlice(const ExternalResourceVecSlice& other) noexcept : inner_(other.inner_) {}
    ExternalResourceVecSlice& operator=(const ExternalResourceVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ExternalResourceVecSlice() {}

    String toDbgString() const;

    const AzExternalResourceVecSlice& inner() const { return inner_; }
    AzExternalResourceVecSlice& inner() { return inner_; }
    const AzExternalResourceVecSlice* ptr() const { return &inner_; }
    AzExternalResourceVecSlice* ptr() { return &inner_; }
    AzExternalResourceVecSlice release() { AzExternalResourceVecSlice result = inner_; inner_ = {}; return result; }
    operator AzExternalResourceVecSlice() && noexcept { AzExternalResourceVecSlice result = inner_; inner_ = {}; return result; }
};

class DirEntryVecSlice {
private:
    AzDirEntryVecSlice inner_;

public:
    DirEntryVecSlice(AzDirEntryVecSlice inner) noexcept : inner_(inner) {}
    DirEntryVecSlice(const DirEntryVecSlice& other) noexcept : inner_(other.inner_) {}
    DirEntryVecSlice& operator=(const DirEntryVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~DirEntryVecSlice() {}

    String toDbgString() const;

    const AzDirEntryVecSlice& inner() const { return inner_; }
    AzDirEntryVecSlice& inner() { return inner_; }
    const AzDirEntryVecSlice* ptr() const { return &inner_; }
    AzDirEntryVecSlice* ptr() { return &inner_; }
    AzDirEntryVecSlice release() { AzDirEntryVecSlice result = inner_; inner_ = {}; return result; }
    operator AzDirEntryVecSlice() && noexcept { AzDirEntryVecSlice result = inner_; inner_ = {}; return result; }
};

class FmtArgVecSlice {
private:
    AzFmtArgVecSlice inner_;

public:
    FmtArgVecSlice(AzFmtArgVecSlice inner) noexcept : inner_(inner) {}
    FmtArgVecSlice(const FmtArgVecSlice& other) noexcept : inner_(other.inner_) {}
    FmtArgVecSlice& operator=(const FmtArgVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~FmtArgVecSlice() {}

    String toDbgString() const;

    const AzFmtArgVecSlice& inner() const { return inner_; }
    AzFmtArgVecSlice& inner() { return inner_; }
    const AzFmtArgVecSlice* ptr() const { return &inner_; }
    AzFmtArgVecSlice* ptr() { return &inner_; }
    AzFmtArgVecSlice release() { AzFmtArgVecSlice result = inner_; inner_ = {}; return result; }
    operator AzFmtArgVecSlice() && noexcept { AzFmtArgVecSlice result = inner_; inner_ = {}; return result; }
};

class JsonKeyValueVecSlice {
private:
    AzJsonKeyValueVecSlice inner_;

public:
    JsonKeyValueVecSlice(AzJsonKeyValueVecSlice inner) noexcept : inner_(inner) {}
    JsonKeyValueVecSlice(const JsonKeyValueVecSlice& other) noexcept : inner_(other.inner_) {}
    JsonKeyValueVecSlice& operator=(const JsonKeyValueVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~JsonKeyValueVecSlice() {}

    String toDbgString() const;

    const AzJsonKeyValueVecSlice& inner() const { return inner_; }
    AzJsonKeyValueVecSlice& inner() { return inner_; }
    const AzJsonKeyValueVecSlice* ptr() const { return &inner_; }
    AzJsonKeyValueVecSlice* ptr() { return &inner_; }
    AzJsonKeyValueVecSlice release() { AzJsonKeyValueVecSlice result = inner_; inner_ = {}; return result; }
    operator AzJsonKeyValueVecSlice() && noexcept { AzJsonKeyValueVecSlice result = inner_; inner_ = {}; return result; }
};

class JsonVecSlice {
private:
    AzJsonVecSlice inner_;

public:
    JsonVecSlice(AzJsonVecSlice inner) noexcept : inner_(inner) {}
    JsonVecSlice(const JsonVecSlice& other) noexcept : inner_(other.inner_) {}
    JsonVecSlice& operator=(const JsonVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~JsonVecSlice() {}

    String toDbgString() const;

    const AzJsonVecSlice& inner() const { return inner_; }
    AzJsonVecSlice& inner() { return inner_; }
    const AzJsonVecSlice* ptr() const { return &inner_; }
    AzJsonVecSlice* ptr() { return &inner_; }
    AzJsonVecSlice release() { AzJsonVecSlice result = inner_; inner_ = {}; return result; }
    operator AzJsonVecSlice() && noexcept { AzJsonVecSlice result = inner_; inner_ = {}; return result; }
};

class Db {
private:
    AzDb inner_;

    Db(const Db&) = delete;
    Db& operator=(const Db&) = delete;

public:
    explicit Db(AzDb inner) noexcept : inner_(inner) {}

    Db(Db&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Db& operator=(Db&& other) noexcept {
        if (this != &other) {
            AzDb_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Db() { AzDb_delete(&inner_); }

    [[nodiscard]] static Db open(String path);
    [[nodiscard]] static Db default_();

    bool is_open() const;
    size_t execute(String sql, DbValueVec params) const;
    DbRows query(String sql, DbValueVec params) const;
    void delete_();
    Db clone() const;
    String toDbgString() const;

    const AzDb& inner() const { return inner_; }
    AzDb& inner() { return inner_; }
    const AzDb* ptr() const { return &inner_; }
    AzDb* ptr() { return &inner_; }
    AzDb release() { AzDb result = inner_; inner_ = {}; return result; }
    operator AzDb() && noexcept { AzDb result = inner_; inner_ = {}; return result; }
};

class Pdf {
private:
    AzPdf inner_;

public:
    Pdf(AzPdf inner) noexcept : inner_(inner) {}
    Pdf(const Pdf& other) noexcept : inner_(other.inner_) {}
    Pdf& operator=(const Pdf& other) noexcept { inner_ = other.inner_; return *this; }
    ~Pdf() {}

    [[nodiscard]] static Pdf new_();
    [[nodiscard]] static Pdf default_();

    U8Vec write_json(Json json) const;
    Json read_json(U8Vec bytes) const;
    U8Vec from_dom(Dom dom, float page_width_px, float page_height_px) const;
    bool partialEq(const Pdf& b) const;
    String toDbgString() const;

    const AzPdf& inner() const { return inner_; }
    AzPdf& inner() { return inner_; }
    const AzPdf* ptr() const { return &inner_; }
    AzPdf* ptr() { return &inner_; }
    AzPdf release() { AzPdf result = inner_; inner_ = {}; return result; }
    operator AzPdf() && noexcept { AzPdf result = inner_; inner_ = {}; return result; }
};

class GamepadId {
private:
    AzGamepadId inner_;

public:
    GamepadId(AzGamepadId inner) noexcept : inner_(inner) {}
    GamepadId(const GamepadId& other) noexcept : inner_(other.inner_) {}
    GamepadId& operator=(const GamepadId& other) noexcept { inner_ = other.inner_; return *this; }
    ~GamepadId() {}

    bool partialEq(const GamepadId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GamepadId& b) const;
    uint8_t cmp(const GamepadId& b) const;
    String toDbgString() const;

    const AzGamepadId& inner() const { return inner_; }
    AzGamepadId& inner() { return inner_; }
    const AzGamepadId* ptr() const { return &inner_; }
    AzGamepadId* ptr() { return &inner_; }
    AzGamepadId release() { AzGamepadId result = inner_; inner_ = {}; return result; }
    operator AzGamepadId() && noexcept { AzGamepadId result = inner_; inner_ = {}; return result; }
};

class WacomPadState {
private:
    AzWacomPadState inner_;

public:
    WacomPadState(AzWacomPadState inner) noexcept : inner_(inner) {}
    WacomPadState(const WacomPadState& other) noexcept : inner_(other.inner_) {}
    WacomPadState& operator=(const WacomPadState& other) noexcept { inner_ = other.inner_; return *this; }
    ~WacomPadState() {}

    [[nodiscard]] static WacomPadState default_();

    bool partialEq(const WacomPadState& b) const;
    String toDbgString() const;

    const AzWacomPadState& inner() const { return inner_; }
    AzWacomPadState& inner() { return inner_; }
    const AzWacomPadState* ptr() const { return &inner_; }
    AzWacomPadState* ptr() { return &inner_; }
    AzWacomPadState release() { AzWacomPadState result = inner_; inner_ = {}; return result; }
    operator AzWacomPadState() && noexcept { AzWacomPadState result = inner_; inner_ = {}; return result; }
};

class AudioConfig {
private:
    AzAudioConfig inner_;

public:
    AudioConfig(AzAudioConfig inner) noexcept : inner_(inner) {}
    AudioConfig(const AudioConfig& other) noexcept : inner_(other.inner_) {}
    AudioConfig& operator=(const AudioConfig& other) noexcept { inner_ = other.inner_; return *this; }
    ~AudioConfig() {}

    [[nodiscard]] static AudioConfig default_();

    bool partialEq(const AudioConfig& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzAudioConfig& inner() const { return inner_; }
    AzAudioConfig& inner() { return inner_; }
    const AzAudioConfig* ptr() const { return &inner_; }
    AzAudioConfig* ptr() { return &inner_; }
    AzAudioConfig release() { AzAudioConfig result = inner_; inner_ = {}; return result; }
    operator AzAudioConfig() && noexcept { AzAudioConfig result = inner_; inner_ = {}; return result; }
};

class Udp {
private:
    AzUdp inner_;

    Udp(const Udp&) = delete;
    Udp& operator=(const Udp&) = delete;

public:
    explicit Udp(AzUdp inner) noexcept : inner_(inner) {}

    Udp(Udp&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Udp& operator=(Udp&& other) noexcept {
        if (this != &other) {
            AzUdp_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Udp() { AzUdp_delete(&inner_); }

    [[nodiscard]] static Udp bind(String local_addr);
    [[nodiscard]] static Udp default_();

    void close();
    size_t send_to(String remote_addr, U8Vec data) const;
    OptionU8Vec recv() const;
    bool is_open() const;
    String local_addr() const;
    size_t send_chunked(String remote_addr, U8Vec data) const;
    OptionU8Vec recv_chunked() const;
    void delete_();
    Udp clone() const;

    const AzUdp& inner() const { return inner_; }
    AzUdp& inner() { return inner_; }
    const AzUdp* ptr() const { return &inner_; }
    AzUdp* ptr() { return &inner_; }
    AzUdp release() { AzUdp result = inner_; inner_ = {}; return result; }
    operator AzUdp() && noexcept { AzUdp result = inner_; inner_ = {}; return result; }
};

class DbValueVecSlice {
private:
    AzDbValueVecSlice inner_;

public:
    DbValueVecSlice(AzDbValueVecSlice inner) noexcept : inner_(inner) {}
    DbValueVecSlice(const DbValueVecSlice& other) noexcept : inner_(other.inner_) {}
    DbValueVecSlice& operator=(const DbValueVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~DbValueVecSlice() {}

    String toDbgString() const;

    const AzDbValueVecSlice& inner() const { return inner_; }
    AzDbValueVecSlice& inner() { return inner_; }
    const AzDbValueVecSlice* ptr() const { return &inner_; }
    AzDbValueVecSlice* ptr() { return &inner_; }
    AzDbValueVecSlice release() { AzDbValueVecSlice result = inner_; inner_ = {}; return result; }
    operator AzDbValueVecSlice() && noexcept { AzDbValueVecSlice result = inner_; inner_ = {}; return result; }
};

class IcuDate {
private:
    AzIcuDate inner_;

public:
    IcuDate(AzIcuDate inner) noexcept : inner_(inner) {}
    IcuDate(const IcuDate& other) noexcept : inner_(other.inner_) {}
    IcuDate& operator=(const IcuDate& other) noexcept { inner_ = other.inner_; return *this; }
    ~IcuDate() {}

    bool partialEq(const IcuDate& b) const;
    String toDbgString() const;

    const AzIcuDate& inner() const { return inner_; }
    AzIcuDate& inner() { return inner_; }
    const AzIcuDate* ptr() const { return &inner_; }
    AzIcuDate* ptr() { return &inner_; }
    AzIcuDate release() { AzIcuDate result = inner_; inner_ = {}; return result; }
    operator AzIcuDate() && noexcept { AzIcuDate result = inner_; inner_ = {}; return result; }
};

class IcuLocalizerHandle {
private:
    AzIcuLocalizerHandle inner_;

    IcuLocalizerHandle(const IcuLocalizerHandle&) = delete;
    IcuLocalizerHandle& operator=(const IcuLocalizerHandle&) = delete;

public:
    explicit IcuLocalizerHandle(AzIcuLocalizerHandle inner) noexcept : inner_(inner) {}

    IcuLocalizerHandle(IcuLocalizerHandle&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    IcuLocalizerHandle& operator=(IcuLocalizerHandle&& other) noexcept {
        if (this != &other) {
            AzIcuLocalizerHandle_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~IcuLocalizerHandle() { AzIcuLocalizerHandle_delete(&inner_); }

    [[nodiscard]] static IcuLocalizerHandle from_system_language(String language);
    [[nodiscard]] static IcuLocalizerHandle create(String default_locale);
    [[nodiscard]] static IcuLocalizerHandle default_();

    String get_default_locale() const;
    void set_default_locale(String locale);
    void set_locale(String locale);
    bool load_data_blob(U8VecRef data) const;
    String get_language(String locale) const;
    String format_integer(String locale, int64_t value) const;
    String format_decimal(String locale, int64_t integer_part, int16_t decimal_places) const;
    AzPluralCategory get_plural_category(String locale, int64_t value) const;
    String pluralize(String locale, int64_t value, String zero, String one, String two, String few, String many, String other) const;
    AzIcuResult format_date(String locale, IcuDate date, AzFormatLength length) const;
    AzIcuResult format_time(String locale, IcuTime time, bool include_seconds) const;
    AzIcuResult format_datetime(String locale, IcuDateTime datetime, AzFormatLength length) const;
    int32_t compare_strings(String locale, String a, String b) const;
    bool strings_equal(String locale, String a, String b) const;
    String format_plural(String locale, int64_t value, String zero, String one, String other) const;
    void clear_cache() const;
    size_t cached_locale_count() const;
    void delete_();
    IcuLocalizerHandle clone() const;
    String toDbgString() const;

    const AzIcuLocalizerHandle& inner() const { return inner_; }
    AzIcuLocalizerHandle& inner() { return inner_; }
    const AzIcuLocalizerHandle* ptr() const { return &inner_; }
    AzIcuLocalizerHandle* ptr() { return &inner_; }
    AzIcuLocalizerHandle release() { AzIcuLocalizerHandle result = inner_; inner_ = {}; return result; }
    operator AzIcuLocalizerHandle() && noexcept { AzIcuLocalizerHandle result = inner_; inner_ = {}; return result; }
};

class FluentLocalizerHandle {
private:
    AzFluentLocalizerHandle inner_;

    FluentLocalizerHandle(const FluentLocalizerHandle&) = delete;
    FluentLocalizerHandle& operator=(const FluentLocalizerHandle&) = delete;

public:
    explicit FluentLocalizerHandle(AzFluentLocalizerHandle inner) noexcept : inner_(inner) {}

    FluentLocalizerHandle(FluentLocalizerHandle&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FluentLocalizerHandle& operator=(FluentLocalizerHandle&& other) noexcept {
        if (this != &other) {
            AzFluentLocalizerHandle_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FluentLocalizerHandle() { AzFluentLocalizerHandle_delete(&inner_); }

    [[nodiscard]] static FluentLocalizerHandle create(String default_locale);
    [[nodiscard]] static FluentLocalizerHandle default_();

    String get_default_locale() const;
    void set_default_locale(String locale) const;
    bool add_resource(String locale, String source) const;
    bool add_resource_from_bytes(String locale, U8VecRef data) const;
    FluentZipLoadResult load_from_zip(U8VecRef data) const;
    String translate(String locale, String message_id, FmtArgVec args) const;
    bool has_message(String locale, String message_id) const;
    StringVec get_loaded_locales() const;
    void clear_locale(String locale) const;
    void clear_all() const;
    void delete_();
    FluentLocalizerHandle clone() const;
    String toDbgString() const;

    const AzFluentLocalizerHandle& inner() const { return inner_; }
    AzFluentLocalizerHandle& inner() { return inner_; }
    const AzFluentLocalizerHandle* ptr() const { return &inner_; }
    AzFluentLocalizerHandle* ptr() { return &inner_; }
    AzFluentLocalizerHandle release() { AzFluentLocalizerHandle result = inner_; inner_ = {}; return result; }
    operator AzFluentLocalizerHandle() && noexcept { AzFluentLocalizerHandle result = inner_; inner_ = {}; return result; }
};

class ComponentDataFieldVecSlice {
private:
    AzComponentDataFieldVecSlice inner_;

public:
    ComponentDataFieldVecSlice(AzComponentDataFieldVecSlice inner) noexcept : inner_(inner) {}
    ComponentDataFieldVecSlice(const ComponentDataFieldVecSlice& other) noexcept : inner_(other.inner_) {}
    ComponentDataFieldVecSlice& operator=(const ComponentDataFieldVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ComponentDataFieldVecSlice() {}

    String toDbgString() const;

    const AzComponentDataFieldVecSlice& inner() const { return inner_; }
    AzComponentDataFieldVecSlice& inner() { return inner_; }
    const AzComponentDataFieldVecSlice* ptr() const { return &inner_; }
    AzComponentDataFieldVecSlice* ptr() { return &inner_; }
    AzComponentDataFieldVecSlice release() { AzComponentDataFieldVecSlice result = inner_; inner_ = {}; return result; }
    operator AzComponentDataFieldVecSlice() && noexcept { AzComponentDataFieldVecSlice result = inner_; inner_ = {}; return result; }
};

class ComponentLibraryVecSlice {
private:
    AzComponentLibraryVecSlice inner_;

public:
    ComponentLibraryVecSlice(AzComponentLibraryVecSlice inner) noexcept : inner_(inner) {}
    ComponentLibraryVecSlice(const ComponentLibraryVecSlice& other) noexcept : inner_(other.inner_) {}
    ComponentLibraryVecSlice& operator=(const ComponentLibraryVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ComponentLibraryVecSlice() {}

    String toDbgString() const;

    const AzComponentLibraryVecSlice& inner() const { return inner_; }
    AzComponentLibraryVecSlice& inner() { return inner_; }
    const AzComponentLibraryVecSlice* ptr() const { return &inner_; }
    AzComponentLibraryVecSlice* ptr() { return &inner_; }
    AzComponentLibraryVecSlice release() { AzComponentLibraryVecSlice result = inner_; inner_ = {}; return result; }
    operator AzComponentLibraryVecSlice() && noexcept { AzComponentLibraryVecSlice result = inner_; inner_ = {}; return result; }
};

class ComponentDefVecSlice {
private:
    AzComponentDefVecSlice inner_;

public:
    ComponentDefVecSlice(AzComponentDefVecSlice inner) noexcept : inner_(inner) {}
    ComponentDefVecSlice(const ComponentDefVecSlice& other) noexcept : inner_(other.inner_) {}
    ComponentDefVecSlice& operator=(const ComponentDefVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ComponentDefVecSlice() {}

    String toDbgString() const;

    const AzComponentDefVecSlice& inner() const { return inner_; }
    AzComponentDefVecSlice& inner() { return inner_; }
    const AzComponentDefVecSlice* ptr() const { return &inner_; }
    AzComponentDefVecSlice* ptr() { return &inner_; }
    AzComponentDefVecSlice release() { AzComponentDefVecSlice result = inner_; inner_ = {}; return result; }
    operator AzComponentDefVecSlice() && noexcept { AzComponentDefVecSlice result = inner_; inner_ = {}; return result; }
};

class ComponentDataModelVecSlice {
private:
    AzComponentDataModelVecSlice inner_;

public:
    ComponentDataModelVecSlice(AzComponentDataModelVecSlice inner) noexcept : inner_(inner) {}
    ComponentDataModelVecSlice(const ComponentDataModelVecSlice& other) noexcept : inner_(other.inner_) {}
    ComponentDataModelVecSlice& operator=(const ComponentDataModelVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ComponentDataModelVecSlice() {}

    String toDbgString() const;

    const AzComponentDataModelVecSlice& inner() const { return inner_; }
    AzComponentDataModelVecSlice& inner() { return inner_; }
    const AzComponentDataModelVecSlice* ptr() const { return &inner_; }
    AzComponentDataModelVecSlice* ptr() { return &inner_; }
    AzComponentDataModelVecSlice release() { AzComponentDataModelVecSlice result = inner_; inner_ = {}; return result; }
    operator AzComponentDataModelVecSlice() && noexcept { AzComponentDataModelVecSlice result = inner_; inner_ = {}; return result; }
};

class ComponentEnumVariantVecSlice {
private:
    AzComponentEnumVariantVecSlice inner_;

public:
    ComponentEnumVariantVecSlice(AzComponentEnumVariantVecSlice inner) noexcept : inner_(inner) {}
    ComponentEnumVariantVecSlice(const ComponentEnumVariantVecSlice& other) noexcept : inner_(other.inner_) {}
    ComponentEnumVariantVecSlice& operator=(const ComponentEnumVariantVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ComponentEnumVariantVecSlice() {}

    String toDbgString() const;

    const AzComponentEnumVariantVecSlice& inner() const { return inner_; }
    AzComponentEnumVariantVecSlice& inner() { return inner_; }
    const AzComponentEnumVariantVecSlice* ptr() const { return &inner_; }
    AzComponentEnumVariantVecSlice* ptr() { return &inner_; }
    AzComponentEnumVariantVecSlice release() { AzComponentEnumVariantVecSlice result = inner_; inner_ = {}; return result; }
    operator AzComponentEnumVariantVecSlice() && noexcept { AzComponentEnumVariantVecSlice result = inner_; inner_ = {}; return result; }
};

class ComponentFieldTypeBox {
private:
    AzComponentFieldTypeBox inner_;

    ComponentFieldTypeBox(const ComponentFieldTypeBox&) = delete;
    ComponentFieldTypeBox& operator=(const ComponentFieldTypeBox&) = delete;

public:
    explicit ComponentFieldTypeBox(AzComponentFieldTypeBox inner) noexcept : inner_(inner) {}

    ComponentFieldTypeBox(ComponentFieldTypeBox&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentFieldTypeBox& operator=(ComponentFieldTypeBox&& other) noexcept {
        if (this != &other) {
            AzComponentFieldTypeBox_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentFieldTypeBox() { AzComponentFieldTypeBox_delete(&inner_); }

    void delete_();
    ComponentFieldTypeBox clone() const;
    bool partialEq(const ComponentFieldTypeBox& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ComponentFieldTypeBox& b) const;
    uint8_t cmp(const ComponentFieldTypeBox& b) const;
    String toDbgString() const;

    const AzComponentFieldTypeBox& inner() const { return inner_; }
    AzComponentFieldTypeBox& inner() { return inner_; }
    const AzComponentFieldTypeBox* ptr() const { return &inner_; }
    AzComponentFieldTypeBox* ptr() { return &inner_; }
    AzComponentFieldTypeBox release() { AzComponentFieldTypeBox result = inner_; inner_ = {}; return result; }
    operator AzComponentFieldTypeBox() && noexcept { AzComponentFieldTypeBox result = inner_; inner_ = {}; return result; }
};

class ComponentEnumModelVecSlice {
private:
    AzComponentEnumModelVecSlice inner_;

public:
    ComponentEnumModelVecSlice(AzComponentEnumModelVecSlice inner) noexcept : inner_(inner) {}
    ComponentEnumModelVecSlice(const ComponentEnumModelVecSlice& other) noexcept : inner_(other.inner_) {}
    ComponentEnumModelVecSlice& operator=(const ComponentEnumModelVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ComponentEnumModelVecSlice() {}

    String toDbgString() const;

    const AzComponentEnumModelVecSlice& inner() const { return inner_; }
    AzComponentEnumModelVecSlice& inner() { return inner_; }
    const AzComponentEnumModelVecSlice* ptr() const { return &inner_; }
    AzComponentEnumModelVecSlice* ptr() { return &inner_; }
    AzComponentEnumModelVecSlice release() { AzComponentEnumModelVecSlice result = inner_; inner_ = {}; return result; }
    operator AzComponentEnumModelVecSlice() && noexcept { AzComponentEnumModelVecSlice result = inner_; inner_ = {}; return result; }
};

class ComponentFieldOverrideVecSlice {
private:
    AzComponentFieldOverrideVecSlice inner_;

public:
    ComponentFieldOverrideVecSlice(AzComponentFieldOverrideVecSlice inner) noexcept : inner_(inner) {}
    ComponentFieldOverrideVecSlice(const ComponentFieldOverrideVecSlice& other) noexcept : inner_(other.inner_) {}
    ComponentFieldOverrideVecSlice& operator=(const ComponentFieldOverrideVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ComponentFieldOverrideVecSlice() {}

    String toDbgString() const;

    const AzComponentFieldOverrideVecSlice& inner() const { return inner_; }
    AzComponentFieldOverrideVecSlice& inner() { return inner_; }
    const AzComponentFieldOverrideVecSlice* ptr() const { return &inner_; }
    AzComponentFieldOverrideVecSlice* ptr() { return &inner_; }
    AzComponentFieldOverrideVecSlice release() { AzComponentFieldOverrideVecSlice result = inner_; inner_ = {}; return result; }
    operator AzComponentFieldOverrideVecSlice() && noexcept { AzComponentFieldOverrideVecSlice result = inner_; inner_ = {}; return result; }
};

class ComponentCallbackArgVecSlice {
private:
    AzComponentCallbackArgVecSlice inner_;

public:
    ComponentCallbackArgVecSlice(AzComponentCallbackArgVecSlice inner) noexcept : inner_(inner) {}
    ComponentCallbackArgVecSlice(const ComponentCallbackArgVecSlice& other) noexcept : inner_(other.inner_) {}
    ComponentCallbackArgVecSlice& operator=(const ComponentCallbackArgVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ComponentCallbackArgVecSlice() {}

    String toDbgString() const;

    const AzComponentCallbackArgVecSlice& inner() const { return inner_; }
    AzComponentCallbackArgVecSlice& inner() { return inner_; }
    const AzComponentCallbackArgVecSlice* ptr() const { return &inner_; }
    AzComponentCallbackArgVecSlice* ptr() { return &inner_; }
    AzComponentCallbackArgVecSlice release() { AzComponentCallbackArgVecSlice result = inner_; inner_ = {}; return result; }
    operator AzComponentCallbackArgVecSlice() && noexcept { AzComponentCallbackArgVecSlice result = inner_; inner_ = {}; return result; }
};

class DpiScaleFactor {
private:
    AzDpiScaleFactor inner_;

public:
    DpiScaleFactor(AzDpiScaleFactor inner) noexcept : inner_(inner) {}
    DpiScaleFactor(const DpiScaleFactor& other) noexcept : inner_(other.inner_) {}
    DpiScaleFactor& operator=(const DpiScaleFactor& other) noexcept { inner_ = other.inner_; return *this; }
    ~DpiScaleFactor() {}

    bool partialEq(const DpiScaleFactor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const DpiScaleFactor& b) const;
    uint8_t cmp(const DpiScaleFactor& b) const;
    String toDbgString() const;

    const AzDpiScaleFactor& inner() const { return inner_; }
    AzDpiScaleFactor& inner() { return inner_; }
    const AzDpiScaleFactor* ptr() const { return &inner_; }
    AzDpiScaleFactor* ptr() { return &inner_; }
    AzDpiScaleFactor release() { AzDpiScaleFactor result = inner_; inner_ = {}; return result; }
    operator AzDpiScaleFactor() && noexcept { AzDpiScaleFactor result = inner_; inner_ = {}; return result; }
};

class WindowFlags {
private:
    AzWindowFlags inner_;

public:
    WindowFlags(AzWindowFlags inner) noexcept : inner_(inner) {}
    WindowFlags(const WindowFlags& other) noexcept : inner_(other.inner_) {}
    WindowFlags& operator=(const WindowFlags& other) noexcept { inner_ = other.inner_; return *this; }
    ~WindowFlags() {}

    [[nodiscard]] static WindowFlags default_();

    bool partialEq(const WindowFlags& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const WindowFlags& b) const;
    uint8_t cmp(const WindowFlags& b) const;
    String toDbgString() const;

    const AzWindowFlags& inner() const { return inner_; }
    AzWindowFlags& inner() { return inner_; }
    const AzWindowFlags* ptr() const { return &inner_; }
    AzWindowFlags* ptr() { return &inner_; }
    AzWindowFlags release() { AzWindowFlags result = inner_; inner_ = {}; return result; }
    operator AzWindowFlags() && noexcept { AzWindowFlags result = inner_; inner_ = {}; return result; }
};

class VideoMode {
private:
    AzVideoMode inner_;

public:
    VideoMode(AzVideoMode inner) noexcept : inner_(inner) {}
    VideoMode(const VideoMode& other) noexcept : inner_(other.inner_) {}
    VideoMode& operator=(const VideoMode& other) noexcept { inner_ = other.inner_; return *this; }
    ~VideoMode() {}

    bool partialEq(const VideoMode& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const VideoMode& b) const;
    uint8_t cmp(const VideoMode& b) const;
    String toDbgString() const;

    const AzVideoMode& inner() const { return inner_; }
    AzVideoMode& inner() { return inner_; }
    const AzVideoMode* ptr() const { return &inner_; }
    AzVideoMode* ptr() { return &inner_; }
    AzVideoMode release() { AzVideoMode result = inner_; inner_ = {}; return result; }
    operator AzVideoMode() && noexcept { AzVideoMode result = inner_; inner_ = {}; return result; }
};

class TextCursor {
private:
    AzTextCursor inner_;

public:
    TextCursor(AzTextCursor inner) noexcept : inner_(inner) {}
    TextCursor(const TextCursor& other) noexcept : inner_(other.inner_) {}
    TextCursor& operator=(const TextCursor& other) noexcept { inner_ = other.inner_; return *this; }
    ~TextCursor() {}

    bool partialEq(const TextCursor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TextCursor& b) const;
    uint8_t cmp(const TextCursor& b) const;
    String toDbgString() const;

    const AzTextCursor& inner() const { return inner_; }
    AzTextCursor& inner() { return inner_; }
    const AzTextCursor* ptr() const { return &inner_; }
    AzTextCursor* ptr() { return &inner_; }
    AzTextCursor release() { AzTextCursor result = inner_; inner_ = {}; return result; }
    operator AzTextCursor() && noexcept { AzTextCursor result = inner_; inner_ = {}; return result; }
};

class XWindowTypeVecSlice {
private:
    AzXWindowTypeVecSlice inner_;

public:
    XWindowTypeVecSlice(AzXWindowTypeVecSlice inner) noexcept : inner_(inner) {}
    XWindowTypeVecSlice(const XWindowTypeVecSlice& other) noexcept : inner_(other.inner_) {}
    XWindowTypeVecSlice& operator=(const XWindowTypeVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~XWindowTypeVecSlice() {}

    String toDbgString() const;

    const AzXWindowTypeVecSlice& inner() const { return inner_; }
    AzXWindowTypeVecSlice& inner() { return inner_; }
    const AzXWindowTypeVecSlice* ptr() const { return &inner_; }
    AzXWindowTypeVecSlice* ptr() { return &inner_; }
    AzXWindowTypeVecSlice release() { AzXWindowTypeVecSlice result = inner_; inner_ = {}; return result; }
    operator AzXWindowTypeVecSlice() && noexcept { AzXWindowTypeVecSlice result = inner_; inner_ = {}; return result; }
};

class TouchPoint {
private:
    AzTouchPoint inner_;

public:
    TouchPoint(AzTouchPoint inner) noexcept : inner_(inner) {}
    TouchPoint(const TouchPoint& other) noexcept : inner_(other.inner_) {}
    TouchPoint& operator=(const TouchPoint& other) noexcept { inner_ = other.inner_; return *this; }
    ~TouchPoint() {}

    bool partialEq(const TouchPoint& b) const;
    uint8_t partialCmp(const TouchPoint& b) const;
    String toDbgString() const;

    const AzTouchPoint& inner() const { return inner_; }
    AzTouchPoint& inner() { return inner_; }
    const AzTouchPoint* ptr() const { return &inner_; }
    AzTouchPoint* ptr() { return &inner_; }
    AzTouchPoint release() { AzTouchPoint result = inner_; inner_ = {}; return result; }
    operator AzTouchPoint() && noexcept { AzTouchPoint result = inner_; inner_ = {}; return result; }
};

class DetectedPinch {
private:
    AzDetectedPinch inner_;

public:
    DetectedPinch(AzDetectedPinch inner) noexcept : inner_(inner) {}
    DetectedPinch(const DetectedPinch& other) noexcept : inner_(other.inner_) {}
    DetectedPinch& operator=(const DetectedPinch& other) noexcept { inner_ = other.inner_; return *this; }
    ~DetectedPinch() {}

    bool partialEq(const DetectedPinch& b) const;
    String toDbgString() const;

    const AzDetectedPinch& inner() const { return inner_; }
    AzDetectedPinch& inner() { return inner_; }
    const AzDetectedPinch* ptr() const { return &inner_; }
    AzDetectedPinch* ptr() { return &inner_; }
    AzDetectedPinch release() { AzDetectedPinch result = inner_; inner_ = {}; return result; }
    operator AzDetectedPinch() && noexcept { AzDetectedPinch result = inner_; inner_ = {}; return result; }
};

class TimerCallbackReturn {
private:
    AzTimerCallbackReturn inner_;

public:
    TimerCallbackReturn(AzTimerCallbackReturn inner) noexcept : inner_(inner) {}
    TimerCallbackReturn(const TimerCallbackReturn& other) noexcept : inner_(other.inner_) {}
    TimerCallbackReturn& operator=(const TimerCallbackReturn& other) noexcept { inner_ = other.inner_; return *this; }
    ~TimerCallbackReturn() {}

    [[nodiscard]] static TimerCallbackReturn create(AzUpdate should_update, AzTerminateTimer should_terminate);
    [[nodiscard]] static TimerCallbackReturn continue_unchanged();
    [[nodiscard]] static TimerCallbackReturn continue_and_refresh_dom();
    [[nodiscard]] static TimerCallbackReturn terminate_unchanged();
    [[nodiscard]] static TimerCallbackReturn terminate_and_refresh_dom();
    [[nodiscard]] static TimerCallbackReturn default_();

    bool partialEq(const TimerCallbackReturn& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TimerCallbackReturn& b) const;
    uint8_t cmp(const TimerCallbackReturn& b) const;
    String toDbgString() const;

    const AzTimerCallbackReturn& inner() const { return inner_; }
    AzTimerCallbackReturn& inner() { return inner_; }
    const AzTimerCallbackReturn* ptr() const { return &inner_; }
    AzTimerCallbackReturn* ptr() { return &inner_; }
    AzTimerCallbackReturn release() { AzTimerCallbackReturn result = inner_; inner_ = {}; return result; }
    operator AzTimerCallbackReturn() && noexcept { AzTimerCallbackReturn result = inner_; inner_ = {}; return result; }
};

class RefAny {
private:
    AzRefAny inner_;

    RefAny(const RefAny&) = delete;
    RefAny& operator=(const RefAny&) = delete;

public:
    explicit RefAny(AzRefAny inner) noexcept : inner_(inner) {}

    RefAny(RefAny&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RefAny& operator=(RefAny&& other) noexcept {
        if (this != &other) {
            AzRefAny_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RefAny() { AzRefAny_delete(&inner_); }

    [[nodiscard]] static RefAny new_c(GlVoidPtrConst ptr, size_t len, size_t align, uint64_t type_id, String type_name, AzRefAnyDestructorType destructor, size_t serialize_fn, size_t deserialize_fn);

    const void* get_data_ptr() const;
    uint64_t get_type_id() const;
    bool is_type(uint64_t type_id) const;
    void set_serialize_fn(size_t serialize_fn);
    void set_deserialize_fn(size_t deserialize_fn);
    bool replace_contents(RefAny new_value);
    bool can_serialize() const;
    bool can_deserialize() const;
    size_t get_serialize_fn() const;
    size_t get_deserialize_fn() const;
    OptionJson serialize_to_json() const;
    void delete_();
    RefAny clone() const;
    bool partialEq(const RefAny& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const RefAny& b) const;
    uint8_t cmp(const RefAny& b) const;
    String toDbgString() const;

    const AzRefAny& inner() const { return inner_; }
    AzRefAny& inner() { return inner_; }
    const AzRefAny* ptr() const { return &inner_; }
    AzRefAny* ptr() { return &inner_; }
    AzRefAny release() { AzRefAny result = inner_; inner_ = {}; return result; }
    operator AzRefAny() && noexcept { AzRefAny result = inner_; inner_ = {}; return result; }

    // Template-based reflection - C++11+ replacement for AZ_REFLECT.
    /// Per-type runtime tag - unique per T, stable across translation units.
    template<ReflectableModel T>
    static uint64_t type_id() noexcept {
        return reinterpret_cast<uint64_t>(&detail::type_id_holder<T>::value);
    }

    /// Variable-template shorthand for `type_id<T>()` (C++14+).
    template<ReflectableModel T>
    static inline const uint64_t type_id_v = reinterpret_cast<uint64_t>(&detail::type_id_holder<T>::value);

    /// Move T into a heap allocation and wrap it as a RefAny. The Rust-side
    /// equivalent of `RefAny::new(model)`.
    template<ReflectableModel T>
    static RefAny create(T model) {
        T* heap = new T(std::move(model));
        AzGlVoidPtrConst ptr = { heap, true };
        AzString name = az_string_from_literal("");
        return RefAny(AzRefAny_newC(
            ptr,
            sizeof(T),
            alignof(T),
            RefAny::type_id<T>(),
            name,
            &detail::type_destructor<T>,
            0,
            0
        ));
    }

    /// Read-only borrow of the T inside this RefAny. nullptr on type mismatch.
    template<ReflectableModel T>
    const T* downcast_ref() const noexcept {
        if (!AzRefAny_isType(&inner_, RefAny::type_id<T>())) return nullptr;
        return static_cast<const T*>(AzRefAny_getDataPtr(&inner_));
    }

    /// Mutable borrow of the T inside this RefAny. nullptr on type mismatch.
    template<ReflectableModel T>
    T* downcast_mut() noexcept {
        if (!AzRefAny_isType(&inner_, RefAny::type_id<T>())) return nullptr;
        return static_cast<T*>(const_cast<void*>(AzRefAny_getDataPtr(&inner_)));
    }
};

class PenState {
private:
    AzPenState inner_;

public:
    PenState(AzPenState inner) noexcept : inner_(inner) {}
    PenState(const PenState& other) noexcept : inner_(other.inner_) {}
    PenState& operator=(const PenState& other) noexcept { inner_ = other.inner_; return *this; }
    ~PenState() {}

    [[nodiscard]] static PenState default_();

    bool partialEq(const PenState& b) const;
    String toDbgString() const;

    const AzPenState& inner() const { return inner_; }
    AzPenState& inner() { return inner_; }
    const AzPenState* ptr() const { return &inner_; }
    AzPenState* ptr() { return &inner_; }
    AzPenState release() { AzPenState result = inner_; inner_ = {}; return result; }
    operator AzPenState() && noexcept { AzPenState result = inner_; inner_ = {}; return result; }
};

class ScrollState {
private:
    AzScrollState inner_;

public:
    ScrollState(AzScrollState inner) noexcept : inner_(inner) {}
    ScrollState(const ScrollState& other) noexcept : inner_(other.inner_) {}
    ScrollState& operator=(const ScrollState& other) noexcept { inner_ = other.inner_; return *this; }
    ~ScrollState() {}

    [[nodiscard]] static ScrollState default_();

    bool partialEq(const ScrollState& b) const;
    uint8_t partialCmp(const ScrollState& b) const;
    String toDbgString() const;

    const AzScrollState& inner() const { return inner_; }
    AzScrollState& inner() { return inner_; }
    const AzScrollState* ptr() const { return &inner_; }
    AzScrollState* ptr() { return &inner_; }
    AzScrollState release() { AzScrollState result = inner_; inner_ = {}; return result; }
    operator AzScrollState() && noexcept { AzScrollState result = inner_; inner_ = {}; return result; }
};

class DomNodeId {
private:
    AzDomNodeId inner_;

public:
    DomNodeId(AzDomNodeId inner) noexcept : inner_(inner) {}
    DomNodeId(const DomNodeId& other) noexcept : inner_(other.inner_) {}
    DomNodeId& operator=(const DomNodeId& other) noexcept { inner_ = other.inner_; return *this; }
    ~DomNodeId() {}

    bool partialEq(const DomNodeId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const DomNodeId& b) const;
    uint8_t cmp(const DomNodeId& b) const;
    String toDbgString() const;

    const AzDomNodeId& inner() const { return inner_; }
    AzDomNodeId& inner() { return inner_; }
    const AzDomNodeId* ptr() const { return &inner_; }
    AzDomNodeId* ptr() { return &inner_; }
    AzDomNodeId release() { AzDomNodeId result = inner_; inner_ = {}; return result; }
    operator AzDomNodeId() && noexcept { AzDomNodeId result = inner_; inner_ = {}; return result; }
};

class ParentWithNodeDepth {
private:
    AzParentWithNodeDepth inner_;

public:
    ParentWithNodeDepth(AzParentWithNodeDepth inner) noexcept : inner_(inner) {}
    ParentWithNodeDepth(const ParentWithNodeDepth& other) noexcept : inner_(other.inner_) {}
    ParentWithNodeDepth& operator=(const ParentWithNodeDepth& other) noexcept { inner_ = other.inner_; return *this; }
    ~ParentWithNodeDepth() {}

    bool partialEq(const ParentWithNodeDepth& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ParentWithNodeDepth& b) const;
    uint8_t cmp(const ParentWithNodeDepth& b) const;
    String toDbgString() const;

    const AzParentWithNodeDepth& inner() const { return inner_; }
    AzParentWithNodeDepth& inner() { return inner_; }
    const AzParentWithNodeDepth* ptr() const { return &inner_; }
    AzParentWithNodeDepth* ptr() { return &inner_; }
    AzParentWithNodeDepth release() { AzParentWithNodeDepth result = inner_; inner_ = {}; return result; }
    operator AzParentWithNodeDepth() && noexcept { AzParentWithNodeDepth result = inner_; inner_ = {}; return result; }
};

class SelectionColor {
private:
    AzSelectionColor inner_;

public:
    SelectionColor(AzSelectionColor inner) noexcept : inner_(inner) {}
    SelectionColor(const SelectionColor& other) noexcept : inner_(other.inner_) {}
    SelectionColor& operator=(const SelectionColor& other) noexcept { inner_ = other.inner_; return *this; }
    ~SelectionColor() {}

    [[nodiscard]] static SelectionColor default_();

    bool partialEq(const SelectionColor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const SelectionColor& b) const;
    uint8_t cmp(const SelectionColor& b) const;
    String toDbgString() const;

    const AzSelectionColor& inner() const { return inner_; }
    AzSelectionColor& inner() { return inner_; }
    const AzSelectionColor* ptr() const { return &inner_; }
    AzSelectionColor* ptr() { return &inner_; }
    AzSelectionColor release() { AzSelectionColor result = inner_; inner_ = {}; return result; }
    operator AzSelectionColor() && noexcept { AzSelectionColor result = inner_; inner_ = {}; return result; }
};

class VirtualKeyCodeVecSlice {
private:
    AzVirtualKeyCodeVecSlice inner_;

public:
    VirtualKeyCodeVecSlice(AzVirtualKeyCodeVecSlice inner) noexcept : inner_(inner) {}
    VirtualKeyCodeVecSlice(const VirtualKeyCodeVecSlice& other) noexcept : inner_(other.inner_) {}
    VirtualKeyCodeVecSlice& operator=(const VirtualKeyCodeVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~VirtualKeyCodeVecSlice() {}

    String toDbgString() const;

    const AzVirtualKeyCodeVecSlice& inner() const { return inner_; }
    AzVirtualKeyCodeVecSlice& inner() { return inner_; }
    const AzVirtualKeyCodeVecSlice* ptr() const { return &inner_; }
    AzVirtualKeyCodeVecSlice* ptr() { return &inner_; }
    AzVirtualKeyCodeVecSlice release() { AzVirtualKeyCodeVecSlice result = inner_; inner_ = {}; return result; }
    operator AzVirtualKeyCodeVecSlice() && noexcept { AzVirtualKeyCodeVecSlice result = inner_; inner_ = {}; return result; }
};

class AccessibilityStateVecSlice {
private:
    AzAccessibilityStateVecSlice inner_;

public:
    AccessibilityStateVecSlice(AzAccessibilityStateVecSlice inner) noexcept : inner_(inner) {}
    AccessibilityStateVecSlice(const AccessibilityStateVecSlice& other) noexcept : inner_(other.inner_) {}
    AccessibilityStateVecSlice& operator=(const AccessibilityStateVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~AccessibilityStateVecSlice() {}

    String toDbgString() const;

    const AzAccessibilityStateVecSlice& inner() const { return inner_; }
    AzAccessibilityStateVecSlice& inner() { return inner_; }
    const AzAccessibilityStateVecSlice* ptr() const { return &inner_; }
    AzAccessibilityStateVecSlice* ptr() { return &inner_; }
    AzAccessibilityStateVecSlice release() { AzAccessibilityStateVecSlice result = inner_; inner_ = {}; return result; }
    operator AzAccessibilityStateVecSlice() && noexcept { AzAccessibilityStateVecSlice result = inner_; inner_ = {}; return result; }
};

class ScanCodeVecSlice {
private:
    AzScanCodeVecSlice inner_;

public:
    ScanCodeVecSlice(AzScanCodeVecSlice inner) noexcept : inner_(inner) {}
    ScanCodeVecSlice(const ScanCodeVecSlice& other) noexcept : inner_(other.inner_) {}
    ScanCodeVecSlice& operator=(const ScanCodeVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~ScanCodeVecSlice() {}

    String toDbgString() const;

    const AzScanCodeVecSlice& inner() const { return inner_; }
    AzScanCodeVecSlice& inner() { return inner_; }
    const AzScanCodeVecSlice* ptr() const { return &inner_; }
    AzScanCodeVecSlice* ptr() { return &inner_; }
    AzScanCodeVecSlice release() { AzScanCodeVecSlice result = inner_; inner_ = {}; return result; }
    operator AzScanCodeVecSlice() && noexcept { AzScanCodeVecSlice result = inner_; inner_ = {}; return result; }
};

class PixelValue {
private:
    AzPixelValue inner_;

public:
    PixelValue(AzPixelValue inner) noexcept : inner_(inner) {}
    PixelValue(const PixelValue& other) noexcept : inner_(other.inner_) {}
    PixelValue& operator=(const PixelValue& other) noexcept { inner_ = other.inner_; return *this; }
    ~PixelValue() {}

    [[nodiscard]] static PixelValue zero();
    [[nodiscard]] static PixelValue px(float value);
    [[nodiscard]] static PixelValue em(float value);
    [[nodiscard]] static PixelValue rem(float value);
    [[nodiscard]] static PixelValue pt(float value);
    [[nodiscard]] static PixelValue percent(float value);
    [[nodiscard]] static PixelValue from_metric(AzSizeMetric metric, float value);
    [[nodiscard]] static PixelValue default_();

    bool partialEq(const PixelValue& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const PixelValue& b) const;
    uint8_t cmp(const PixelValue& b) const;
    String toDbgString() const;

    const AzPixelValue& inner() const { return inner_; }
    AzPixelValue& inner() { return inner_; }
    const AzPixelValue* ptr() const { return &inner_; }
    AzPixelValue* ptr() { return &inner_; }
    AzPixelValue release() { AzPixelValue result = inner_; inner_ = {}; return result; }
    operator AzPixelValue() && noexcept { AzPixelValue result = inner_; inner_ = {}; return result; }
};

class StyleColorMatrix {
private:
    AzStyleColorMatrix inner_;

    StyleColorMatrix(const StyleColorMatrix&) = delete;
    StyleColorMatrix& operator=(const StyleColorMatrix&) = delete;

public:
    explicit StyleColorMatrix(AzStyleColorMatrix inner) noexcept : inner_(inner) {}

    StyleColorMatrix(StyleColorMatrix&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyleColorMatrix& operator=(StyleColorMatrix&& other) noexcept {
        if (this != &other) {
            AzStyleColorMatrix_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyleColorMatrix() { AzStyleColorMatrix_delete(&inner_); }

    void delete_();
    StyleColorMatrix clone() const;
    bool partialEq(const StyleColorMatrix& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleColorMatrix& b) const;
    uint8_t cmp(const StyleColorMatrix& b) const;
    String toDbgString() const;

    const AzStyleColorMatrix& inner() const { return inner_; }
    AzStyleColorMatrix& inner() { return inner_; }
    const AzStyleColorMatrix* ptr() const { return &inner_; }
    AzStyleColorMatrix* ptr() { return &inner_; }
    AzStyleColorMatrix release() { AzStyleColorMatrix result = inner_; inner_ = {}; return result; }
    operator AzStyleColorMatrix() && noexcept { AzStyleColorMatrix result = inner_; inner_ = {}; return result; }
};

class LayoutFlexGrow {
private:
    AzLayoutFlexGrow inner_;

public:
    LayoutFlexGrow(AzLayoutFlexGrow inner) noexcept : inner_(inner) {}
    LayoutFlexGrow(const LayoutFlexGrow& other) noexcept : inner_(other.inner_) {}
    LayoutFlexGrow& operator=(const LayoutFlexGrow& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutFlexGrow() {}

    [[nodiscard]] static LayoutFlexGrow create(float value);
    [[nodiscard]] static LayoutFlexGrow default_();

    bool partialEq(const LayoutFlexGrow& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutFlexGrow& b) const;
    uint8_t cmp(const LayoutFlexGrow& b) const;
    String toDbgString() const;

    const AzLayoutFlexGrow& inner() const { return inner_; }
    AzLayoutFlexGrow& inner() { return inner_; }
    const AzLayoutFlexGrow* ptr() const { return &inner_; }
    AzLayoutFlexGrow* ptr() { return &inner_; }
    AzLayoutFlexGrow release() { AzLayoutFlexGrow result = inner_; inner_ = {}; return result; }
    operator AzLayoutFlexGrow() && noexcept { AzLayoutFlexGrow result = inner_; inner_ = {}; return result; }
};

class LayoutFlexShrink {
private:
    AzLayoutFlexShrink inner_;

public:
    LayoutFlexShrink(AzLayoutFlexShrink inner) noexcept : inner_(inner) {}
    LayoutFlexShrink(const LayoutFlexShrink& other) noexcept : inner_(other.inner_) {}
    LayoutFlexShrink& operator=(const LayoutFlexShrink& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutFlexShrink() {}

    [[nodiscard]] static LayoutFlexShrink default_();

    bool partialEq(const LayoutFlexShrink& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutFlexShrink& b) const;
    uint8_t cmp(const LayoutFlexShrink& b) const;
    String toDbgString() const;

    const AzLayoutFlexShrink& inner() const { return inner_; }
    AzLayoutFlexShrink& inner() { return inner_; }
    const AzLayoutFlexShrink* ptr() const { return &inner_; }
    AzLayoutFlexShrink* ptr() { return &inner_; }
    AzLayoutFlexShrink release() { AzLayoutFlexShrink result = inner_; inner_ = {}; return result; }
    operator AzLayoutFlexShrink() && noexcept { AzLayoutFlexShrink result = inner_; inner_ = {}; return result; }
};

class PercentageValue {
private:
    AzPercentageValue inner_;

public:
    PercentageValue(AzPercentageValue inner) noexcept : inner_(inner) {}
    PercentageValue(const PercentageValue& other) noexcept : inner_(other.inner_) {}
    PercentageValue& operator=(const PercentageValue& other) noexcept { inner_ = other.inner_; return *this; }
    ~PercentageValue() {}

    [[nodiscard]] static PercentageValue default_();

    bool partialEq(const PercentageValue& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const PercentageValue& b) const;
    uint8_t cmp(const PercentageValue& b) const;
    String toDbgString() const;

    const AzPercentageValue& inner() const { return inner_; }
    AzPercentageValue& inner() { return inner_; }
    const AzPercentageValue* ptr() const { return &inner_; }
    AzPercentageValue* ptr() { return &inner_; }
    AzPercentageValue release() { AzPercentageValue result = inner_; inner_ = {}; return result; }
    operator AzPercentageValue() && noexcept { AzPercentageValue result = inner_; inner_ = {}; return result; }
};

class AngleValue {
private:
    AzAngleValue inner_;

public:
    AngleValue(AzAngleValue inner) noexcept : inner_(inner) {}
    AngleValue(const AngleValue& other) noexcept : inner_(other.inner_) {}
    AngleValue& operator=(const AngleValue& other) noexcept { inner_ = other.inner_; return *this; }
    ~AngleValue() {}

    [[nodiscard]] static AngleValue default_();

    static AngleValue zero();
    static AngleValue deg(float value);
    static AngleValue rad(float value);
    static AngleValue grad(float value);
    static AngleValue turn(float value);
    float get_degrees() const;
    bool partialEq(const AngleValue& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const AngleValue& b) const;
    uint8_t cmp(const AngleValue& b) const;
    String toDbgString() const;

    const AzAngleValue& inner() const { return inner_; }
    AzAngleValue& inner() { return inner_; }
    const AzAngleValue* ptr() const { return &inner_; }
    AzAngleValue* ptr() { return &inner_; }
    AzAngleValue release() { AzAngleValue result = inner_; inner_ = {}; return result; }
    operator AzAngleValue() && noexcept { AzAngleValue result = inner_; inner_ = {}; return result; }
};

class DirectionCorners {
private:
    AzDirectionCorners inner_;

public:
    DirectionCorners(AzDirectionCorners inner) noexcept : inner_(inner) {}
    DirectionCorners(const DirectionCorners& other) noexcept : inner_(other.inner_) {}
    DirectionCorners& operator=(const DirectionCorners& other) noexcept { inner_ = other.inner_; return *this; }
    ~DirectionCorners() {}

    bool partialEq(const DirectionCorners& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const DirectionCorners& b) const;
    uint8_t cmp(const DirectionCorners& b) const;
    String toDbgString() const;

    const AzDirectionCorners& inner() const { return inner_; }
    AzDirectionCorners& inner() { return inner_; }
    const AzDirectionCorners* ptr() const { return &inner_; }
    AzDirectionCorners* ptr() { return &inner_; }
    AzDirectionCorners release() { AzDirectionCorners result = inner_; inner_ = {}; return result; }
    operator AzDirectionCorners() && noexcept { AzDirectionCorners result = inner_; inner_ = {}; return result; }
};

class StyleBorderBottomColor {
private:
    AzStyleBorderBottomColor inner_;

public:
    StyleBorderBottomColor(AzStyleBorderBottomColor inner) noexcept : inner_(inner) {}
    StyleBorderBottomColor(const StyleBorderBottomColor& other) noexcept : inner_(other.inner_) {}
    StyleBorderBottomColor& operator=(const StyleBorderBottomColor& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBorderBottomColor() {}

    bool partialEq(const StyleBorderBottomColor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBorderBottomColor& b) const;
    uint8_t cmp(const StyleBorderBottomColor& b) const;

    const AzStyleBorderBottomColor& inner() const { return inner_; }
    AzStyleBorderBottomColor& inner() { return inner_; }
    const AzStyleBorderBottomColor* ptr() const { return &inner_; }
    AzStyleBorderBottomColor* ptr() { return &inner_; }
    AzStyleBorderBottomColor release() { AzStyleBorderBottomColor result = inner_; inner_ = {}; return result; }
    operator AzStyleBorderBottomColor() && noexcept { AzStyleBorderBottomColor result = inner_; inner_ = {}; return result; }
};

class StyleBorderBottomStyle {
private:
    AzStyleBorderBottomStyle inner_;

public:
    StyleBorderBottomStyle(AzStyleBorderBottomStyle inner) noexcept : inner_(inner) {}
    StyleBorderBottomStyle(const StyleBorderBottomStyle& other) noexcept : inner_(other.inner_) {}
    StyleBorderBottomStyle& operator=(const StyleBorderBottomStyle& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBorderBottomStyle() {}

    bool partialEq(const StyleBorderBottomStyle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBorderBottomStyle& b) const;
    uint8_t cmp(const StyleBorderBottomStyle& b) const;

    const AzStyleBorderBottomStyle& inner() const { return inner_; }
    AzStyleBorderBottomStyle& inner() { return inner_; }
    const AzStyleBorderBottomStyle* ptr() const { return &inner_; }
    AzStyleBorderBottomStyle* ptr() { return &inner_; }
    AzStyleBorderBottomStyle release() { AzStyleBorderBottomStyle result = inner_; inner_ = {}; return result; }
    operator AzStyleBorderBottomStyle() && noexcept { AzStyleBorderBottomStyle result = inner_; inner_ = {}; return result; }
};

class StyleBorderLeftColor {
private:
    AzStyleBorderLeftColor inner_;

public:
    StyleBorderLeftColor(AzStyleBorderLeftColor inner) noexcept : inner_(inner) {}
    StyleBorderLeftColor(const StyleBorderLeftColor& other) noexcept : inner_(other.inner_) {}
    StyleBorderLeftColor& operator=(const StyleBorderLeftColor& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBorderLeftColor() {}

    bool partialEq(const StyleBorderLeftColor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBorderLeftColor& b) const;
    uint8_t cmp(const StyleBorderLeftColor& b) const;

    const AzStyleBorderLeftColor& inner() const { return inner_; }
    AzStyleBorderLeftColor& inner() { return inner_; }
    const AzStyleBorderLeftColor* ptr() const { return &inner_; }
    AzStyleBorderLeftColor* ptr() { return &inner_; }
    AzStyleBorderLeftColor release() { AzStyleBorderLeftColor result = inner_; inner_ = {}; return result; }
    operator AzStyleBorderLeftColor() && noexcept { AzStyleBorderLeftColor result = inner_; inner_ = {}; return result; }
};

class StyleBorderLeftStyle {
private:
    AzStyleBorderLeftStyle inner_;

public:
    StyleBorderLeftStyle(AzStyleBorderLeftStyle inner) noexcept : inner_(inner) {}
    StyleBorderLeftStyle(const StyleBorderLeftStyle& other) noexcept : inner_(other.inner_) {}
    StyleBorderLeftStyle& operator=(const StyleBorderLeftStyle& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBorderLeftStyle() {}

    bool partialEq(const StyleBorderLeftStyle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBorderLeftStyle& b) const;
    uint8_t cmp(const StyleBorderLeftStyle& b) const;

    const AzStyleBorderLeftStyle& inner() const { return inner_; }
    AzStyleBorderLeftStyle& inner() { return inner_; }
    const AzStyleBorderLeftStyle* ptr() const { return &inner_; }
    AzStyleBorderLeftStyle* ptr() { return &inner_; }
    AzStyleBorderLeftStyle release() { AzStyleBorderLeftStyle result = inner_; inner_ = {}; return result; }
    operator AzStyleBorderLeftStyle() && noexcept { AzStyleBorderLeftStyle result = inner_; inner_ = {}; return result; }
};

class StyleBorderRightColor {
private:
    AzStyleBorderRightColor inner_;

public:
    StyleBorderRightColor(AzStyleBorderRightColor inner) noexcept : inner_(inner) {}
    StyleBorderRightColor(const StyleBorderRightColor& other) noexcept : inner_(other.inner_) {}
    StyleBorderRightColor& operator=(const StyleBorderRightColor& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBorderRightColor() {}

    bool partialEq(const StyleBorderRightColor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBorderRightColor& b) const;
    uint8_t cmp(const StyleBorderRightColor& b) const;

    const AzStyleBorderRightColor& inner() const { return inner_; }
    AzStyleBorderRightColor& inner() { return inner_; }
    const AzStyleBorderRightColor* ptr() const { return &inner_; }
    AzStyleBorderRightColor* ptr() { return &inner_; }
    AzStyleBorderRightColor release() { AzStyleBorderRightColor result = inner_; inner_ = {}; return result; }
    operator AzStyleBorderRightColor() && noexcept { AzStyleBorderRightColor result = inner_; inner_ = {}; return result; }
};

class StyleBorderRightStyle {
private:
    AzStyleBorderRightStyle inner_;

public:
    StyleBorderRightStyle(AzStyleBorderRightStyle inner) noexcept : inner_(inner) {}
    StyleBorderRightStyle(const StyleBorderRightStyle& other) noexcept : inner_(other.inner_) {}
    StyleBorderRightStyle& operator=(const StyleBorderRightStyle& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBorderRightStyle() {}

    bool partialEq(const StyleBorderRightStyle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBorderRightStyle& b) const;
    uint8_t cmp(const StyleBorderRightStyle& b) const;

    const AzStyleBorderRightStyle& inner() const { return inner_; }
    AzStyleBorderRightStyle& inner() { return inner_; }
    const AzStyleBorderRightStyle* ptr() const { return &inner_; }
    AzStyleBorderRightStyle* ptr() { return &inner_; }
    AzStyleBorderRightStyle release() { AzStyleBorderRightStyle result = inner_; inner_ = {}; return result; }
    operator AzStyleBorderRightStyle() && noexcept { AzStyleBorderRightStyle result = inner_; inner_ = {}; return result; }
};

class StyleBorderTopColor {
private:
    AzStyleBorderTopColor inner_;

public:
    StyleBorderTopColor(AzStyleBorderTopColor inner) noexcept : inner_(inner) {}
    StyleBorderTopColor(const StyleBorderTopColor& other) noexcept : inner_(other.inner_) {}
    StyleBorderTopColor& operator=(const StyleBorderTopColor& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBorderTopColor() {}

    bool partialEq(const StyleBorderTopColor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBorderTopColor& b) const;
    uint8_t cmp(const StyleBorderTopColor& b) const;

    const AzStyleBorderTopColor& inner() const { return inner_; }
    AzStyleBorderTopColor& inner() { return inner_; }
    const AzStyleBorderTopColor* ptr() const { return &inner_; }
    AzStyleBorderTopColor* ptr() { return &inner_; }
    AzStyleBorderTopColor release() { AzStyleBorderTopColor result = inner_; inner_ = {}; return result; }
    operator AzStyleBorderTopColor() && noexcept { AzStyleBorderTopColor result = inner_; inner_ = {}; return result; }
};

class StyleBorderTopStyle {
private:
    AzStyleBorderTopStyle inner_;

public:
    StyleBorderTopStyle(AzStyleBorderTopStyle inner) noexcept : inner_(inner) {}
    StyleBorderTopStyle(const StyleBorderTopStyle& other) noexcept : inner_(other.inner_) {}
    StyleBorderTopStyle& operator=(const StyleBorderTopStyle& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBorderTopStyle() {}

    bool partialEq(const StyleBorderTopStyle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBorderTopStyle& b) const;
    uint8_t cmp(const StyleBorderTopStyle& b) const;

    const AzStyleBorderTopStyle& inner() const { return inner_; }
    AzStyleBorderTopStyle& inner() { return inner_; }
    const AzStyleBorderTopStyle* ptr() const { return &inner_; }
    AzStyleBorderTopStyle* ptr() { return &inner_; }
    AzStyleBorderTopStyle release() { AzStyleBorderTopStyle result = inner_; inner_ = {}; return result; }
    operator AzStyleBorderTopStyle() && noexcept { AzStyleBorderTopStyle result = inner_; inner_ = {}; return result; }
};

class StyleTransformMatrix2D {
private:
    AzStyleTransformMatrix2D inner_;

public:
    StyleTransformMatrix2D(AzStyleTransformMatrix2D inner) noexcept : inner_(inner) {}
    StyleTransformMatrix2D(const StyleTransformMatrix2D& other) noexcept : inner_(other.inner_) {}
    StyleTransformMatrix2D& operator=(const StyleTransformMatrix2D& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleTransformMatrix2D() {}

    [[nodiscard]] static StyleTransformMatrix2D default_();

    bool partialEq(const StyleTransformMatrix2D& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleTransformMatrix2D& b) const;
    uint8_t cmp(const StyleTransformMatrix2D& b) const;
    String toDbgString() const;

    const AzStyleTransformMatrix2D& inner() const { return inner_; }
    AzStyleTransformMatrix2D& inner() { return inner_; }
    const AzStyleTransformMatrix2D* ptr() const { return &inner_; }
    AzStyleTransformMatrix2D* ptr() { return &inner_; }
    AzStyleTransformMatrix2D release() { AzStyleTransformMatrix2D result = inner_; inner_ = {}; return result; }
    operator AzStyleTransformMatrix2D() && noexcept { AzStyleTransformMatrix2D result = inner_; inner_ = {}; return result; }
};

class StyleTransformMatrix3D {
private:
    AzStyleTransformMatrix3D inner_;

public:
    StyleTransformMatrix3D(AzStyleTransformMatrix3D inner) noexcept : inner_(inner) {}
    StyleTransformMatrix3D(const StyleTransformMatrix3D& other) noexcept : inner_(other.inner_) {}
    StyleTransformMatrix3D& operator=(const StyleTransformMatrix3D& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleTransformMatrix3D() {}

    [[nodiscard]] static StyleTransformMatrix3D default_();

    bool partialEq(const StyleTransformMatrix3D& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleTransformMatrix3D& b) const;
    uint8_t cmp(const StyleTransformMatrix3D& b) const;
    String toDbgString() const;

    const AzStyleTransformMatrix3D& inner() const { return inner_; }
    AzStyleTransformMatrix3D& inner() { return inner_; }
    const AzStyleTransformMatrix3D* ptr() const { return &inner_; }
    AzStyleTransformMatrix3D* ptr() { return &inner_; }
    AzStyleTransformMatrix3D release() { AzStyleTransformMatrix3D result = inner_; inner_ = {}; return result; }
    operator AzStyleTransformMatrix3D() && noexcept { AzStyleTransformMatrix3D result = inner_; inner_ = {}; return result; }
};

class StyleTransformScale2D {
private:
    AzStyleTransformScale2D inner_;

public:
    StyleTransformScale2D(AzStyleTransformScale2D inner) noexcept : inner_(inner) {}
    StyleTransformScale2D(const StyleTransformScale2D& other) noexcept : inner_(other.inner_) {}
    StyleTransformScale2D& operator=(const StyleTransformScale2D& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleTransformScale2D() {}

    bool partialEq(const StyleTransformScale2D& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleTransformScale2D& b) const;
    uint8_t cmp(const StyleTransformScale2D& b) const;
    String toDbgString() const;

    const AzStyleTransformScale2D& inner() const { return inner_; }
    AzStyleTransformScale2D& inner() { return inner_; }
    const AzStyleTransformScale2D* ptr() const { return &inner_; }
    AzStyleTransformScale2D* ptr() { return &inner_; }
    AzStyleTransformScale2D release() { AzStyleTransformScale2D result = inner_; inner_ = {}; return result; }
    operator AzStyleTransformScale2D() && noexcept { AzStyleTransformScale2D result = inner_; inner_ = {}; return result; }
};

class StyleTransformScale3D {
private:
    AzStyleTransformScale3D inner_;

public:
    StyleTransformScale3D(AzStyleTransformScale3D inner) noexcept : inner_(inner) {}
    StyleTransformScale3D(const StyleTransformScale3D& other) noexcept : inner_(other.inner_) {}
    StyleTransformScale3D& operator=(const StyleTransformScale3D& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleTransformScale3D() {}

    bool partialEq(const StyleTransformScale3D& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleTransformScale3D& b) const;
    uint8_t cmp(const StyleTransformScale3D& b) const;
    String toDbgString() const;

    const AzStyleTransformScale3D& inner() const { return inner_; }
    AzStyleTransformScale3D& inner() { return inner_; }
    const AzStyleTransformScale3D* ptr() const { return &inner_; }
    AzStyleTransformScale3D* ptr() { return &inner_; }
    AzStyleTransformScale3D release() { AzStyleTransformScale3D result = inner_; inner_ = {}; return result; }
    operator AzStyleTransformScale3D() && noexcept { AzStyleTransformScale3D result = inner_; inner_ = {}; return result; }
};

class StyleTextColor {
private:
    AzStyleTextColor inner_;

public:
    StyleTextColor(AzStyleTextColor inner) noexcept : inner_(inner) {}
    StyleTextColor(const StyleTextColor& other) noexcept : inner_(other.inner_) {}
    StyleTextColor& operator=(const StyleTextColor& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleTextColor() {}

    [[nodiscard]] static StyleTextColor default_();

    bool partialEq(const StyleTextColor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleTextColor& b) const;
    uint8_t cmp(const StyleTextColor& b) const;
    String toDbgString() const;

    const AzStyleTextColor& inner() const { return inner_; }
    AzStyleTextColor& inner() { return inner_; }
    const AzStyleTextColor* ptr() const { return &inner_; }
    AzStyleTextColor* ptr() { return &inner_; }
    AzStyleTextColor release() { AzStyleTextColor result = inner_; inner_ = {}; return result; }
    operator AzStyleTextColor() && noexcept { AzStyleTextColor result = inner_; inner_ = {}; return result; }
};

class SelectionBackgroundColor {
private:
    AzSelectionBackgroundColor inner_;

public:
    SelectionBackgroundColor(AzSelectionBackgroundColor inner) noexcept : inner_(inner) {}
    SelectionBackgroundColor(const SelectionBackgroundColor& other) noexcept : inner_(other.inner_) {}
    SelectionBackgroundColor& operator=(const SelectionBackgroundColor& other) noexcept { inner_ = other.inner_; return *this; }
    ~SelectionBackgroundColor() {}

    [[nodiscard]] static SelectionBackgroundColor default_();

    bool partialEq(const SelectionBackgroundColor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const SelectionBackgroundColor& b) const;
    uint8_t cmp(const SelectionBackgroundColor& b) const;
    String toDbgString() const;

    const AzSelectionBackgroundColor& inner() const { return inner_; }
    AzSelectionBackgroundColor& inner() { return inner_; }
    const AzSelectionBackgroundColor* ptr() const { return &inner_; }
    AzSelectionBackgroundColor* ptr() { return &inner_; }
    AzSelectionBackgroundColor release() { AzSelectionBackgroundColor result = inner_; inner_ = {}; return result; }
    operator AzSelectionBackgroundColor() && noexcept { AzSelectionBackgroundColor result = inner_; inner_ = {}; return result; }
};

class ColumnRuleColor {
private:
    AzColumnRuleColor inner_;

public:
    ColumnRuleColor(AzColumnRuleColor inner) noexcept : inner_(inner) {}
    ColumnRuleColor(const ColumnRuleColor& other) noexcept : inner_(other.inner_) {}
    ColumnRuleColor& operator=(const ColumnRuleColor& other) noexcept { inner_ = other.inner_; return *this; }
    ~ColumnRuleColor() {}

    [[nodiscard]] static ColumnRuleColor default_();

    bool partialEq(const ColumnRuleColor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ColumnRuleColor& b) const;
    uint8_t cmp(const ColumnRuleColor& b) const;
    String toDbgString() const;

    const AzColumnRuleColor& inner() const { return inner_; }
    AzColumnRuleColor& inner() { return inner_; }
    const AzColumnRuleColor* ptr() const { return &inner_; }
    AzColumnRuleColor* ptr() { return &inner_; }
    AzColumnRuleColor release() { AzColumnRuleColor result = inner_; inner_ = {}; return result; }
    operator AzColumnRuleColor() && noexcept { AzColumnRuleColor result = inner_; inner_ = {}; return result; }
};

class CaretAnimationDuration {
private:
    AzCaretAnimationDuration inner_;

public:
    CaretAnimationDuration(AzCaretAnimationDuration inner) noexcept : inner_(inner) {}
    CaretAnimationDuration(const CaretAnimationDuration& other) noexcept : inner_(other.inner_) {}
    CaretAnimationDuration& operator=(const CaretAnimationDuration& other) noexcept { inner_ = other.inner_; return *this; }
    ~CaretAnimationDuration() {}

    [[nodiscard]] static CaretAnimationDuration default_();

    bool partialEq(const CaretAnimationDuration& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CaretAnimationDuration& b) const;
    uint8_t cmp(const CaretAnimationDuration& b) const;
    String toDbgString() const;

    const AzCaretAnimationDuration& inner() const { return inner_; }
    AzCaretAnimationDuration& inner() { return inner_; }
    const AzCaretAnimationDuration* ptr() const { return &inner_; }
    AzCaretAnimationDuration* ptr() { return &inner_; }
    AzCaretAnimationDuration release() { AzCaretAnimationDuration result = inner_; inner_ = {}; return result; }
    operator AzCaretAnimationDuration() && noexcept { AzCaretAnimationDuration result = inner_; inner_ = {}; return result; }
};

class ColumnRuleStyle {
private:
    AzColumnRuleStyle inner_;

public:
    ColumnRuleStyle(AzColumnRuleStyle inner) noexcept : inner_(inner) {}
    ColumnRuleStyle(const ColumnRuleStyle& other) noexcept : inner_(other.inner_) {}
    ColumnRuleStyle& operator=(const ColumnRuleStyle& other) noexcept { inner_ = other.inner_; return *this; }
    ~ColumnRuleStyle() {}

    [[nodiscard]] static ColumnRuleStyle default_();

    bool partialEq(const ColumnRuleStyle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ColumnRuleStyle& b) const;
    uint8_t cmp(const ColumnRuleStyle& b) const;
    String toDbgString() const;

    const AzColumnRuleStyle& inner() const { return inner_; }
    AzColumnRuleStyle& inner() { return inner_; }
    const AzColumnRuleStyle* ptr() const { return &inner_; }
    AzColumnRuleStyle* ptr() { return &inner_; }
    AzColumnRuleStyle release() { AzColumnRuleStyle result = inner_; inner_ = {}; return result; }
    operator AzColumnRuleStyle() && noexcept { AzColumnRuleStyle result = inner_; inner_ = {}; return result; }
};

class ShapeImageThreshold {
private:
    AzShapeImageThreshold inner_;

public:
    ShapeImageThreshold(AzShapeImageThreshold inner) noexcept : inner_(inner) {}
    ShapeImageThreshold(const ShapeImageThreshold& other) noexcept : inner_(other.inner_) {}
    ShapeImageThreshold& operator=(const ShapeImageThreshold& other) noexcept { inner_ = other.inner_; return *this; }
    ~ShapeImageThreshold() {}

    [[nodiscard]] static ShapeImageThreshold default_();

    bool partialEq(const ShapeImageThreshold& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ShapeImageThreshold& b) const;
    uint8_t cmp(const ShapeImageThreshold& b) const;
    String toDbgString() const;

    const AzShapeImageThreshold& inner() const { return inner_; }
    AzShapeImageThreshold& inner() { return inner_; }
    const AzShapeImageThreshold* ptr() const { return &inner_; }
    AzShapeImageThreshold* ptr() { return &inner_; }
    AzShapeImageThreshold release() { AzShapeImageThreshold result = inner_; inner_ = {}; return result; }
    operator AzShapeImageThreshold() && noexcept { AzShapeImageThreshold result = inner_; inner_ = {}; return result; }
};

class CaretColor {
private:
    AzCaretColor inner_;

public:
    CaretColor(AzCaretColor inner) noexcept : inner_(inner) {}
    CaretColor(const CaretColor& other) noexcept : inner_(other.inner_) {}
    CaretColor& operator=(const CaretColor& other) noexcept { inner_ = other.inner_; return *this; }
    ~CaretColor() {}

    [[nodiscard]] static CaretColor default_();

    bool partialEq(const CaretColor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CaretColor& b) const;
    uint8_t cmp(const CaretColor& b) const;
    String toDbgString() const;

    const AzCaretColor& inner() const { return inner_; }
    AzCaretColor& inner() { return inner_; }
    const AzCaretColor* ptr() const { return &inner_; }
    AzCaretColor* ptr() { return &inner_; }
    AzCaretColor release() { AzCaretColor result = inner_; inner_ = {}; return result; }
    operator AzCaretColor() && noexcept { AzCaretColor result = inner_; inner_ = {}; return result; }
};

class StyleExclusionMargin {
private:
    AzStyleExclusionMargin inner_;

public:
    StyleExclusionMargin(AzStyleExclusionMargin inner) noexcept : inner_(inner) {}
    StyleExclusionMargin(const StyleExclusionMargin& other) noexcept : inner_(other.inner_) {}
    StyleExclusionMargin& operator=(const StyleExclusionMargin& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleExclusionMargin() {}

    [[nodiscard]] static StyleExclusionMargin default_();

    bool partialEq(const StyleExclusionMargin& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleExclusionMargin& b) const;
    uint8_t cmp(const StyleExclusionMargin& b) const;
    String toDbgString() const;

    const AzStyleExclusionMargin& inner() const { return inner_; }
    AzStyleExclusionMargin& inner() { return inner_; }
    const AzStyleExclusionMargin* ptr() const { return &inner_; }
    AzStyleExclusionMargin* ptr() { return &inner_; }
    AzStyleExclusionMargin release() { AzStyleExclusionMargin result = inner_; inner_ = {}; return result; }
    operator AzStyleExclusionMargin() && noexcept { AzStyleExclusionMargin result = inner_; inner_ = {}; return result; }
};

class StyleInitialLetter {
private:
    AzStyleInitialLetter inner_;

public:
    StyleInitialLetter(AzStyleInitialLetter inner) noexcept : inner_(inner) {}
    StyleInitialLetter(const StyleInitialLetter& other) noexcept : inner_(other.inner_) {}
    StyleInitialLetter& operator=(const StyleInitialLetter& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleInitialLetter() {}

    bool partialEq(const StyleInitialLetter& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleInitialLetter& b) const;
    uint8_t cmp(const StyleInitialLetter& b) const;
    String toDbgString() const;

    const AzStyleInitialLetter& inner() const { return inner_; }
    AzStyleInitialLetter& inner() { return inner_; }
    const AzStyleInitialLetter* ptr() const { return &inner_; }
    AzStyleInitialLetter* ptr() { return &inner_; }
    AzStyleInitialLetter release() { AzStyleInitialLetter result = inner_; inner_ = {}; return result; }
    operator AzStyleInitialLetter() && noexcept { AzStyleInitialLetter result = inner_; inner_ = {}; return result; }
};

class ScrollbarColorCustom {
private:
    AzScrollbarColorCustom inner_;

public:
    ScrollbarColorCustom(AzScrollbarColorCustom inner) noexcept : inner_(inner) {}
    ScrollbarColorCustom(const ScrollbarColorCustom& other) noexcept : inner_(other.inner_) {}
    ScrollbarColorCustom& operator=(const ScrollbarColorCustom& other) noexcept { inner_ = other.inner_; return *this; }
    ~ScrollbarColorCustom() {}

    bool partialEq(const ScrollbarColorCustom& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ScrollbarColorCustom& b) const;
    uint8_t cmp(const ScrollbarColorCustom& b) const;
    String toDbgString() const;

    const AzScrollbarColorCustom& inner() const { return inner_; }
    AzScrollbarColorCustom& inner() { return inner_; }
    const AzScrollbarColorCustom* ptr() const { return &inner_; }
    AzScrollbarColorCustom* ptr() { return &inner_; }
    AzScrollbarColorCustom release() { AzScrollbarColorCustom result = inner_; inner_ = {}; return result; }
    operator AzScrollbarColorCustom() && noexcept { AzScrollbarColorCustom result = inner_; inner_ = {}; return result; }
};

class ShapeInset {
private:
    AzShapeInset inner_;

    ShapeInset(const ShapeInset&) = delete;
    ShapeInset& operator=(const ShapeInset&) = delete;

public:
    explicit ShapeInset(AzShapeInset inner) noexcept : inner_(inner) {}

    ShapeInset(ShapeInset&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ShapeInset& operator=(ShapeInset&& other) noexcept {
        if (this != &other) {
            AzShapeInset_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ShapeInset() { AzShapeInset_delete(&inner_); }

    void delete_();
    ShapeInset clone() const;
    bool partialEq(const ShapeInset& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ShapeInset& b) const;
    uint8_t cmp(const ShapeInset& b) const;
    String toDbgString() const;

    const AzShapeInset& inner() const { return inner_; }
    AzShapeInset& inner() { return inner_; }
    const AzShapeInset* ptr() const { return &inner_; }
    AzShapeInset* ptr() { return &inner_; }
    AzShapeInset release() { AzShapeInset result = inner_; inner_ = {}; return result; }
    operator AzShapeInset() && noexcept { AzShapeInset result = inner_; inner_ = {}; return result; }
};

class ShapeEllipse {
private:
    AzShapeEllipse inner_;

    ShapeEllipse(const ShapeEllipse&) = delete;
    ShapeEllipse& operator=(const ShapeEllipse&) = delete;

public:
    explicit ShapeEllipse(AzShapeEllipse inner) noexcept : inner_(inner) {}

    ShapeEllipse(ShapeEllipse&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ShapeEllipse& operator=(ShapeEllipse&& other) noexcept {
        if (this != &other) {
            AzShapeEllipse_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ShapeEllipse() { AzShapeEllipse_delete(&inner_); }

    void delete_();
    ShapeEllipse clone() const;
    bool partialEq(const ShapeEllipse& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ShapeEllipse& b) const;
    uint8_t cmp(const ShapeEllipse& b) const;
    String toDbgString() const;

    const AzShapeEllipse& inner() const { return inner_; }
    AzShapeEllipse& inner() { return inner_; }
    const AzShapeEllipse* ptr() const { return &inner_; }
    AzShapeEllipse* ptr() { return &inner_; }
    AzShapeEllipse release() { AzShapeEllipse result = inner_; inner_ = {}; return result; }
    operator AzShapeEllipse() && noexcept { AzShapeEllipse result = inner_; inner_ = {}; return result; }
};

class LayoutRect {
private:
    AzLayoutRect inner_;

public:
    LayoutRect(AzLayoutRect inner) noexcept : inner_(inner) {}
    LayoutRect(const LayoutRect& other) noexcept : inner_(other.inner_) {}
    LayoutRect& operator=(const LayoutRect& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutRect() {}

    [[nodiscard]] static LayoutRect create(LayoutPoint origin, LayoutSize size);
    [[nodiscard]] static LayoutRect zero();

    bool contains_f32(float x, float y) const;
    bool contains_rect(LayoutRect other) const;
    static OptionLayoutRect union_(LayoutRectVecSlice rects);
    bool partialEq(const LayoutRect& b) const;
    uint8_t partialCmp(const LayoutRect& b) const;
    String toDbgString() const;

    const AzLayoutRect& inner() const { return inner_; }
    AzLayoutRect& inner() { return inner_; }
    const AzLayoutRect* ptr() const { return &inner_; }
    AzLayoutRect* ptr() { return &inner_; }
    AzLayoutRect release() { AzLayoutRect result = inner_; inner_ = {}; return result; }
    operator AzLayoutRect() && noexcept { AzLayoutRect result = inner_; inner_ = {}; return result; }
};

class StyledNode {
private:
    AzStyledNode inner_;

    StyledNode(const StyledNode&) = delete;
    StyledNode& operator=(const StyledNode&) = delete;

public:
    explicit StyledNode(AzStyledNode inner) noexcept : inner_(inner) {}

    StyledNode(StyledNode&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyledNode& operator=(StyledNode&& other) noexcept {
        if (this != &other) {
            AzStyledNode_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyledNode() { AzStyledNode_delete(&inner_); }

    [[nodiscard]] static StyledNode default_();

    void delete_();
    StyledNode clone() const;
    bool partialEq(const StyledNode& b) const;
    uint8_t partialCmp(const StyledNode& b) const;
    String toDbgString() const;

    const AzStyledNode& inner() const { return inner_; }
    AzStyledNode& inner() { return inner_; }
    const AzStyledNode* ptr() const { return &inner_; }
    AzStyledNode* ptr() { return &inner_; }
    AzStyledNode release() { AzStyledNode result = inner_; inner_ = {}; return result; }
    operator AzStyledNode() && noexcept { AzStyledNode result = inner_; inner_ = {}; return result; }
};

class ArithmeticCoefficients {
private:
    AzArithmeticCoefficients inner_;

    ArithmeticCoefficients(const ArithmeticCoefficients&) = delete;
    ArithmeticCoefficients& operator=(const ArithmeticCoefficients&) = delete;

public:
    explicit ArithmeticCoefficients(AzArithmeticCoefficients inner) noexcept : inner_(inner) {}

    ArithmeticCoefficients(ArithmeticCoefficients&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ArithmeticCoefficients& operator=(ArithmeticCoefficients&& other) noexcept {
        if (this != &other) {
            AzArithmeticCoefficients_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ArithmeticCoefficients() { AzArithmeticCoefficients_delete(&inner_); }

    void delete_();
    ArithmeticCoefficients clone() const;
    bool partialEq(const ArithmeticCoefficients& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ArithmeticCoefficients& b) const;
    uint8_t cmp(const ArithmeticCoefficients& b) const;
    String toDbgString() const;

    const AzArithmeticCoefficients& inner() const { return inner_; }
    AzArithmeticCoefficients& inner() { return inner_; }
    const AzArithmeticCoefficients* ptr() const { return &inner_; }
    AzArithmeticCoefficients* ptr() { return &inner_; }
    AzArithmeticCoefficients release() { AzArithmeticCoefficients result = inner_; inner_ = {}; return result; }
    operator AzArithmeticCoefficients() && noexcept { AzArithmeticCoefficients result = inner_; inner_ = {}; return result; }
};

class StyleBackgroundRepeatVecSlice {
private:
    AzStyleBackgroundRepeatVecSlice inner_;

public:
    StyleBackgroundRepeatVecSlice(AzStyleBackgroundRepeatVecSlice inner) noexcept : inner_(inner) {}
    StyleBackgroundRepeatVecSlice(const StyleBackgroundRepeatVecSlice& other) noexcept : inner_(other.inner_) {}
    StyleBackgroundRepeatVecSlice& operator=(const StyleBackgroundRepeatVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBackgroundRepeatVecSlice() {}

    String toDbgString() const;

    const AzStyleBackgroundRepeatVecSlice& inner() const { return inner_; }
    AzStyleBackgroundRepeatVecSlice& inner() { return inner_; }
    const AzStyleBackgroundRepeatVecSlice* ptr() const { return &inner_; }
    AzStyleBackgroundRepeatVecSlice* ptr() { return &inner_; }
    AzStyleBackgroundRepeatVecSlice release() { AzStyleBackgroundRepeatVecSlice result = inner_; inner_ = {}; return result; }
    operator AzStyleBackgroundRepeatVecSlice() && noexcept { AzStyleBackgroundRepeatVecSlice result = inner_; inner_ = {}; return result; }
};

class ScrollbarPreferences {
private:
    AzScrollbarPreferences inner_;

public:
    ScrollbarPreferences(AzScrollbarPreferences inner) noexcept : inner_(inner) {}
    ScrollbarPreferences(const ScrollbarPreferences& other) noexcept : inner_(other.inner_) {}
    ScrollbarPreferences& operator=(const ScrollbarPreferences& other) noexcept { inner_ = other.inner_; return *this; }
    ~ScrollbarPreferences() {}

    [[nodiscard]] static ScrollbarPreferences default_();

    bool partialEq(const ScrollbarPreferences& b) const;
    String toDbgString() const;

    const AzScrollbarPreferences& inner() const { return inner_; }
    AzScrollbarPreferences& inner() { return inner_; }
    const AzScrollbarPreferences* ptr() const { return &inner_; }
    AzScrollbarPreferences* ptr() { return &inner_; }
    AzScrollbarPreferences release() { AzScrollbarPreferences result = inner_; inner_ = {}; return result; }
    operator AzScrollbarPreferences() && noexcept { AzScrollbarPreferences result = inner_; inner_ = {}; return result; }
};

class TextRenderingHints {
private:
    AzTextRenderingHints inner_;

public:
    TextRenderingHints(AzTextRenderingHints inner) noexcept : inner_(inner) {}
    TextRenderingHints(const TextRenderingHints& other) noexcept : inner_(other.inner_) {}
    TextRenderingHints& operator=(const TextRenderingHints& other) noexcept { inner_ = other.inner_; return *this; }
    ~TextRenderingHints() {}

    [[nodiscard]] static TextRenderingHints default_();

    bool partialEq(const TextRenderingHints& b) const;
    String toDbgString() const;

    const AzTextRenderingHints& inner() const { return inner_; }
    AzTextRenderingHints& inner() { return inner_; }
    const AzTextRenderingHints* ptr() const { return &inner_; }
    AzTextRenderingHints* ptr() { return &inner_; }
    AzTextRenderingHints release() { AzTextRenderingHints result = inner_; inner_ = {}; return result; }
    operator AzTextRenderingHints() && noexcept { AzTextRenderingHints result = inner_; inner_ = {}; return result; }
};

class AnimationMetrics {
private:
    AzAnimationMetrics inner_;

public:
    AnimationMetrics(AzAnimationMetrics inner) noexcept : inner_(inner) {}
    AnimationMetrics(const AnimationMetrics& other) noexcept : inner_(other.inner_) {}
    AnimationMetrics& operator=(const AnimationMetrics& other) noexcept { inner_ = other.inner_; return *this; }
    ~AnimationMetrics() {}

    [[nodiscard]] static AnimationMetrics default_();

    bool partialEq(const AnimationMetrics& b) const;
    String toDbgString() const;

    const AzAnimationMetrics& inner() const { return inner_; }
    AzAnimationMetrics& inner() { return inner_; }
    const AzAnimationMetrics* ptr() const { return &inner_; }
    AzAnimationMetrics* ptr() { return &inner_; }
    AzAnimationMetrics release() { AzAnimationMetrics result = inner_; inner_ = {}; return result; }
    operator AzAnimationMetrics() && noexcept { AzAnimationMetrics result = inner_; inner_ = {}; return result; }
};

class CssSyntaxInvalidAdvance {
private:
    AzCssSyntaxInvalidAdvance inner_;

public:
    CssSyntaxInvalidAdvance(AzCssSyntaxInvalidAdvance inner) noexcept : inner_(inner) {}
    CssSyntaxInvalidAdvance(const CssSyntaxInvalidAdvance& other) noexcept : inner_(other.inner_) {}
    CssSyntaxInvalidAdvance& operator=(const CssSyntaxInvalidAdvance& other) noexcept { inner_ = other.inner_; return *this; }
    ~CssSyntaxInvalidAdvance() {}

    bool partialEq(const CssSyntaxInvalidAdvance& b) const;
    String toDbgString() const;

    const AzCssSyntaxInvalidAdvance& inner() const { return inner_; }
    AzCssSyntaxInvalidAdvance& inner() { return inner_; }
    const AzCssSyntaxInvalidAdvance* ptr() const { return &inner_; }
    AzCssSyntaxInvalidAdvance* ptr() { return &inner_; }
    AzCssSyntaxInvalidAdvance release() { AzCssSyntaxInvalidAdvance result = inner_; inner_ = {}; return result; }
    operator AzCssSyntaxInvalidAdvance() && noexcept { AzCssSyntaxInvalidAdvance result = inner_; inner_ = {}; return result; }
};

class SvgFillStyle {
private:
    AzSvgFillStyle inner_;

public:
    SvgFillStyle(AzSvgFillStyle inner) noexcept : inner_(inner) {}
    SvgFillStyle(const SvgFillStyle& other) noexcept : inner_(other.inner_) {}
    SvgFillStyle& operator=(const SvgFillStyle& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgFillStyle() {}

    [[nodiscard]] static SvgFillStyle default_();

    bool partialEq(const SvgFillStyle& b) const;
    uint8_t partialCmp(const SvgFillStyle& b) const;
    String toDbgString() const;

    const AzSvgFillStyle& inner() const { return inner_; }
    AzSvgFillStyle& inner() { return inner_; }
    const AzSvgFillStyle* ptr() const { return &inner_; }
    AzSvgFillStyle* ptr() { return &inner_; }
    AzSvgFillStyle release() { AzSvgFillStyle result = inner_; inner_ = {}; return result; }
    operator AzSvgFillStyle() && noexcept { AzSvgFillStyle result = inner_; inner_ = {}; return result; }
};

class OsVersion {
private:
    AzOsVersion inner_;

public:
    OsVersion(AzOsVersion inner) noexcept : inner_(inner) {}
    OsVersion(const OsVersion& other) noexcept : inner_(other.inner_) {}
    OsVersion& operator=(const OsVersion& other) noexcept { inner_ = other.inner_; return *this; }
    ~OsVersion() {}

    [[nodiscard]] static OsVersion default_();

    bool partialEq(const OsVersion& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzOsVersion& inner() const { return inner_; }
    AzOsVersion& inner() { return inner_; }
    const AzOsVersion* ptr() const { return &inner_; }
    AzOsVersion* ptr() { return &inner_; }
    AzOsVersion release() { AzOsVersion result = inner_; inner_ = {}; return result; }
    operator AzOsVersion() && noexcept { AzOsVersion result = inner_; inner_ = {}; return result; }
};

class VisualHints {
private:
    AzVisualHints inner_;

public:
    VisualHints(AzVisualHints inner) noexcept : inner_(inner) {}
    VisualHints(const VisualHints& other) noexcept : inner_(other.inner_) {}
    VisualHints& operator=(const VisualHints& other) noexcept { inner_ = other.inner_; return *this; }
    ~VisualHints() {}

    [[nodiscard]] static VisualHints default_();

    bool partialEq(const VisualHints& b) const;
    String toDbgString() const;

    const AzVisualHints& inner() const { return inner_; }
    AzVisualHints& inner() { return inner_; }
    const AzVisualHints* ptr() const { return &inner_; }
    AzVisualHints* ptr() { return &inner_; }
    AzVisualHints release() { AzVisualHints result = inner_; inner_ = {}; return result; }
    operator AzVisualHints() && noexcept { AzVisualHints result = inner_; inner_ = {}; return result; }
};

class StyleClipRect {
private:
    AzStyleClipRect inner_;

public:
    StyleClipRect(AzStyleClipRect inner) noexcept : inner_(inner) {}
    StyleClipRect(const StyleClipRect& other) noexcept : inner_(other.inner_) {}
    StyleClipRect& operator=(const StyleClipRect& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleClipRect() {}

    [[nodiscard]] static StyleClipRect default_();

    bool partialEq(const StyleClipRect& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleClipRect& b) const;
    uint8_t cmp(const StyleClipRect& b) const;
    String toDbgString() const;

    const AzStyleClipRect& inner() const { return inner_; }
    AzStyleClipRect& inner() { return inner_; }
    const AzStyleClipRect* ptr() const { return &inner_; }
    AzStyleClipRect* ptr() { return &inner_; }
    AzStyleClipRect release() { AzStyleClipRect result = inner_; inner_ = {}; return result; }
    operator AzStyleClipRect() && noexcept { AzStyleClipRect result = inner_; inner_ = {}; return result; }
};

class DesktopEnvVersion {
private:
    AzDesktopEnvVersion inner_;

public:
    DesktopEnvVersion(AzDesktopEnvVersion inner) noexcept : inner_(inner) {}
    DesktopEnvVersion(const DesktopEnvVersion& other) noexcept : inner_(other.inner_) {}
    DesktopEnvVersion& operator=(const DesktopEnvVersion& other) noexcept { inner_ = other.inner_; return *this; }
    ~DesktopEnvVersion() {}

    bool partialEq(const DesktopEnvVersion& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzDesktopEnvVersion& inner() const { return inner_; }
    AzDesktopEnvVersion& inner() { return inner_; }
    const AzDesktopEnvVersion* ptr() const { return &inner_; }
    AzDesktopEnvVersion* ptr() { return &inner_; }
    AzDesktopEnvVersion release() { AzDesktopEnvVersion result = inner_; inner_ = {}; return result; }
    operator AzDesktopEnvVersion() && noexcept { AzDesktopEnvVersion result = inner_; inner_ = {}; return result; }
};

class ColorInputState {
private:
    AzColorInputState inner_;

    ColorInputState(const ColorInputState&) = delete;
    ColorInputState& operator=(const ColorInputState&) = delete;

public:
    explicit ColorInputState(AzColorInputState inner) noexcept : inner_(inner) {}

    ColorInputState(ColorInputState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ColorInputState& operator=(ColorInputState&& other) noexcept {
        if (this != &other) {
            AzColorInputState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ColorInputState() { AzColorInputState_delete(&inner_); }

    [[nodiscard]] static ColorInputState default_();

    void delete_();
    ColorInputState clone() const;
    bool partialEq(const ColorInputState& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ColorInputState& b) const;
    uint8_t cmp(const ColorInputState& b) const;
    String toDbgString() const;

    const AzColorInputState& inner() const { return inner_; }
    AzColorInputState& inner() { return inner_; }
    const AzColorInputState* ptr() const { return &inner_; }
    AzColorInputState* ptr() { return &inner_; }
    AzColorInputState release() { AzColorInputState result = inner_; inner_ = {}; return result; }
    operator AzColorInputState() && noexcept { AzColorInputState result = inner_; inner_ = {}; return result; }
};

class OnTextInputReturn {
private:
    AzOnTextInputReturn inner_;

public:
    OnTextInputReturn(AzOnTextInputReturn inner) noexcept : inner_(inner) {}
    OnTextInputReturn(const OnTextInputReturn& other) noexcept : inner_(other.inner_) {}
    OnTextInputReturn& operator=(const OnTextInputReturn& other) noexcept { inner_ = other.inner_; return *this; }
    ~OnTextInputReturn() {}

    bool partialEq(const OnTextInputReturn& b) const;
    String toDbgString() const;

    const AzOnTextInputReturn& inner() const { return inner_; }
    AzOnTextInputReturn& inner() { return inner_; }
    const AzOnTextInputReturn* ptr() const { return &inner_; }
    AzOnTextInputReturn* ptr() { return &inner_; }
    AzOnTextInputReturn release() { AzOnTextInputReturn result = inner_; inner_ = {}; return result; }
    operator AzOnTextInputReturn() && noexcept { AzOnTextInputReturn result = inner_; inner_ = {}; return result; }
};

class GlShaderPrecisionFormatReturn {
private:
    AzGlShaderPrecisionFormatReturn inner_;

public:
    GlShaderPrecisionFormatReturn(AzGlShaderPrecisionFormatReturn inner) noexcept : inner_(inner) {}
    GlShaderPrecisionFormatReturn(const GlShaderPrecisionFormatReturn& other) noexcept : inner_(other.inner_) {}
    GlShaderPrecisionFormatReturn& operator=(const GlShaderPrecisionFormatReturn& other) noexcept { inner_ = other.inner_; return *this; }
    ~GlShaderPrecisionFormatReturn() {}

    bool partialEq(const GlShaderPrecisionFormatReturn& b) const;
    uint8_t partialCmp(const GlShaderPrecisionFormatReturn& b) const;
    String toDbgString() const;

    const AzGlShaderPrecisionFormatReturn& inner() const { return inner_; }
    AzGlShaderPrecisionFormatReturn& inner() { return inner_; }
    const AzGlShaderPrecisionFormatReturn* ptr() const { return &inner_; }
    AzGlShaderPrecisionFormatReturn* ptr() { return &inner_; }
    AzGlShaderPrecisionFormatReturn release() { AzGlShaderPrecisionFormatReturn result = inner_; inner_ = {}; return result; }
    operator AzGlShaderPrecisionFormatReturn() && noexcept { AzGlShaderPrecisionFormatReturn result = inner_; inner_ = {}; return result; }
};

class GlContextPtr {
private:
    AzGlContextPtr inner_;

    GlContextPtr(const GlContextPtr&) = delete;
    GlContextPtr& operator=(const GlContextPtr&) = delete;

public:
    explicit GlContextPtr(AzGlContextPtr inner) noexcept : inner_(inner) {}

    GlContextPtr(GlContextPtr&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GlContextPtr& operator=(GlContextPtr&& other) noexcept {
        if (this != &other) {
            AzGlContextPtr_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GlContextPtr() { AzGlContextPtr_delete(&inner_); }

    AzGlType get_type() const;
    void buffer_data_untyped(AzGLenum target, AzGLsizeiptr size, GlVoidPtrConst data, AzGLenum usage) const;
    void buffer_sub_data_untyped(AzGLenum target, ptrdiff_t offset, AzGLsizeiptr size, GlVoidPtrConst data) const;
    GlVoidPtrMut map_buffer(AzGLenum target, AzGLbitfield access) const;
    GlVoidPtrMut map_buffer_range(AzGLenum target, AzGLintptr offset, AzGLsizeiptr length, AzGLbitfield access) const;
    AzGLboolean unmap_buffer(AzGLenum target) const;
    void tex_buffer(AzGLenum target, AzGLenum internal_format, AzGLuint buffer) const;
    void read_buffer(AzGLenum mode) const;
    void read_pixels_into_buffer(AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height, AzGLenum format, AzGLenum pixel_type, U8VecRefMut dst_buffer) const;
    U8Vec read_pixels(AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height, AzGLenum format, AzGLenum pixel_type) const;
    void read_pixels_into_pbo(AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height, AzGLenum format, AzGLenum pixel_type) const;
    void sample_coverage(AzGLclampf value, bool invert) const;
    void polygon_offset(AzGLfloat factor, AzGLfloat units) const;
    void pixel_store_i(AzGLenum name, AzGLint param) const;
    GLuintVec gen_buffers(AzGLsizei n) const;
    GLuintVec gen_renderbuffers(AzGLsizei n) const;
    GLuintVec gen_framebuffers(AzGLsizei n) const;
    GLuintVec gen_textures(AzGLsizei n) const;
    GLuintVec gen_vertex_arrays(AzGLsizei n) const;
    GLuintVec gen_queries(AzGLsizei n) const;
    void begin_query(AzGLenum target, AzGLuint id) const;
    void end_query(AzGLenum target) const;
    void query_counter(AzGLuint id, AzGLenum target) const;
    int32_t get_query_object_iv(AzGLuint id, AzGLenum pname) const;
    uint32_t get_query_object_uiv(AzGLuint id, AzGLenum pname) const;
    int64_t get_query_object_i64v(AzGLuint id, AzGLenum pname) const;
    uint64_t get_query_object_ui64v(AzGLuint id, AzGLenum pname) const;
    void delete_queries(GLuintVecRef queries) const;
    void delete_vertex_arrays(GLuintVecRef vertex_arrays) const;
    void delete_buffers(GLuintVecRef buffers) const;
    void delete_renderbuffers(GLuintVecRef renderbuffers) const;
    void delete_framebuffers(GLuintVecRef framebuffers) const;
    void delete_textures(GLuintVecRef textures) const;
    void framebuffer_renderbuffer(AzGLenum target, AzGLenum attachment, AzGLenum renderbuffertarget, AzGLuint renderbuffer) const;
    void renderbuffer_storage(AzGLenum target, AzGLenum internalformat, AzGLsizei width, AzGLsizei height) const;
    void depth_func(AzGLenum func) const;
    void active_texture(AzGLenum texture) const;
    void attach_shader(AzGLuint program, AzGLuint shader) const;
    void get_uniform_iv(AzGLuint program, AzGLint location, GLintVecRefMut result) const;
    void get_uniform_fv(AzGLuint program, AzGLint location, GLfloatVecRefMut result) const;
    void bind_buffer_base(AzGLenum target, AzGLuint index, AzGLuint buffer) const;
    void bind_buffer_range(AzGLenum target, AzGLuint index, AzGLuint buffer, AzGLintptr offset, AzGLsizeiptr size) const;
    void uniform_block_binding(AzGLuint program, AzGLuint uniform_block_index, AzGLuint uniform_block_binding) const;
    void bind_buffer(AzGLenum target, AzGLuint buffer) const;
    void bind_vertex_array(AzGLuint vao) const;
    void bind_renderbuffer(AzGLenum target, AzGLuint renderbuffer) const;
    void bind_framebuffer(AzGLenum target, AzGLuint framebuffer) const;
    void bind_texture(AzGLenum target, AzGLuint texture) const;
    void draw_buffers(GLenumVecRef bufs) const;
    void tex_image_2d(AzGLenum target, AzGLint level, AzGLint internal_format, AzGLsizei width, AzGLsizei height, AzGLint border, AzGLenum format, AzGLenum ty, OptionU8VecRef opt_data) const;
    void compressed_tex_image_2d(AzGLenum target, AzGLint level, AzGLenum internal_format, AzGLsizei width, AzGLsizei height, AzGLint border, U8VecRef data) const;
    void compressed_tex_sub_image_2d(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLsizei width, AzGLsizei height, AzGLenum format, U8VecRef data) const;
    void tex_image_3d(AzGLenum target, AzGLint level, AzGLint internal_format, AzGLsizei width, AzGLsizei height, AzGLsizei depth, AzGLint border, AzGLenum format, AzGLenum ty, OptionU8VecRef opt_data) const;
    void copy_tex_image_2d(AzGLenum target, AzGLint level, AzGLenum internal_format, AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height, AzGLint border) const;
    void copy_tex_sub_image_2d(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height) const;
    void copy_tex_sub_image_3d(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLint zoffset, AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height) const;
    void tex_sub_image_2d(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLsizei width, AzGLsizei height, AzGLenum format, AzGLenum ty, U8VecRef data) const;
    void tex_sub_image_2d_pbo(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLsizei width, AzGLsizei height, AzGLenum format, AzGLenum ty, size_t offset) const;
    void tex_sub_image_3d(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLint zoffset, AzGLsizei width, AzGLsizei height, AzGLsizei depth, AzGLenum format, AzGLenum ty, U8VecRef data) const;
    void tex_sub_image_3d_pbo(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLint zoffset, AzGLsizei width, AzGLsizei height, AzGLsizei depth, AzGLenum format, AzGLenum ty, size_t offset) const;
    void tex_storage_2d(AzGLenum target, AzGLint levels, AzGLenum internal_format, AzGLsizei width, AzGLsizei height) const;
    void tex_storage_3d(AzGLenum target, AzGLint levels, AzGLenum internal_format, AzGLsizei width, AzGLsizei height, AzGLsizei depth) const;
    void get_tex_image_into_buffer(AzGLenum target, AzGLint level, AzGLenum format, AzGLenum ty, U8VecRefMut output) const;
    void copy_image_sub_data(AzGLuint src_name, AzGLenum src_target, AzGLint src_level, AzGLint src_x, AzGLint src_y, AzGLint src_z, AzGLuint dst_name, AzGLenum dst_target, AzGLint dst_level, AzGLint dst_x, AzGLint dst_y, AzGLint dst_z, AzGLsizei src_width, AzGLsizei src_height, AzGLsizei src_depth) const;
    void invalidate_framebuffer(AzGLenum target, GLenumVecRef attachments) const;
    void invalidate_sub_framebuffer(AzGLenum target, GLenumVecRef attachments, AzGLint xoffset, AzGLint yoffset, AzGLsizei width, AzGLsizei height) const;
    void get_integer_v(AzGLenum name, GLintVecRefMut result) const;
    void get_integer_64v(AzGLenum name, GLint64VecRefMut result) const;
    void get_integer_iv(AzGLenum name, AzGLuint index, GLintVecRefMut result) const;
    void get_integer_64iv(AzGLenum name, AzGLuint index, GLint64VecRefMut result) const;
    void get_boolean_v(AzGLenum name, GLbooleanVecRefMut result) const;
    void get_float_v(AzGLenum name, GLfloatVecRefMut result) const;
    AzGLint get_framebuffer_attachment_parameter_iv(AzGLenum target, AzGLenum attachment, AzGLenum pname) const;
    AzGLint get_renderbuffer_parameter_iv(AzGLenum target, AzGLenum pname) const;
    AzGLint get_tex_parameter_iv(AzGLenum target, AzGLenum name) const;
    AzGLfloat get_tex_parameter_fv(AzGLenum target, AzGLenum name) const;
    void tex_parameter_i(AzGLenum target, AzGLenum pname, AzGLint param) const;
    void tex_parameter_f(AzGLenum target, AzGLenum pname, AzGLfloat param) const;
    void framebuffer_texture_2d(AzGLenum target, AzGLenum attachment, AzGLenum textarget, AzGLuint texture, AzGLint level) const;
    void framebuffer_texture_layer(AzGLenum target, AzGLenum attachment, AzGLuint texture, AzGLint level, AzGLint layer) const;
    void blit_framebuffer(AzGLint src_x0, AzGLint src_y0, AzGLint src_x1, AzGLint src_y1, AzGLint dst_x0, AzGLint dst_y0, AzGLint dst_x1, AzGLint dst_y1, AzGLbitfield mask, AzGLenum filter) const;
    void vertex_attrib_4f(AzGLuint index, AzGLfloat x, AzGLfloat y, AzGLfloat z, AzGLfloat w) const;
    void vertex_attrib_divisor(AzGLuint index, AzGLuint divisor) const;
    void viewport(AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height) const;
    void scissor(AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height) const;
    void line_width(AzGLfloat width) const;
    void use_program(AzGLuint program) const;
    void validate_program(AzGLuint program) const;
    void draw_arrays(AzGLenum mode, AzGLint first, AzGLsizei count) const;
    void draw_arrays_instanced(AzGLenum mode, AzGLint first, AzGLsizei count, AzGLsizei primcount) const;
    void draw_elements(AzGLenum mode, AzGLsizei count, AzGLenum element_type, AzGLuint indices_offset) const;
    void draw_elements_instanced(AzGLenum mode, AzGLsizei count, AzGLenum element_type, AzGLuint indices_offset, AzGLsizei primcount) const;
    void blend_color(float r, float g, float b, float a) const;
    void blend_func(AzGLenum sfactor, AzGLenum dfactor) const;
    void blend_func_separate(AzGLenum src_rgb, AzGLenum dest_rgb, AzGLenum src_alpha, AzGLenum dest_alpha) const;
    void blend_equation(AzGLenum mode) const;
    void blend_equation_separate(AzGLenum mode_rgb, AzGLenum mode_alpha) const;
    void color_mask(bool r, bool g, bool b, bool a) const;
    void cull_face(AzGLenum mode) const;
    void front_face(AzGLenum mode) const;
    void enable(AzGLenum cap) const;
    void disable(AzGLenum cap) const;
    void hint(AzGLenum param_name, AzGLenum param_val) const;
    AzGLboolean is_enabled(AzGLenum cap) const;
    AzGLboolean is_shader(AzGLuint shader) const;
    AzGLboolean is_texture(AzGLenum texture) const;
    AzGLboolean is_framebuffer(AzGLenum framebuffer) const;
    AzGLboolean is_renderbuffer(AzGLenum renderbuffer) const;
    AzGLenum check_frame_buffer_status(AzGLenum target) const;
    void enable_vertex_attrib_array(AzGLuint index) const;
    void disable_vertex_attrib_array(AzGLuint index) const;
    void uniform_1f(AzGLint location, AzGLfloat v0) const;
    void uniform_1fv(AzGLint location, F32VecRef values) const;
    void uniform_1i(AzGLint location, AzGLint v0) const;
    void uniform_1iv(AzGLint location, I32VecRef values) const;
    void uniform_1ui(AzGLint location, AzGLuint v0) const;
    void uniform_2f(AzGLint location, AzGLfloat v0, AzGLfloat v1) const;
    void uniform_2fv(AzGLint location, F32VecRef values) const;
    void uniform_2i(AzGLint location, AzGLint v0, AzGLint v1) const;
    void uniform_2iv(AzGLint location, I32VecRef values) const;
    void uniform_2ui(AzGLint location, AzGLuint v0, AzGLuint v1) const;
    void uniform_3f(AzGLint location, AzGLfloat v0, AzGLfloat v1, AzGLfloat v2) const;
    void uniform_3fv(AzGLint location, F32VecRef values) const;
    void uniform_3i(AzGLint location, AzGLint v0, AzGLint v1, AzGLint v2) const;
    void uniform_3iv(AzGLint location, I32VecRef values) const;
    void uniform_3ui(AzGLint location, AzGLuint v0, AzGLuint v1, AzGLuint v2) const;
    void uniform_4f(AzGLint location, AzGLfloat x, AzGLfloat y, AzGLfloat z, AzGLfloat w) const;
    void uniform_4i(AzGLint location, AzGLint x, AzGLint y, AzGLint z, AzGLint w) const;
    void uniform_4iv(AzGLint location, I32VecRef values) const;
    void uniform_4ui(AzGLint location, AzGLuint x, AzGLuint y, AzGLuint z, AzGLuint w) const;
    void uniform_4fv(AzGLint location, F32VecRef values) const;
    void uniform_matrix_2fv(AzGLint location, bool transpose, F32VecRef value) const;
    void uniform_matrix_3fv(AzGLint location, bool transpose, F32VecRef value) const;
    void uniform_matrix_4fv(AzGLint location, bool transpose, F32VecRef value) const;
    void depth_mask(bool flag) const;
    void depth_range(double near, double far) const;
    GetActiveAttribReturn get_active_attrib(AzGLuint program, AzGLuint index) const;
    GetActiveUniformReturn get_active_uniform(AzGLuint program, AzGLuint index) const;
    GLintVec get_active_uniforms_iv(AzGLuint program, GLuintVec indices, AzGLenum pname) const;
    AzGLint get_active_uniform_block_i(AzGLuint program, AzGLuint index, AzGLenum pname) const;
    GLintVec get_active_uniform_block_iv(AzGLuint program, AzGLuint index, AzGLenum pname) const;
    String get_active_uniform_block_name(AzGLuint program, AzGLuint index) const;
    String get_program_info_log(AzGLuint program) const;
    void get_program_iv(AzGLuint program, AzGLenum pname, GLintVecRefMut result) const;
    GetProgramBinaryReturn get_program_binary(AzGLuint program) const;
    void program_binary(AzGLuint program, AzGLenum format, U8VecRef binary) const;
    void program_parameter_i(AzGLuint program, AzGLenum pname, AzGLint value) const;
    void get_vertex_attrib_iv(AzGLuint index, AzGLenum pname, GLintVecRefMut result) const;
    void get_vertex_attrib_fv(AzGLuint index, AzGLenum pname, GLfloatVecRefMut result) const;
    AzGLsizeiptr get_vertex_attrib_pointer_v(AzGLuint index, AzGLenum pname) const;
    AzGLint get_buffer_parameter_iv(AzGLuint target, AzGLenum pname) const;
    String get_shader_info_log(AzGLuint shader) const;
    void get_shader_iv(AzGLuint shader, AzGLenum pname, GLintVecRefMut result) const;
    GlShaderPrecisionFormatReturn get_shader_precision_format(AzGLuint shader_type, AzGLuint precision_type) const;
    void compile_shader(AzGLuint shader) const;
    AzGLuint create_program() const;
    void delete_program(AzGLuint program) const;
    AzGLuint create_shader(AzGLenum shader_type) const;
    void delete_shader(AzGLuint shader) const;
    void detach_shader(AzGLuint program, AzGLuint shader) const;
    void link_program(AzGLuint program) const;
    void clear_color(float r, float g, float b, float a) const;
    void clear(AzGLbitfield buffer_mask) const;
    void clear_depth(double depth) const;
    void clear_stencil(AzGLint s) const;
    void flush() const;
    void finish() const;
    AzGLenum get_error() const;
    void stencil_mask(AzGLuint mask) const;
    void stencil_mask_separate(AzGLenum face, AzGLuint mask) const;
    void stencil_func(AzGLenum func, AzGLint ref_, AzGLuint mask) const;
    void stencil_func_separate(AzGLenum face, AzGLenum func, AzGLint ref_, AzGLuint mask) const;
    void stencil_op(AzGLenum sfail, AzGLenum dpfail, AzGLenum dppass) const;
    void stencil_op_separate(AzGLenum face, AzGLenum sfail, AzGLenum dpfail, AzGLenum dppass) const;
    void egl_image_target_texture2d_oes(AzGLenum target, GlVoidPtrConst image) const;
    void generate_mipmap(AzGLenum target) const;
    void pop_group_marker_ext() const;
    void pop_debug_group_khr() const;
    GLsyncPtr fence_sync(AzGLenum condition, AzGLbitfield flags) const;
    uint32_t client_wait_sync(GLsyncPtr sync, AzGLbitfield flags, AzGLuint64 timeout) const;
    void wait_sync(GLsyncPtr sync, AzGLbitfield flags, AzGLuint64 timeout) const;
    void delete_sync(GLsyncPtr sync) const;
    void texture_range_apple(AzGLenum target, U8VecRef data) const;
    GLuintVec gen_fences_apple(AzGLsizei n) const;
    void delete_fences_apple(GLuintVecRef fences) const;
    void set_fence_apple(AzGLuint fence) const;
    void finish_fence_apple(AzGLuint fence) const;
    void test_fence_apple(AzGLuint fence) const;
    AzGLboolean test_object_apple(AzGLenum object, AzGLuint name) const;
    void finish_object_apple(AzGLenum object, AzGLuint name) const;
    void blend_barrier_khr() const;
    DebugMessageVec get_debug_messages() const;
    void provoking_vertex_angle(AzGLenum mode) const;
    GLuintVec gen_vertex_arrays_apple(AzGLsizei n) const;
    void bind_vertex_array_apple(AzGLuint vao) const;
    void delete_vertex_arrays_apple(GLuintVecRef vertex_arrays) const;
    void copy_texture_chromium(AzGLuint source_id, AzGLint source_level, AzGLenum dest_target, AzGLuint dest_id, AzGLint dest_level, AzGLint internal_format, AzGLenum dest_type, AzGLboolean unpack_flip_y, AzGLboolean unpack_premultiply_alpha, AzGLboolean unpack_unmultiply_alpha) const;
    void copy_sub_texture_chromium(AzGLuint source_id, AzGLint source_level, AzGLenum dest_target, AzGLuint dest_id, AzGLint dest_level, AzGLint x_offset, AzGLint y_offset, AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height, AzGLboolean unpack_flip_y, AzGLboolean unpack_premultiply_alpha, AzGLboolean unpack_unmultiply_alpha) const;
    void egl_image_target_renderbuffer_storage_oes(uint32_t target, GlVoidPtrConst image) const;
    void copy_texture_3d_angle(AzGLuint source_id, AzGLint source_level, AzGLenum dest_target, AzGLuint dest_id, AzGLint dest_level, AzGLint internal_format, AzGLenum dest_type, AzGLboolean unpack_flip_y, AzGLboolean unpack_premultiply_alpha, AzGLboolean unpack_unmultiply_alpha) const;
    void copy_sub_texture_3d_angle(AzGLuint source_id, AzGLint source_level, AzGLenum dest_target, AzGLuint dest_id, AzGLint dest_level, AzGLint x_offset, AzGLint y_offset, AzGLint z_offset, AzGLint x, AzGLint y, AzGLint z, AzGLsizei width, AzGLsizei height, AzGLsizei depth, AzGLboolean unpack_flip_y, AzGLboolean unpack_premultiply_alpha, AzGLboolean unpack_unmultiply_alpha) const;
    void buffer_storage(AzGLenum target, AzGLsizeiptr size, GlVoidPtrConst data, AzGLbitfield flags) const;
    void flush_mapped_buffer_range(AzGLenum target, AzGLintptr offset, AzGLsizeiptr length) const;
    AzGLuint get_svg_shader() const;
    AzGLuint get_fxaa_shader() const;
    void shader_source(AzGLuint shader, StringVec strings) const;
    void bind_attrib_location(AzGLuint program, AzGLuint index, String name) const;
    AzGLuint get_uniform_block_index(AzGLuint program, String name) const;
    GLuintVec get_uniform_indices(AzGLuint program, RefstrVecRef names) const;
    void vertex_attrib_pointer_f32(AzGLuint index, AzGLint size, bool normalized, AzGLsizei stride, AzGLuint offset) const;
    void vertex_attrib_pointer(AzGLuint index, AzGLint size, AzGLenum type_, bool normalized, AzGLsizei stride, AzGLuint offset) const;
    void vertex_attrib_i_pointer(AzGLuint index, AzGLint size, AzGLenum type_, AzGLsizei stride, AzGLuint offset) const;
    int get_attrib_location(AzGLuint program, String name) const;
    int get_frag_data_location(AzGLuint program, String name) const;
    int get_uniform_location(AzGLuint program, String name) const;
    String get_string(AzGLenum which) const;
    String get_string_i(AzGLenum which, AzGLuint index) const;
    void insert_event_marker_ext(String message) const;
    void push_group_marker_ext(String message) const;
    void debug_message_insert_khr(AzGLenum source, AzGLenum type_, AzGLuint id, AzGLenum severity, String message) const;
    void push_debug_group_khr(AzGLenum source, AzGLuint id, String message) const;
    AzGLint get_frag_data_index(AzGLuint program, String name) const;
    void bind_frag_data_location_indexed(AzGLuint program, AzGLuint color_number, AzGLuint index, String name) const;
    void delete_();
    GlContextPtr clone() const;
    bool partialEq(const GlContextPtr& b) const;
    uint8_t partialCmp(const GlContextPtr& b) const;
    uint8_t cmp(const GlContextPtr& b) const;
    String toDbgString() const;

    const AzGlContextPtr& inner() const { return inner_; }
    AzGlContextPtr& inner() { return inner_; }
    const AzGlContextPtr* ptr() const { return &inner_; }
    AzGlContextPtr* ptr() { return &inner_; }
    AzGlContextPtr release() { AzGlContextPtr result = inner_; inner_ = {}; return result; }
    operator AzGlContextPtr() && noexcept { AzGlContextPtr result = inner_; inner_ = {}; return result; }
};

class GLuintVecSlice {
private:
    AzGLuintVecSlice inner_;

public:
    GLuintVecSlice(AzGLuintVecSlice inner) noexcept : inner_(inner) {}
    GLuintVecSlice(const GLuintVecSlice& other) noexcept : inner_(other.inner_) {}
    GLuintVecSlice& operator=(const GLuintVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~GLuintVecSlice() {}

    String toDbgString() const;

    const AzGLuintVecSlice& inner() const { return inner_; }
    AzGLuintVecSlice& inner() { return inner_; }
    const AzGLuintVecSlice* ptr() const { return &inner_; }
    AzGLuintVecSlice* ptr() { return &inner_; }
    AzGLuintVecSlice release() { AzGLuintVecSlice result = inner_; inner_ = {}; return result; }
    operator AzGLuintVecSlice() && noexcept { AzGLuintVecSlice result = inner_; inner_ = {}; return result; }
};

class GLintVecSlice {
private:
    AzGLintVecSlice inner_;

public:
    GLintVecSlice(AzGLintVecSlice inner) noexcept : inner_(inner) {}
    GLintVecSlice(const GLintVecSlice& other) noexcept : inner_(other.inner_) {}
    GLintVecSlice& operator=(const GLintVecSlice& other) noexcept { inner_ = other.inner_; return *this; }
    ~GLintVecSlice() {}

    String toDbgString() const;

    const AzGLintVecSlice& inner() const { return inner_; }
    AzGLintVecSlice& inner() { return inner_; }
    const AzGLintVecSlice* ptr() const { return &inner_; }
    AzGLintVecSlice* ptr() { return &inner_; }
    AzGLintVecSlice release() { AzGLintVecSlice result = inner_; inner_ = {}; return result; }
    operator AzGLintVecSlice() && noexcept { AzGLintVecSlice result = inner_; inner_ = {}; return result; }
};

class ImageDescriptor {
private:
    AzImageDescriptor inner_;

public:
    ImageDescriptor(AzImageDescriptor inner) noexcept : inner_(inner) {}
    ImageDescriptor(const ImageDescriptor& other) noexcept : inner_(other.inner_) {}
    ImageDescriptor& operator=(const ImageDescriptor& other) noexcept { inner_ = other.inner_; return *this; }
    ~ImageDescriptor() {}

    bool partialEq(const ImageDescriptor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ImageDescriptor& b) const;
    uint8_t cmp(const ImageDescriptor& b) const;
    String toDbgString() const;

    const AzImageDescriptor& inner() const { return inner_; }
    AzImageDescriptor& inner() { return inner_; }
    const AzImageDescriptor* ptr() const { return &inner_; }
    AzImageDescriptor* ptr() { return &inner_; }
    AzImageDescriptor release() { AzImageDescriptor result = inner_; inner_ = {}; return result; }
    operator AzImageDescriptor() && noexcept { AzImageDescriptor result = inner_; inner_ = {}; return result; }
};

class FontMetrics {
private:
    AzFontMetrics inner_;

    FontMetrics(const FontMetrics&) = delete;
    FontMetrics& operator=(const FontMetrics&) = delete;

public:
    explicit FontMetrics(AzFontMetrics inner) noexcept : inner_(inner) {}

    FontMetrics(FontMetrics&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FontMetrics& operator=(FontMetrics&& other) noexcept {
        if (this != &other) {
            AzFontMetrics_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FontMetrics() { AzFontMetrics_delete(&inner_); }

    [[nodiscard]] static FontMetrics zero();
    [[nodiscard]] static FontMetrics default_();

    bool use_typo_metrics() const;
    int16_t get_ascender() const;
    int16_t get_descender() const;
    int16_t get_line_gap() const;
    int16_t get_x_min() const;
    int16_t get_y_min() const;
    int16_t get_x_max() const;
    int16_t get_y_max() const;
    uint16_t get_advance_width_max() const;
    int16_t get_min_left_side_bearing() const;
    int16_t get_min_right_side_bearing() const;
    int16_t get_x_max_extent() const;
    int16_t get_x_avg_char_width() const;
    int16_t get_y_subscript_x_size() const;
    int16_t get_y_subscript_y_size() const;
    int16_t get_y_subscript_x_offset() const;
    int16_t get_y_subscript_y_offset() const;
    int16_t get_y_superscript_x_size() const;
    int16_t get_y_superscript_y_size() const;
    int16_t get_y_superscript_x_offset() const;
    int16_t get_y_superscript_y_offset() const;
    void delete_();
    FontMetrics clone() const;
    bool partialEq(const FontMetrics& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const FontMetrics& b) const;
    uint8_t cmp(const FontMetrics& b) const;
    String toDbgString() const;

    const AzFontMetrics& inner() const { return inner_; }
    AzFontMetrics& inner() { return inner_; }
    const AzFontMetrics* ptr() const { return &inner_; }
    AzFontMetrics* ptr() { return &inner_; }
    AzFontMetrics release() { AzFontMetrics result = inner_; inner_ = {}; return result; }
    operator AzFontMetrics() && noexcept { AzFontMetrics result = inner_; inner_ = {}; return result; }
};

class FontRef {
private:
    AzFontRef inner_;

    FontRef(const FontRef&) = delete;
    FontRef& operator=(const FontRef&) = delete;

public:
    explicit FontRef(AzFontRef inner) noexcept : inner_(inner) {}

    FontRef(FontRef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FontRef& operator=(FontRef&& other) noexcept {
        if (this != &other) {
            AzFontRef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FontRef() { AzFontRef_delete(&inner_); }

    [[nodiscard]] static FontRef create(const void* parsed, AzFontRefDestructorCallbackType destructor);
    [[nodiscard]] static OptionFontRef parse(LoadedFontSource source);

    U8Vec get_bytes() const;
    FontMetrics get_font_metrics() const;
    uint64_t get_hash() const;
    void delete_();
    FontRef clone() const;
    bool partialEq(const FontRef& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const FontRef& b) const;
    uint8_t cmp(const FontRef& b) const;
    String toDbgString() const;

    const AzFontRef& inner() const { return inner_; }
    AzFontRef& inner() { return inner_; }
    const AzFontRef* ptr() const { return &inner_; }
    AzFontRef* ptr() { return &inner_; }
    AzFontRef release() { AzFontRef result = inner_; inner_ = {}; return result; }
    operator AzFontRef() && noexcept { AzFontRef result = inner_; inner_ = {}; return result; }
};

class LogicalRect {
private:
    AzLogicalRect inner_;

public:
    LogicalRect(AzLogicalRect inner) noexcept : inner_(inner) {}
    LogicalRect(const LogicalRect& other) noexcept : inner_(other.inner_) {}
    LogicalRect& operator=(const LogicalRect& other) noexcept { inner_ = other.inner_; return *this; }
    ~LogicalRect() {}

    [[nodiscard]] static LogicalRect create(LogicalPosition origin, LogicalSize size);
    [[nodiscard]] static LogicalRect zero();
    [[nodiscard]] static LogicalRect default_();

    float max_x() const;
    float min_x() const;
    float max_y() const;
    float min_y() const;
    bool contains(LogicalPosition point) const;
    bool intersects(LogicalRect other) const;
    bool partialEq(const LogicalRect& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LogicalRect& b) const;
    uint8_t cmp(const LogicalRect& b) const;
    String toDbgString() const;

    const AzLogicalRect& inner() const { return inner_; }
    AzLogicalRect& inner() { return inner_; }
    const AzLogicalRect* ptr() const { return &inner_; }
    AzLogicalRect* ptr() { return &inner_; }
    AzLogicalRect release() { AzLogicalRect result = inner_; inner_ = {}; return result; }
    operator AzLogicalRect() && noexcept { AzLogicalRect result = inner_; inner_ = {}; return result; }
};

class ShapeCircle {
private:
    AzShapeCircle inner_;

    ShapeCircle(const ShapeCircle&) = delete;
    ShapeCircle& operator=(const ShapeCircle&) = delete;

public:
    explicit ShapeCircle(AzShapeCircle inner) noexcept : inner_(inner) {}

    ShapeCircle(ShapeCircle&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ShapeCircle& operator=(ShapeCircle&& other) noexcept {
        if (this != &other) {
            AzShapeCircle_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ShapeCircle() { AzShapeCircle_delete(&inner_); }

    void delete_();
    ShapeCircle clone() const;
    bool partialEq(const ShapeCircle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ShapeCircle& b) const;
    uint8_t cmp(const ShapeCircle& b) const;
    String toDbgString() const;

    const AzShapeCircle& inner() const { return inner_; }
    AzShapeCircle& inner() { return inner_; }
    const AzShapeCircle* ptr() const { return &inner_; }
    AzShapeCircle* ptr() { return &inner_; }
    AzShapeCircle release() { AzShapeCircle result = inner_; inner_ = {}; return result; }
    operator AzShapeCircle() && noexcept { AzShapeCircle result = inner_; inner_ = {}; return result; }
};

class SvgLine {
private:
    AzSvgLine inner_;

public:
    SvgLine(AzSvgLine inner) noexcept : inner_(inner) {}
    SvgLine(const SvgLine& other) noexcept : inner_(other.inner_) {}
    SvgLine& operator=(const SvgLine& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgLine() {}

    bool partialEq(const SvgLine& b) const;
    uint8_t partialCmp(const SvgLine& b) const;
    String toDbgString() const;

    const AzSvgLine& inner() const { return inner_; }
    AzSvgLine& inner() { return inner_; }
    const AzSvgLine* ptr() const { return &inner_; }
    AzSvgLine* ptr() { return &inner_; }
    AzSvgLine release() { AzSvgLine result = inner_; inner_ = {}; return result; }
    operator AzSvgLine() && noexcept { AzSvgLine result = inner_; inner_ = {}; return result; }
};

class SvgCubicCurve {
private:
    AzSvgCubicCurve inner_;

public:
    SvgCubicCurve(AzSvgCubicCurve inner) noexcept : inner_(inner) {}
    SvgCubicCurve(const SvgCubicCurve& other) noexcept : inner_(other.inner_) {}
    SvgCubicCurve& operator=(const SvgCubicCurve& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgCubicCurve() {}

    bool partialEq(const SvgCubicCurve& b) const;
    uint8_t partialCmp(const SvgCubicCurve& b) const;
    String toDbgString() const;

    const AzSvgCubicCurve& inner() const { return inner_; }
    AzSvgCubicCurve& inner() { return inner_; }
    const AzSvgCubicCurve* ptr() const { return &inner_; }
    AzSvgCubicCurve* ptr() { return &inner_; }
    AzSvgCubicCurve release() { AzSvgCubicCurve result = inner_; inner_ = {}; return result; }
    operator AzSvgCubicCurve() && noexcept { AzSvgCubicCurve result = inner_; inner_ = {}; return result; }
};

class SvgQuadraticCurve {
private:
    AzSvgQuadraticCurve inner_;

public:
    SvgQuadraticCurve(AzSvgQuadraticCurve inner) noexcept : inner_(inner) {}
    SvgQuadraticCurve(const SvgQuadraticCurve& other) noexcept : inner_(other.inner_) {}
    SvgQuadraticCurve& operator=(const SvgQuadraticCurve& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgQuadraticCurve() {}

    bool partialEq(const SvgQuadraticCurve& b) const;
    uint8_t partialCmp(const SvgQuadraticCurve& b) const;
    String toDbgString() const;

    const AzSvgQuadraticCurve& inner() const { return inner_; }
    AzSvgQuadraticCurve& inner() { return inner_; }
    const AzSvgQuadraticCurve* ptr() const { return &inner_; }
    AzSvgQuadraticCurve* ptr() { return &inner_; }
    AzSvgQuadraticCurve release() { AzSvgQuadraticCurve result = inner_; inner_ = {}; return result; }
    operator AzSvgQuadraticCurve() && noexcept { AzSvgQuadraticCurve result = inner_; inner_ = {}; return result; }
};

class GetSystemTimeCallback {
private:
    AzGetSystemTimeCallback inner_;

    GetSystemTimeCallback(const GetSystemTimeCallback&) = delete;
    GetSystemTimeCallback& operator=(const GetSystemTimeCallback&) = delete;

public:
    explicit GetSystemTimeCallback(AzGetSystemTimeCallback inner) noexcept : inner_(inner) {}

    GetSystemTimeCallback(GetSystemTimeCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GetSystemTimeCallback& operator=(GetSystemTimeCallback&& other) noexcept {
        if (this != &other) {
            AzGetSystemTimeCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GetSystemTimeCallback() { AzGetSystemTimeCallback_delete(&inner_); }

    void delete_();
    GetSystemTimeCallback clone() const;
    bool partialEq(const GetSystemTimeCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GetSystemTimeCallback& b) const;
    uint8_t cmp(const GetSystemTimeCallback& b) const;
    String toDbgString() const;

    const AzGetSystemTimeCallback& inner() const { return inner_; }
    AzGetSystemTimeCallback& inner() { return inner_; }
    const AzGetSystemTimeCallback* ptr() const { return &inner_; }
    AzGetSystemTimeCallback* ptr() { return &inner_; }
    AzGetSystemTimeCallback release() { AzGetSystemTimeCallback result = inner_; inner_ = {}; return result; }
    operator AzGetSystemTimeCallback() && noexcept { AzGetSystemTimeCallback result = inner_; inner_ = {}; return result; }
};

class ScrollIntoViewOptions {
private:
    AzScrollIntoViewOptions inner_;

public:
    ScrollIntoViewOptions(AzScrollIntoViewOptions inner) noexcept : inner_(inner) {}
    ScrollIntoViewOptions(const ScrollIntoViewOptions& other) noexcept : inner_(other.inner_) {}
    ScrollIntoViewOptions& operator=(const ScrollIntoViewOptions& other) noexcept { inner_ = other.inner_; return *this; }
    ~ScrollIntoViewOptions() {}

    [[nodiscard]] static ScrollIntoViewOptions nearest();
    [[nodiscard]] static ScrollIntoViewOptions center();
    [[nodiscard]] static ScrollIntoViewOptions start();
    [[nodiscard]] static ScrollIntoViewOptions end();
    [[nodiscard]] static ScrollIntoViewOptions default_();

    ScrollIntoViewOptions with_instant() const;
    ScrollIntoViewOptions with_smooth() const;
    bool partialEq(const ScrollIntoViewOptions& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzScrollIntoViewOptions& inner() const { return inner_; }
    AzScrollIntoViewOptions& inner() { return inner_; }
    const AzScrollIntoViewOptions* ptr() const { return &inner_; }
    AzScrollIntoViewOptions* ptr() { return &inner_; }
    AzScrollIntoViewOptions release() { AzScrollIntoViewOptions result = inner_; inner_ = {}; return result; }
    operator AzScrollIntoViewOptions() && noexcept { AzScrollIntoViewOptions result = inner_; inner_ = {}; return result; }
};

class NonXmlCharError {
private:
    AzNonXmlCharError inner_;

    NonXmlCharError(const NonXmlCharError&) = delete;
    NonXmlCharError& operator=(const NonXmlCharError&) = delete;

public:
    explicit NonXmlCharError(AzNonXmlCharError inner) noexcept : inner_(inner) {}

    NonXmlCharError(NonXmlCharError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NonXmlCharError& operator=(NonXmlCharError&& other) noexcept {
        if (this != &other) {
            AzNonXmlCharError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NonXmlCharError() { AzNonXmlCharError_delete(&inner_); }

    void delete_();
    NonXmlCharError clone() const;
    bool partialEq(const NonXmlCharError& b) const;
    uint8_t partialCmp(const NonXmlCharError& b) const;
    String toDbgString() const;

    const AzNonXmlCharError& inner() const { return inner_; }
    AzNonXmlCharError& inner() { return inner_; }
    const AzNonXmlCharError* ptr() const { return &inner_; }
    AzNonXmlCharError* ptr() { return &inner_; }
    AzNonXmlCharError release() { AzNonXmlCharError result = inner_; inner_ = {}; return result; }
    operator AzNonXmlCharError() && noexcept { AzNonXmlCharError result = inner_; inner_ = {}; return result; }
};

class InvalidCharError {
private:
    AzInvalidCharError inner_;

    InvalidCharError(const InvalidCharError&) = delete;
    InvalidCharError& operator=(const InvalidCharError&) = delete;

public:
    explicit InvalidCharError(AzInvalidCharError inner) noexcept : inner_(inner) {}

    InvalidCharError(InvalidCharError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    InvalidCharError& operator=(InvalidCharError&& other) noexcept {
        if (this != &other) {
            AzInvalidCharError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~InvalidCharError() { AzInvalidCharError_delete(&inner_); }

    void delete_();
    InvalidCharError clone() const;
    bool partialEq(const InvalidCharError& b) const;
    uint8_t partialCmp(const InvalidCharError& b) const;
    String toDbgString() const;

    const AzInvalidCharError& inner() const { return inner_; }
    AzInvalidCharError& inner() { return inner_; }
    const AzInvalidCharError* ptr() const { return &inner_; }
    AzInvalidCharError* ptr() { return &inner_; }
    AzInvalidCharError release() { AzInvalidCharError result = inner_; inner_ = {}; return result; }
    operator AzInvalidCharError() && noexcept { AzInvalidCharError result = inner_; inner_ = {}; return result; }
};

class InvalidQuoteError {
private:
    AzInvalidQuoteError inner_;

    InvalidQuoteError(const InvalidQuoteError&) = delete;
    InvalidQuoteError& operator=(const InvalidQuoteError&) = delete;

public:
    explicit InvalidQuoteError(AzInvalidQuoteError inner) noexcept : inner_(inner) {}

    InvalidQuoteError(InvalidQuoteError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    InvalidQuoteError& operator=(InvalidQuoteError&& other) noexcept {
        if (this != &other) {
            AzInvalidQuoteError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~InvalidQuoteError() { AzInvalidQuoteError_delete(&inner_); }

    void delete_();
    InvalidQuoteError clone() const;
    bool partialEq(const InvalidQuoteError& b) const;
    uint8_t partialCmp(const InvalidQuoteError& b) const;
    String toDbgString() const;

    const AzInvalidQuoteError& inner() const { return inner_; }
    AzInvalidQuoteError& inner() { return inner_; }
    const AzInvalidQuoteError* ptr() const { return &inner_; }
    AzInvalidQuoteError* ptr() { return &inner_; }
    AzInvalidQuoteError release() { AzInvalidQuoteError result = inner_; inner_ = {}; return result; }
    operator AzInvalidQuoteError() && noexcept { AzInvalidQuoteError result = inner_; inner_ = {}; return result; }
};

class InvalidSpaceError {
private:
    AzInvalidSpaceError inner_;

    InvalidSpaceError(const InvalidSpaceError&) = delete;
    InvalidSpaceError& operator=(const InvalidSpaceError&) = delete;

public:
    explicit InvalidSpaceError(AzInvalidSpaceError inner) noexcept : inner_(inner) {}

    InvalidSpaceError(InvalidSpaceError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    InvalidSpaceError& operator=(InvalidSpaceError&& other) noexcept {
        if (this != &other) {
            AzInvalidSpaceError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~InvalidSpaceError() { AzInvalidSpaceError_delete(&inner_); }

    void delete_();
    InvalidSpaceError clone() const;
    bool partialEq(const InvalidSpaceError& b) const;
    uint8_t partialCmp(const InvalidSpaceError& b) const;
    String toDbgString() const;

    const AzInvalidSpaceError& inner() const { return inner_; }
    AzInvalidSpaceError& inner() { return inner_; }
    const AzInvalidSpaceError* ptr() const { return &inner_; }
    AzInvalidSpaceError* ptr() { return &inner_; }
    AzInvalidSpaceError release() { AzInvalidSpaceError result = inner_; inner_ = {}; return result; }
    operator AzInvalidSpaceError() && noexcept { AzInvalidSpaceError result = inner_; inner_ = {}; return result; }
};

class ErrorLocationRange {
private:
    AzErrorLocationRange inner_;

public:
    ErrorLocationRange(AzErrorLocationRange inner) noexcept : inner_(inner) {}
    ErrorLocationRange(const ErrorLocationRange& other) noexcept : inner_(other.inner_) {}
    ErrorLocationRange& operator=(const ErrorLocationRange& other) noexcept { inner_ = other.inner_; return *this; }
    ~ErrorLocationRange() {}

    [[nodiscard]] static ErrorLocationRange default_();

    bool partialEq(const ErrorLocationRange& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ErrorLocationRange& b) const;
    uint8_t cmp(const ErrorLocationRange& b) const;
    String toDbgString() const;

    const AzErrorLocationRange& inner() const { return inner_; }
    AzErrorLocationRange& inner() { return inner_; }
    const AzErrorLocationRange* ptr() const { return &inner_; }
    AzErrorLocationRange* ptr() { return &inner_; }
    AzErrorLocationRange release() { AzErrorLocationRange result = inner_; inner_ = {}; return result; }
    operator AzErrorLocationRange() && noexcept { AzErrorLocationRange result = inner_; inner_ = {}; return result; }
};

class RendererOptions {
private:
    AzRendererOptions inner_;

public:
    RendererOptions(AzRendererOptions inner) noexcept : inner_(inner) {}
    RendererOptions(const RendererOptions& other) noexcept : inner_(other.inner_) {}
    RendererOptions& operator=(const RendererOptions& other) noexcept { inner_ = other.inner_; return *this; }
    ~RendererOptions() {}

    [[nodiscard]] static RendererOptions default_();

    bool partialEq(const RendererOptions& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const RendererOptions& b) const;
    uint8_t cmp(const RendererOptions& b) const;
    String toDbgString() const;

    const AzRendererOptions& inner() const { return inner_; }
    AzRendererOptions& inner() { return inner_; }
    const AzRendererOptions* ptr() const { return &inner_; }
    AzRendererOptions* ptr() { return &inner_; }
    AzRendererOptions release() { AzRendererOptions result = inner_; inner_ = {}; return result; }
    operator AzRendererOptions() && noexcept { AzRendererOptions result = inner_; inner_ = {}; return result; }
};

class FileMetadata {
private:
    AzFileMetadata inner_;

    FileMetadata(const FileMetadata&) = delete;
    FileMetadata& operator=(const FileMetadata&) = delete;

public:
    explicit FileMetadata(AzFileMetadata inner) noexcept : inner_(inner) {}

    FileMetadata(FileMetadata&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FileMetadata& operator=(FileMetadata&& other) noexcept {
        if (this != &other) {
            AzFileMetadata_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FileMetadata() { AzFileMetadata_delete(&inner_); }

    void delete_();
    FileMetadata clone() const;
    bool partialEq(const FileMetadata& b) const;
    String toDbgString() const;

    const AzFileMetadata& inner() const { return inner_; }
    AzFileMetadata& inner() { return inner_; }
    const AzFileMetadata* ptr() const { return &inner_; }
    AzFileMetadata* ptr() { return &inner_; }
    AzFileMetadata release() { AzFileMetadata result = inner_; inner_ = {}; return result; }
    operator AzFileMetadata() && noexcept { AzFileMetadata result = inner_; inner_ = {}; return result; }
};

class SensorReading {
private:
    AzSensorReading inner_;

public:
    SensorReading(AzSensorReading inner) noexcept : inner_(inner) {}
    SensorReading(const SensorReading& other) noexcept : inner_(other.inner_) {}
    SensorReading& operator=(const SensorReading& other) noexcept { inner_ = other.inner_; return *this; }
    ~SensorReading() {}

    bool partialEq(const SensorReading& b) const;
    String toDbgString() const;

    const AzSensorReading& inner() const { return inner_; }
    AzSensorReading& inner() { return inner_; }
    const AzSensorReading* ptr() const { return &inner_; }
    AzSensorReading* ptr() { return &inner_; }
    AzSensorReading release() { AzSensorReading result = inner_; inner_ = {}; return result; }
    operator AzSensorReading() && noexcept { AzSensorReading result = inner_; inner_ = {}; return result; }
};

class GamepadState {
private:
    AzGamepadState inner_;

public:
    GamepadState(AzGamepadState inner) noexcept : inner_(inner) {}
    GamepadState(const GamepadState& other) noexcept : inner_(other.inner_) {}
    GamepadState& operator=(const GamepadState& other) noexcept { inner_ = other.inner_; return *this; }
    ~GamepadState() {}

    bool is_pressed(AzGamepadButton button) const;
    float axis(AzGamepadAxis axis) const;
    bool partialEq(const GamepadState& b) const;
    String toDbgString() const;

    const AzGamepadState& inner() const { return inner_; }
    AzGamepadState& inner() { return inner_; }
    const AzGamepadState* ptr() const { return &inner_; }
    AzGamepadState* ptr() { return &inner_; }
    AzGamepadState release() { AzGamepadState result = inner_; inner_ = {}; return result; }
    operator AzGamepadState() && noexcept { AzGamepadState result = inner_; inner_ = {}; return result; }
};

class CameraConfig {
private:
    AzCameraConfig inner_;

public:
    CameraConfig(AzCameraConfig inner) noexcept : inner_(inner) {}
    CameraConfig(const CameraConfig& other) noexcept : inner_(other.inner_) {}
    CameraConfig& operator=(const CameraConfig& other) noexcept { inner_ = other.inner_; return *this; }
    ~CameraConfig() {}

    [[nodiscard]] static CameraConfig default_();

    bool partialEq(const CameraConfig& b) const;
    String toDbgString() const;

    const AzCameraConfig& inner() const { return inner_; }
    AzCameraConfig& inner() { return inner_; }
    const AzCameraConfig* ptr() const { return &inner_; }
    AzCameraConfig* ptr() { return &inner_; }
    AzCameraConfig release() { AzCameraConfig result = inner_; inner_ = {}; return result; }
    operator AzCameraConfig() && noexcept { AzCameraConfig result = inner_; inner_ = {}; return result; }
};

class ScreenCaptureConfig {
private:
    AzScreenCaptureConfig inner_;

public:
    ScreenCaptureConfig(AzScreenCaptureConfig inner) noexcept : inner_(inner) {}
    ScreenCaptureConfig(const ScreenCaptureConfig& other) noexcept : inner_(other.inner_) {}
    ScreenCaptureConfig& operator=(const ScreenCaptureConfig& other) noexcept { inner_ = other.inner_; return *this; }
    ~ScreenCaptureConfig() {}

    [[nodiscard]] static ScreenCaptureConfig default_();

    bool partialEq(const ScreenCaptureConfig& b) const;
    String toDbgString() const;

    const AzScreenCaptureConfig& inner() const { return inner_; }
    AzScreenCaptureConfig& inner() { return inner_; }
    const AzScreenCaptureConfig* ptr() const { return &inner_; }
    AzScreenCaptureConfig* ptr() { return &inner_; }
    AzScreenCaptureConfig release() { AzScreenCaptureConfig result = inner_; inner_ = {}; return result; }
    operator AzScreenCaptureConfig() && noexcept { AzScreenCaptureConfig result = inner_; inner_ = {}; return result; }
};

class DetectedRotation {
private:
    AzDetectedRotation inner_;

public:
    DetectedRotation(AzDetectedRotation inner) noexcept : inner_(inner) {}
    DetectedRotation(const DetectedRotation& other) noexcept : inner_(other.inner_) {}
    DetectedRotation& operator=(const DetectedRotation& other) noexcept { inner_ = other.inner_; return *this; }
    ~DetectedRotation() {}

    bool partialEq(const DetectedRotation& b) const;
    String toDbgString() const;

    const AzDetectedRotation& inner() const { return inner_; }
    AzDetectedRotation& inner() { return inner_; }
    const AzDetectedRotation* ptr() const { return &inner_; }
    AzDetectedRotation* ptr() { return &inner_; }
    AzDetectedRotation release() { AzDetectedRotation result = inner_; inner_ = {}; return result; }
    operator AzDetectedRotation() && noexcept { AzDetectedRotation result = inner_; inner_ = {}; return result; }
};

class DetectedLongPress {
private:
    AzDetectedLongPress inner_;

public:
    DetectedLongPress(AzDetectedLongPress inner) noexcept : inner_(inner) {}
    DetectedLongPress(const DetectedLongPress& other) noexcept : inner_(other.inner_) {}
    DetectedLongPress& operator=(const DetectedLongPress& other) noexcept { inner_ = other.inner_; return *this; }
    ~DetectedLongPress() {}

    bool partialEq(const DetectedLongPress& b) const;
    String toDbgString() const;

    const AzDetectedLongPress& inner() const { return inner_; }
    AzDetectedLongPress& inner() { return inner_; }
    const AzDetectedLongPress* ptr() const { return &inner_; }
    AzDetectedLongPress* ptr() { return &inner_; }
    AzDetectedLongPress release() { AzDetectedLongPress result = inner_; inner_ = {}; return result; }
    operator AzDetectedLongPress() && noexcept { AzDetectedLongPress result = inner_; inner_ = {}; return result; }
};

class IcuDateTime {
private:
    AzIcuDateTime inner_;

public:
    IcuDateTime(AzIcuDateTime inner) noexcept : inner_(inner) {}
    IcuDateTime(const IcuDateTime& other) noexcept : inner_(other.inner_) {}
    IcuDateTime& operator=(const IcuDateTime& other) noexcept { inner_ = other.inner_; return *this; }
    ~IcuDateTime() {}

    bool partialEq(const IcuDateTime& b) const;
    String toDbgString() const;

    const AzIcuDateTime& inner() const { return inner_; }
    AzIcuDateTime& inner() { return inner_; }
    const AzIcuDateTime* ptr() const { return &inner_; }
    AzIcuDateTime* ptr() { return &inner_; }
    AzIcuDateTime release() { AzIcuDateTime result = inner_; inner_ = {}; return result; }
    operator AzIcuDateTime() && noexcept { AzIcuDateTime result = inner_; inner_ = {}; return result; }
};

class HidpiAdjustedBounds {
private:
    AzHidpiAdjustedBounds inner_;

public:
    HidpiAdjustedBounds(AzHidpiAdjustedBounds inner) noexcept : inner_(inner) {}
    HidpiAdjustedBounds(const HidpiAdjustedBounds& other) noexcept : inner_(other.inner_) {}
    HidpiAdjustedBounds& operator=(const HidpiAdjustedBounds& other) noexcept { inner_ = other.inner_; return *this; }
    ~HidpiAdjustedBounds() {}

    [[nodiscard]] static HidpiAdjustedBounds from_bounds(LayoutSize bounds, DpiScaleFactor hidpi_factor);

    AzPhysicalSizeU32 get_physical_size() const;
    LogicalSize get_logical_size() const;
    DpiScaleFactor get_hidpi_factor() const;
    String toDbgString() const;

    const AzHidpiAdjustedBounds& inner() const { return inner_; }
    AzHidpiAdjustedBounds& inner() { return inner_; }
    const AzHidpiAdjustedBounds* ptr() const { return &inner_; }
    AzHidpiAdjustedBounds* ptr() { return &inner_; }
    AzHidpiAdjustedBounds release() { AzHidpiAdjustedBounds result = inner_; inner_ = {}; return result; }
    operator AzHidpiAdjustedBounds() && noexcept { AzHidpiAdjustedBounds result = inner_; inner_ = {}; return result; }
};

class WindowSize {
private:
    AzWindowSize inner_;

public:
    WindowSize(AzWindowSize inner) noexcept : inner_(inner) {}
    WindowSize(const WindowSize& other) noexcept : inner_(other.inner_) {}
    WindowSize& operator=(const WindowSize& other) noexcept { inner_ = other.inner_; return *this; }
    ~WindowSize() {}

    [[nodiscard]] static WindowSize default_();

    bool partialEq(const WindowSize& b) const;
    uint8_t partialCmp(const WindowSize& b) const;
    String toDbgString() const;

    const AzWindowSize& inner() const { return inner_; }
    AzWindowSize& inner() { return inner_; }
    const AzWindowSize* ptr() const { return &inner_; }
    AzWindowSize* ptr() { return &inner_; }
    AzWindowSize release() { AzWindowSize result = inner_; inner_ = {}; return result; }
    operator AzWindowSize() && noexcept { AzWindowSize result = inner_; inner_ = {}; return result; }
};

class TextOpMoveCursor {
private:
    AzTextOpMoveCursor inner_;

    TextOpMoveCursor(const TextOpMoveCursor&) = delete;
    TextOpMoveCursor& operator=(const TextOpMoveCursor&) = delete;

public:
    explicit TextOpMoveCursor(AzTextOpMoveCursor inner) noexcept : inner_(inner) {}

    TextOpMoveCursor(TextOpMoveCursor&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextOpMoveCursor& operator=(TextOpMoveCursor&& other) noexcept {
        if (this != &other) {
            AzTextOpMoveCursor_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextOpMoveCursor() { AzTextOpMoveCursor_delete(&inner_); }

    void delete_();
    TextOpMoveCursor clone() const;
    String toDbgString() const;

    const AzTextOpMoveCursor& inner() const { return inner_; }
    AzTextOpMoveCursor& inner() { return inner_; }
    const AzTextOpMoveCursor* ptr() const { return &inner_; }
    AzTextOpMoveCursor* ptr() { return &inner_; }
    AzTextOpMoveCursor release() { AzTextOpMoveCursor result = inner_; inner_ = {}; return result; }
    operator AzTextOpMoveCursor() && noexcept { AzTextOpMoveCursor result = inner_; inner_ = {}; return result; }
};

class CallbackInfo {
private:
    AzCallbackInfo inner_;

public:
    CallbackInfo(AzCallbackInfo inner) noexcept : inner_(inner) {}
    CallbackInfo(const CallbackInfo& other) noexcept : inner_(other.inner_) {}
    CallbackInfo& operator=(const CallbackInfo& other) noexcept { inner_ = other.inner_; return *this; }
    ~CallbackInfo() {}

    OptionRefAny get_ctx() const;
    OptionGlContextPtr get_gl_context() const;
    void add_timer(TimerId timer_id, Timer timer);
    void remove_timer(TimerId timer_id);
    void add_thread(ThreadId thread_id, Thread thread);
    void remove_thread(ThreadId thread_id);
    void stop_propagation();
    void stop_immediate_propagation();
    void create_window(WindowCreateOptions options);
    void close_window();
    void modify_window_state(FullWindowState state);
    void add_image_to_cache(String id, ImageRef image);
    void remove_image_from_cache(String id);
    void reload_system_fonts();
    void prevent_default();
    void open_menu(Menu menu);
    void open_menu_at(Menu menu, LogicalPosition position);
    void show_tooltip(String text);
    void show_tooltip_at(String text, LogicalPosition position);
    void hide_tooltip();
    bool open_menu_for_hit_node(Menu menu);
    WindowFlags get_current_window_flags() const;
    OptionLogicalPosition get_scroll_offset() const;
    KeyboardState get_current_keyboard_state() const;
    MouseState get_current_mouse_state() const;
    OptionCursorNodePosition get_cursor_relative_to_node() const;
    OptionLogicalPosition get_cursor_relative_to_viewport() const;
    OptionLogicalPosition get_cursor_position() const;
    OptionScreenPosition get_cursor_position_screen() const;
    OptionDragDelta get_drag_delta() const;
    OptionDragDelta get_drag_delta_screen() const;
    OptionDragDelta get_drag_delta_screen_incremental() const;
    void begin_interactive_move();
    MonitorVec get_monitors() const;
    OptionMonitor get_current_monitor() const;
    AzInstant get_current_time() const;
    bool is_dom_focused(DomId dom_id) const;
    bool is_pen_in_contact() const;
    bool is_pen_eraser() const;
    bool is_pen_barrel_button_pressed() const;
    void set_focus_to_path(DomId dom_id, CssPath css_path);
    void focus_next();
    void focus_previous();
    void focus_first();
    void focus_last();
    void clear_focus();
    bool is_dragging() const;
    bool is_drag_active() const;
    bool is_node_drag_active() const;
    bool is_file_drag_active() const;
    bool has_sufficient_history_for_gestures() const;
    void change_node_text(DomNodeId node_id, String text);
    void update_image_callback(DomId dom_id, NodeId node_id);
    void update_all_image_callbacks();
    void trigger_virtual_view_rerender(DomId dom_id, NodeId node_id);
    NodeHierarchyItemId get_node_id_by_id_attribute(DomId dom_id, String id) const;
    NodeHierarchyItemId get_parent_node(DomId dom_id, NodeId node_id) const;
    NodeHierarchyItemId get_next_sibling_node(DomId dom_id, NodeId node_id) const;
    NodeHierarchyItemId get_previous_sibling_node(DomId dom_id, NodeId node_id) const;
    NodeHierarchyItemId get_first_child_node(DomId dom_id, NodeId node_id) const;
    NodeHierarchyItemId get_last_child_node(DomId dom_id, NodeId node_id) const;
    void change_node_image_mask(DomId dom_id, NodeId node_id, ImageMask mask);
    void set_css_property(DomNodeId node_id, AzCssProperty property);
    void scroll_to(DomId dom_id, NodeHierarchyItemId node_id, LogicalPosition position);
    void insert_text(DomId dom_id, NodeId node_id, String text);
    SelectionId add_cursor(DomId dom_id, NodeId node_id, TextCursor cursor);
    SelectionId add_selection_range(DomId dom_id, NodeId node_id, SelectionRange range);
    bool remove_selection_by_id(SelectionId selection_id);
    size_t get_selection_count(DomId dom_id) const;
    bool open_menu_for_node(Menu menu, DomNodeId node_id);
    OptionLogicalSize get_node_size(DomNodeId node_id) const;
    OptionLogicalPosition get_node_position(DomNodeId node_id) const;
    OptionLogicalRect get_node_rect(DomNodeId node_id) const;
    OptionLogicalRect get_hit_node_rect() const;
    OptionTimer get_timer(TimerId timer_id) const;
    TimerIdVec get_timer_ids() const;
    OptionThread get_thread(ThreadId thread_id) const;
    ThreadIdVec get_thread_ids() const;
    DomIdVec get_dom_ids() const;
    DomNodeId get_hit_node() const;
    OptionDomNodeId get_parent(DomNodeId node_id) const;
    OptionDomNodeId get_previous_sibling(DomNodeId node_id) const;
    OptionDomNodeId get_next_sibling(DomNodeId node_id) const;
    OptionDomNodeId get_first_child(DomNodeId node_id) const;
    OptionDomNodeId get_last_child(DomNodeId node_id) const;
    OptionRefAny get_dataset(DomNodeId node_id);
    OptionDomNodeId get_node_id_of_root_dataset(RefAny search_key);
    OptionString get_string_contents(DomNodeId node_id) const;
    OptionSelectionState get_selection(DomId dom_id) const;
    bool has_selection(DomId dom_id) const;
    OptionTextCursor get_primary_cursor(DomId dom_id) const;
    SelectionRangeVec get_selection_ranges(DomId dom_id) const;
    FullWindowState get_current_window_state() const;
    OptionWindowFlags get_previous_window_flags() const;
    OptionKeyboardState get_previous_keyboard_state() const;
    OptionMouseState get_previous_mouse_state() const;
    AzRawWindowHandle get_current_window_handle() const;
    OptionLogicalRect get_hit_node_layout_rect() const;
    OptionCssProperty get_computed_css_property(DomNodeId node_id, AzCssPropertyType property_type) const;
    OptionCssProperty get_computed_width(DomNodeId node_id) const;
    OptionCssProperty get_computed_height(DomNodeId node_id) const;
    GetSystemTimeCallback get_system_time_fn() const;
    bool is_node_focused(DomNodeId node_id) const;
    OptionPenState get_pen_state() const;
    OptionF32 get_pen_pressure() const;
    OptionPenTilt get_pen_tilt() const;
    OptionU64 get_current_event_id() const;
    void set_focus_to_node(DomId dom_id, NodeId node_id);
    OptionDomNodeId get_focused_node() const;
    bool has_focus(DomNodeId node_id) const;
    OptionString get_hovered_file() const;
    OptionString get_dropped_file() const;
    OptionDomNodeId get_dragged_node() const;
    OptionString get_dragged_file() const;
    OptionDragState get_drag_state() const;
    OptionLogicalPosition get_scroll_offset_for_node(DomId dom_id, NodeId node_id) const;
    OptionLogicalPosition get_scroll_delta(DomId dom_id, NodeId node_id) const;
    bool had_scroll_activity(DomId dom_id, NodeId node_id) const;
    OptionScrollState get_scroll_state(DomId dom_id, NodeId node_id) const;
    OptionSelectionRange inspect_paste_target_range(DomNodeId target) const;
    OptionSelectAllResult inspect_select_all_changeset(DomNodeId target) const;
    OptionDeleteResult inspect_delete_changeset(DomNodeId target, bool forward) const;
    OptionClipboardContent get_clipboard_content() const;
    OptionClipboardContent inspect_copy_changeset(DomNodeId target) const;
    OptionClipboardContent inspect_cut_changeset(DomNodeId target) const;
    void set_clipboard_content(ClipboardContent content);
    void set_copy_content(DomNodeId target, ClipboardContent content);
    void set_cut_content(DomNodeId target, ClipboardContent content);
    void set_select_all_range(DomNodeId target, SelectionRange range);
    OptionString get_node_text_content(DomNodeId target) const;
    OptionTextCursor get_node_cursor_position(DomNodeId target) const;
    SelectionRangeVec get_node_selection_ranges(DomNodeId target) const;
    bool node_has_selection(DomNodeId target) const;
    OptionUsize get_node_text_length(DomNodeId target) const;
    bool can_undo(NodeId node_id) const;
    bool can_redo(NodeId node_id) const;
    OptionString get_undo_text(NodeId node_id) const;
    OptionString get_redo_text(NodeId node_id) const;
    OptionUndoableOperation inspect_undo_operation(NodeId node_id) const;
    OptionUndoableOperation inspect_redo_operation(NodeId node_id) const;
    OptionTextCursor inspect_move_cursor_left(DomNodeId target) const;
    OptionTextCursor inspect_move_cursor_right(DomNodeId target) const;
    OptionTextCursor inspect_move_cursor_up(DomNodeId target) const;
    OptionTextCursor inspect_move_cursor_down(DomNodeId target) const;
    OptionTextCursor inspect_move_cursor_to_line_start(DomNodeId target) const;
    OptionTextCursor inspect_move_cursor_to_line_end(DomNodeId target) const;
    OptionTextCursor inspect_move_cursor_to_document_start(DomNodeId target) const;
    OptionTextCursor inspect_move_cursor_to_document_end(DomNodeId target) const;
    OptionDeleteResult inspect_backspace(DomNodeId target) const;
    OptionDeleteResult inspect_delete(DomNodeId target) const;
    void move_cursor_left(DomNodeId target, bool extend_selection);
    void move_cursor_right(DomNodeId target, bool extend_selection);
    void move_cursor_up(DomNodeId target, bool extend_selection);
    void move_cursor_down(DomNodeId target, bool extend_selection);
    void move_cursor_to_line_start(DomNodeId target, bool extend_selection);
    void move_cursor_to_line_end(DomNodeId target, bool extend_selection);
    void move_cursor_to_document_start(DomNodeId target, bool extend_selection);
    void move_cursor_to_document_end(DomNodeId target, bool extend_selection);
    void delete_backward(DomNodeId target);
    void delete_forward(DomNodeId target);
    NodeHierarchyItemIdVec get_all_children_nodes(DomId dom_id, NodeId node_id) const;
    size_t get_children_count(DomId dom_id, NodeId node_id) const;
    OptionString get_node_tag_name(DomNodeId node_id) const;
    OptionString get_node_attribute(DomNodeId node_id, String attr_name) const;
    StringVec get_node_classes(DomNodeId node_id) const;
    OptionString get_node_id(DomNodeId node_id) const;
    ResultU8VecString take_screenshot(DomId dom_id) const;
    ResultVoidString take_screenshot_to_file(DomId dom_id, String path) const;
    ResultVoidString take_native_screenshot(String path) const;
    ResultU8VecString take_native_screenshot_bytes() const;
    ResultStringString take_native_screenshot_base64() const;
    ResultStringString take_screenshot_base64(DomId dom_id) const;
    OptionPendingTextEdit get_text_changeset() const;
    void accept_drop();
    StringVec get_drag_types() const;
    void set_drag_data(String mime_type, U8Vec data);
    void set_drop_effect(AzDropEffect effect);
    bool was_double_clicked() const;
    OptionGestureDirection get_swipe_direction() const;
    OptionDetectedPinch get_pinch() const;
    OptionDetectedRotation get_rotation() const;
    OptionDetectedLongPress get_long_press() const;
    OptionLocationFix get_location_fix() const;
    OptionBiometricResult get_biometric_result() const;
    AzBiometricKind get_biometric_kind() const;
    void request_biometric_auth(BiometricPrompt prompt);
    void keyring_store(String key, String secret, bool require_biometry);
    void keyring_get(String key);
    void keyring_delete(String key);
    OptionKeyringResult get_keyring_result() const;
    OptionSensorReading get_sensor_reading(AzSensorKind kind) const;
    OptionGamepadState get_gamepad_state(GamepadId id) const;
    OptionGamepadState get_primary_gamepad() const;
    OptionWacomPadState get_wacom_pad() const;
    SafeAreaInsets get_safe_area_insets() const;
    LoadedFontVec get_loaded_fonts() const;
    OptionU8Vec get_loaded_font_bytes(uint64_t font_hash) const;
    String toDbgString() const;

    const AzCallbackInfo& inner() const { return inner_; }
    AzCallbackInfo& inner() { return inner_; }
    const AzCallbackInfo* ptr() const { return &inner_; }
    AzCallbackInfo* ptr() { return &inner_; }
    AzCallbackInfo release() { AzCallbackInfo result = inner_; inner_ = {}; return result; }
    operator AzCallbackInfo() && noexcept { AzCallbackInfo result = inner_; inner_ = {}; return result; }
};

class TagIdToNodeIdMapping {
private:
    AzTagIdToNodeIdMapping inner_;

    TagIdToNodeIdMapping(const TagIdToNodeIdMapping&) = delete;
    TagIdToNodeIdMapping& operator=(const TagIdToNodeIdMapping&) = delete;

public:
    explicit TagIdToNodeIdMapping(AzTagIdToNodeIdMapping inner) noexcept : inner_(inner) {}

    TagIdToNodeIdMapping(TagIdToNodeIdMapping&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TagIdToNodeIdMapping& operator=(TagIdToNodeIdMapping&& other) noexcept {
        if (this != &other) {
            AzTagIdToNodeIdMapping_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TagIdToNodeIdMapping() { AzTagIdToNodeIdMapping_delete(&inner_); }

    void delete_();
    TagIdToNodeIdMapping clone() const;
    bool partialEq(const TagIdToNodeIdMapping& b) const;
    uint8_t partialCmp(const TagIdToNodeIdMapping& b) const;
    uint8_t cmp(const TagIdToNodeIdMapping& b) const;
    String toDbgString() const;

    const AzTagIdToNodeIdMapping& inner() const { return inner_; }
    AzTagIdToNodeIdMapping& inner() { return inner_; }
    const AzTagIdToNodeIdMapping* ptr() const { return &inner_; }
    AzTagIdToNodeIdMapping* ptr() { return &inner_; }
    AzTagIdToNodeIdMapping release() { AzTagIdToNodeIdMapping result = inner_; inner_ = {}; return result; }
    operator AzTagIdToNodeIdMapping() && noexcept { AzTagIdToNodeIdMapping result = inner_; inner_ = {}; return result; }
};

class MouseState {
private:
    AzMouseState inner_;

public:
    MouseState(AzMouseState inner) noexcept : inner_(inner) {}
    MouseState(const MouseState& other) noexcept : inner_(other.inner_) {}
    MouseState& operator=(const MouseState& other) noexcept { inner_ = other.inner_; return *this; }
    ~MouseState() {}

    [[nodiscard]] static MouseState default_();

    bool partialEq(const MouseState& b) const;
    uint8_t partialCmp(const MouseState& b) const;
    String toDbgString() const;

    const AzMouseState& inner() const { return inner_; }
    AzMouseState& inner() { return inner_; }
    const AzMouseState* ptr() const { return &inner_; }
    AzMouseState* ptr() { return &inner_; }
    AzMouseState release() { AzMouseState result = inner_; inner_ = {}; return result; }
    operator AzMouseState() && noexcept { AzMouseState result = inner_; inner_ = {}; return result; }
};

class SelectionRange {
private:
    AzSelectionRange inner_;

public:
    SelectionRange(AzSelectionRange inner) noexcept : inner_(inner) {}
    SelectionRange(const SelectionRange& other) noexcept : inner_(other.inner_) {}
    SelectionRange& operator=(const SelectionRange& other) noexcept { inner_ = other.inner_; return *this; }
    ~SelectionRange() {}

    bool partialEq(const SelectionRange& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const SelectionRange& b) const;
    uint8_t cmp(const SelectionRange& b) const;
    String toDbgString() const;

    const AzSelectionRange& inner() const { return inner_; }
    AzSelectionRange& inner() { return inner_; }
    const AzSelectionRange* ptr() const { return &inner_; }
    AzSelectionRange* ptr() { return &inner_; }
    AzSelectionRange release() { AzSelectionRange result = inner_; inner_ = {}; return result; }
    operator AzSelectionRange() && noexcept { AzSelectionRange result = inner_; inner_ = {}; return result; }
};

class SelectionRadius {
private:
    AzSelectionRadius inner_;

public:
    SelectionRadius(AzSelectionRadius inner) noexcept : inner_(inner) {}
    SelectionRadius(const SelectionRadius& other) noexcept : inner_(other.inner_) {}
    SelectionRadius& operator=(const SelectionRadius& other) noexcept { inner_ = other.inner_; return *this; }
    ~SelectionRadius() {}

    [[nodiscard]] static SelectionRadius default_();

    bool partialEq(const SelectionRadius& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const SelectionRadius& b) const;
    uint8_t cmp(const SelectionRadius& b) const;
    String toDbgString() const;

    const AzSelectionRadius& inner() const { return inner_; }
    AzSelectionRadius& inner() { return inner_; }
    const AzSelectionRadius* ptr() const { return &inner_; }
    AzSelectionRadius* ptr() { return &inner_; }
    AzSelectionRadius release() { AzSelectionRadius result = inner_; inner_ = {}; return result; }
    operator AzSelectionRadius() && noexcept { AzSelectionRadius result = inner_; inner_ = {}; return result; }
};

class PixelValueSize {
private:
    AzPixelValueSize inner_;

public:
    PixelValueSize(AzPixelValueSize inner) noexcept : inner_(inner) {}
    PixelValueSize(const PixelValueSize& other) noexcept : inner_(other.inner_) {}
    PixelValueSize& operator=(const PixelValueSize& other) noexcept { inner_ = other.inner_; return *this; }
    ~PixelValueSize() {}

    bool partialEq(const PixelValueSize& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const PixelValueSize& b) const;
    uint8_t cmp(const PixelValueSize& b) const;
    String toDbgString() const;

    const AzPixelValueSize& inner() const { return inner_; }
    AzPixelValueSize& inner() { return inner_; }
    const AzPixelValueSize* ptr() const { return &inner_; }
    AzPixelValueSize* ptr() { return &inner_; }
    AzPixelValueSize release() { AzPixelValueSize result = inner_; inner_ = {}; return result; }
    operator AzPixelValueSize() && noexcept { AzPixelValueSize result = inner_; inner_ = {}; return result; }
};

class PixelValueNoPercent {
private:
    AzPixelValueNoPercent inner_;

public:
    PixelValueNoPercent(AzPixelValueNoPercent inner) noexcept : inner_(inner) {}
    PixelValueNoPercent(const PixelValueNoPercent& other) noexcept : inner_(other.inner_) {}
    PixelValueNoPercent& operator=(const PixelValueNoPercent& other) noexcept { inner_ = other.inner_; return *this; }
    ~PixelValueNoPercent() {}

    [[nodiscard]] static PixelValueNoPercent default_();

    bool partialEq(const PixelValueNoPercent& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const PixelValueNoPercent& b) const;
    uint8_t cmp(const PixelValueNoPercent& b) const;
    String toDbgString() const;

    const AzPixelValueNoPercent& inner() const { return inner_; }
    AzPixelValueNoPercent& inner() { return inner_; }
    const AzPixelValueNoPercent* ptr() const { return &inner_; }
    AzPixelValueNoPercent* ptr() { return &inner_; }
    AzPixelValueNoPercent release() { AzPixelValueNoPercent result = inner_; inner_ = {}; return result; }
    operator AzPixelValueNoPercent() && noexcept { AzPixelValueNoPercent result = inner_; inner_ = {}; return result; }
};

class StyleBlur {
private:
    AzStyleBlur inner_;

    StyleBlur(const StyleBlur&) = delete;
    StyleBlur& operator=(const StyleBlur&) = delete;

public:
    explicit StyleBlur(AzStyleBlur inner) noexcept : inner_(inner) {}

    StyleBlur(StyleBlur&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyleBlur& operator=(StyleBlur&& other) noexcept {
        if (this != &other) {
            AzStyleBlur_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyleBlur() { AzStyleBlur_delete(&inner_); }

    [[nodiscard]] static StyleBlur default_();

    void delete_();
    StyleBlur clone() const;
    bool partialEq(const StyleBlur& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBlur& b) const;
    uint8_t cmp(const StyleBlur& b) const;
    String toDbgString() const;

    const AzStyleBlur& inner() const { return inner_; }
    AzStyleBlur& inner() { return inner_; }
    const AzStyleBlur* ptr() const { return &inner_; }
    AzStyleBlur* ptr() { return &inner_; }
    AzStyleBlur release() { AzStyleBlur result = inner_; inner_ = {}; return result; }
    operator AzStyleBlur() && noexcept { AzStyleBlur result = inner_; inner_ = {}; return result; }
};

class StyleFilterOffset {
private:
    AzStyleFilterOffset inner_;

    StyleFilterOffset(const StyleFilterOffset&) = delete;
    StyleFilterOffset& operator=(const StyleFilterOffset&) = delete;

public:
    explicit StyleFilterOffset(AzStyleFilterOffset inner) noexcept : inner_(inner) {}

    StyleFilterOffset(StyleFilterOffset&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyleFilterOffset& operator=(StyleFilterOffset&& other) noexcept {
        if (this != &other) {
            AzStyleFilterOffset_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyleFilterOffset() { AzStyleFilterOffset_delete(&inner_); }

    [[nodiscard]] static StyleFilterOffset default_();

    void delete_();
    StyleFilterOffset clone() const;
    bool partialEq(const StyleFilterOffset& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleFilterOffset& b) const;
    uint8_t cmp(const StyleFilterOffset& b) const;
    String toDbgString() const;

    const AzStyleFilterOffset& inner() const { return inner_; }
    AzStyleFilterOffset& inner() { return inner_; }
    const AzStyleFilterOffset* ptr() const { return &inner_; }
    AzStyleFilterOffset* ptr() { return &inner_; }
    AzStyleFilterOffset release() { AzStyleFilterOffset result = inner_; inner_ = {}; return result; }
    operator AzStyleFilterOffset() && noexcept { AzStyleFilterOffset result = inner_; inner_ = {}; return result; }
};

class LayoutLeft {
private:
    AzLayoutLeft inner_;

public:
    LayoutLeft(AzLayoutLeft inner) noexcept : inner_(inner) {}
    LayoutLeft(const LayoutLeft& other) noexcept : inner_(other.inner_) {}
    LayoutLeft& operator=(const LayoutLeft& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutLeft() {}

    [[nodiscard]] static LayoutLeft default_();

    bool partialEq(const LayoutLeft& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutLeft& b) const;
    uint8_t cmp(const LayoutLeft& b) const;

    const AzLayoutLeft& inner() const { return inner_; }
    AzLayoutLeft& inner() { return inner_; }
    const AzLayoutLeft* ptr() const { return &inner_; }
    AzLayoutLeft* ptr() { return &inner_; }
    AzLayoutLeft release() { AzLayoutLeft result = inner_; inner_ = {}; return result; }
    operator AzLayoutLeft() && noexcept { AzLayoutLeft result = inner_; inner_ = {}; return result; }
};

class LayoutMarginBottom {
private:
    AzLayoutMarginBottom inner_;

public:
    LayoutMarginBottom(AzLayoutMarginBottom inner) noexcept : inner_(inner) {}
    LayoutMarginBottom(const LayoutMarginBottom& other) noexcept : inner_(other.inner_) {}
    LayoutMarginBottom& operator=(const LayoutMarginBottom& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutMarginBottom() {}

    [[nodiscard]] static LayoutMarginBottom default_();

    bool partialEq(const LayoutMarginBottom& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutMarginBottom& b) const;
    uint8_t cmp(const LayoutMarginBottom& b) const;
    String toDbgString() const;

    const AzLayoutMarginBottom& inner() const { return inner_; }
    AzLayoutMarginBottom& inner() { return inner_; }
    const AzLayoutMarginBottom* ptr() const { return &inner_; }
    AzLayoutMarginBottom* ptr() { return &inner_; }
    AzLayoutMarginBottom release() { AzLayoutMarginBottom result = inner_; inner_ = {}; return result; }
    operator AzLayoutMarginBottom() && noexcept { AzLayoutMarginBottom result = inner_; inner_ = {}; return result; }
};

class LayoutMarginLeft {
private:
    AzLayoutMarginLeft inner_;

public:
    LayoutMarginLeft(AzLayoutMarginLeft inner) noexcept : inner_(inner) {}
    LayoutMarginLeft(const LayoutMarginLeft& other) noexcept : inner_(other.inner_) {}
    LayoutMarginLeft& operator=(const LayoutMarginLeft& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutMarginLeft() {}

    [[nodiscard]] static LayoutMarginLeft default_();

    bool partialEq(const LayoutMarginLeft& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutMarginLeft& b) const;
    uint8_t cmp(const LayoutMarginLeft& b) const;
    String toDbgString() const;

    const AzLayoutMarginLeft& inner() const { return inner_; }
    AzLayoutMarginLeft& inner() { return inner_; }
    const AzLayoutMarginLeft* ptr() const { return &inner_; }
    AzLayoutMarginLeft* ptr() { return &inner_; }
    AzLayoutMarginLeft release() { AzLayoutMarginLeft result = inner_; inner_ = {}; return result; }
    operator AzLayoutMarginLeft() && noexcept { AzLayoutMarginLeft result = inner_; inner_ = {}; return result; }
};

class LayoutMarginRight {
private:
    AzLayoutMarginRight inner_;

public:
    LayoutMarginRight(AzLayoutMarginRight inner) noexcept : inner_(inner) {}
    LayoutMarginRight(const LayoutMarginRight& other) noexcept : inner_(other.inner_) {}
    LayoutMarginRight& operator=(const LayoutMarginRight& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutMarginRight() {}

    [[nodiscard]] static LayoutMarginRight default_();

    bool partialEq(const LayoutMarginRight& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutMarginRight& b) const;
    uint8_t cmp(const LayoutMarginRight& b) const;
    String toDbgString() const;

    const AzLayoutMarginRight& inner() const { return inner_; }
    AzLayoutMarginRight& inner() { return inner_; }
    const AzLayoutMarginRight* ptr() const { return &inner_; }
    AzLayoutMarginRight* ptr() { return &inner_; }
    AzLayoutMarginRight release() { AzLayoutMarginRight result = inner_; inner_ = {}; return result; }
    operator AzLayoutMarginRight() && noexcept { AzLayoutMarginRight result = inner_; inner_ = {}; return result; }
};

class LayoutMarginTop {
private:
    AzLayoutMarginTop inner_;

public:
    LayoutMarginTop(AzLayoutMarginTop inner) noexcept : inner_(inner) {}
    LayoutMarginTop(const LayoutMarginTop& other) noexcept : inner_(other.inner_) {}
    LayoutMarginTop& operator=(const LayoutMarginTop& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutMarginTop() {}

    [[nodiscard]] static LayoutMarginTop default_();

    bool partialEq(const LayoutMarginTop& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutMarginTop& b) const;
    uint8_t cmp(const LayoutMarginTop& b) const;
    String toDbgString() const;

    const AzLayoutMarginTop& inner() const { return inner_; }
    AzLayoutMarginTop& inner() { return inner_; }
    const AzLayoutMarginTop* ptr() const { return &inner_; }
    AzLayoutMarginTop* ptr() { return &inner_; }
    AzLayoutMarginTop release() { AzLayoutMarginTop result = inner_; inner_ = {}; return result; }
    operator AzLayoutMarginTop() && noexcept { AzLayoutMarginTop result = inner_; inner_ = {}; return result; }
};

class LayoutMaxHeight {
private:
    AzLayoutMaxHeight inner_;

public:
    LayoutMaxHeight(AzLayoutMaxHeight inner) noexcept : inner_(inner) {}
    LayoutMaxHeight(const LayoutMaxHeight& other) noexcept : inner_(other.inner_) {}
    LayoutMaxHeight& operator=(const LayoutMaxHeight& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutMaxHeight() {}

    bool partialEq(const LayoutMaxHeight& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutMaxHeight& b) const;
    uint8_t cmp(const LayoutMaxHeight& b) const;
    String toDbgString() const;

    const AzLayoutMaxHeight& inner() const { return inner_; }
    AzLayoutMaxHeight& inner() { return inner_; }
    const AzLayoutMaxHeight* ptr() const { return &inner_; }
    AzLayoutMaxHeight* ptr() { return &inner_; }
    AzLayoutMaxHeight release() { AzLayoutMaxHeight result = inner_; inner_ = {}; return result; }
    operator AzLayoutMaxHeight() && noexcept { AzLayoutMaxHeight result = inner_; inner_ = {}; return result; }
};

class LayoutMaxWidth {
private:
    AzLayoutMaxWidth inner_;

public:
    LayoutMaxWidth(AzLayoutMaxWidth inner) noexcept : inner_(inner) {}
    LayoutMaxWidth(const LayoutMaxWidth& other) noexcept : inner_(other.inner_) {}
    LayoutMaxWidth& operator=(const LayoutMaxWidth& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutMaxWidth() {}

    bool partialEq(const LayoutMaxWidth& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutMaxWidth& b) const;
    uint8_t cmp(const LayoutMaxWidth& b) const;
    String toDbgString() const;

    const AzLayoutMaxWidth& inner() const { return inner_; }
    AzLayoutMaxWidth& inner() { return inner_; }
    const AzLayoutMaxWidth* ptr() const { return &inner_; }
    AzLayoutMaxWidth* ptr() { return &inner_; }
    AzLayoutMaxWidth release() { AzLayoutMaxWidth result = inner_; inner_ = {}; return result; }
    operator AzLayoutMaxWidth() && noexcept { AzLayoutMaxWidth result = inner_; inner_ = {}; return result; }
};

class LayoutMinHeight {
private:
    AzLayoutMinHeight inner_;

public:
    LayoutMinHeight(AzLayoutMinHeight inner) noexcept : inner_(inner) {}
    LayoutMinHeight(const LayoutMinHeight& other) noexcept : inner_(other.inner_) {}
    LayoutMinHeight& operator=(const LayoutMinHeight& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutMinHeight() {}

    bool partialEq(const LayoutMinHeight& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutMinHeight& b) const;
    uint8_t cmp(const LayoutMinHeight& b) const;
    String toDbgString() const;

    const AzLayoutMinHeight& inner() const { return inner_; }
    AzLayoutMinHeight& inner() { return inner_; }
    const AzLayoutMinHeight* ptr() const { return &inner_; }
    AzLayoutMinHeight* ptr() { return &inner_; }
    AzLayoutMinHeight release() { AzLayoutMinHeight result = inner_; inner_ = {}; return result; }
    operator AzLayoutMinHeight() && noexcept { AzLayoutMinHeight result = inner_; inner_ = {}; return result; }
};

class LayoutMinWidth {
private:
    AzLayoutMinWidth inner_;

public:
    LayoutMinWidth(AzLayoutMinWidth inner) noexcept : inner_(inner) {}
    LayoutMinWidth(const LayoutMinWidth& other) noexcept : inner_(other.inner_) {}
    LayoutMinWidth& operator=(const LayoutMinWidth& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutMinWidth() {}

    bool partialEq(const LayoutMinWidth& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutMinWidth& b) const;
    uint8_t cmp(const LayoutMinWidth& b) const;
    String toDbgString() const;

    const AzLayoutMinWidth& inner() const { return inner_; }
    AzLayoutMinWidth& inner() { return inner_; }
    const AzLayoutMinWidth* ptr() const { return &inner_; }
    AzLayoutMinWidth* ptr() { return &inner_; }
    AzLayoutMinWidth release() { AzLayoutMinWidth result = inner_; inner_ = {}; return result; }
    operator AzLayoutMinWidth() && noexcept { AzLayoutMinWidth result = inner_; inner_ = {}; return result; }
};

class LayoutPaddingBottom {
private:
    AzLayoutPaddingBottom inner_;

public:
    LayoutPaddingBottom(AzLayoutPaddingBottom inner) noexcept : inner_(inner) {}
    LayoutPaddingBottom(const LayoutPaddingBottom& other) noexcept : inner_(other.inner_) {}
    LayoutPaddingBottom& operator=(const LayoutPaddingBottom& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutPaddingBottom() {}

    [[nodiscard]] static LayoutPaddingBottom default_();

    bool partialEq(const LayoutPaddingBottom& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutPaddingBottom& b) const;
    uint8_t cmp(const LayoutPaddingBottom& b) const;
    String toDbgString() const;

    const AzLayoutPaddingBottom& inner() const { return inner_; }
    AzLayoutPaddingBottom& inner() { return inner_; }
    const AzLayoutPaddingBottom* ptr() const { return &inner_; }
    AzLayoutPaddingBottom* ptr() { return &inner_; }
    AzLayoutPaddingBottom release() { AzLayoutPaddingBottom result = inner_; inner_ = {}; return result; }
    operator AzLayoutPaddingBottom() && noexcept { AzLayoutPaddingBottom result = inner_; inner_ = {}; return result; }
};

class LayoutPaddingLeft {
private:
    AzLayoutPaddingLeft inner_;

public:
    LayoutPaddingLeft(AzLayoutPaddingLeft inner) noexcept : inner_(inner) {}
    LayoutPaddingLeft(const LayoutPaddingLeft& other) noexcept : inner_(other.inner_) {}
    LayoutPaddingLeft& operator=(const LayoutPaddingLeft& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutPaddingLeft() {}

    [[nodiscard]] static LayoutPaddingLeft default_();

    bool partialEq(const LayoutPaddingLeft& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutPaddingLeft& b) const;
    uint8_t cmp(const LayoutPaddingLeft& b) const;
    String toDbgString() const;

    const AzLayoutPaddingLeft& inner() const { return inner_; }
    AzLayoutPaddingLeft& inner() { return inner_; }
    const AzLayoutPaddingLeft* ptr() const { return &inner_; }
    AzLayoutPaddingLeft* ptr() { return &inner_; }
    AzLayoutPaddingLeft release() { AzLayoutPaddingLeft result = inner_; inner_ = {}; return result; }
    operator AzLayoutPaddingLeft() && noexcept { AzLayoutPaddingLeft result = inner_; inner_ = {}; return result; }
};

class LayoutPaddingRight {
private:
    AzLayoutPaddingRight inner_;

public:
    LayoutPaddingRight(AzLayoutPaddingRight inner) noexcept : inner_(inner) {}
    LayoutPaddingRight(const LayoutPaddingRight& other) noexcept : inner_(other.inner_) {}
    LayoutPaddingRight& operator=(const LayoutPaddingRight& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutPaddingRight() {}

    [[nodiscard]] static LayoutPaddingRight default_();

    bool partialEq(const LayoutPaddingRight& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutPaddingRight& b) const;
    uint8_t cmp(const LayoutPaddingRight& b) const;
    String toDbgString() const;

    const AzLayoutPaddingRight& inner() const { return inner_; }
    AzLayoutPaddingRight& inner() { return inner_; }
    const AzLayoutPaddingRight* ptr() const { return &inner_; }
    AzLayoutPaddingRight* ptr() { return &inner_; }
    AzLayoutPaddingRight release() { AzLayoutPaddingRight result = inner_; inner_ = {}; return result; }
    operator AzLayoutPaddingRight() && noexcept { AzLayoutPaddingRight result = inner_; inner_ = {}; return result; }
};

class LayoutPaddingTop {
private:
    AzLayoutPaddingTop inner_;

public:
    LayoutPaddingTop(AzLayoutPaddingTop inner) noexcept : inner_(inner) {}
    LayoutPaddingTop(const LayoutPaddingTop& other) noexcept : inner_(other.inner_) {}
    LayoutPaddingTop& operator=(const LayoutPaddingTop& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutPaddingTop() {}

    [[nodiscard]] static LayoutPaddingTop default_();

    bool partialEq(const LayoutPaddingTop& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutPaddingTop& b) const;
    uint8_t cmp(const LayoutPaddingTop& b) const;
    String toDbgString() const;

    const AzLayoutPaddingTop& inner() const { return inner_; }
    AzLayoutPaddingTop& inner() { return inner_; }
    const AzLayoutPaddingTop* ptr() const { return &inner_; }
    AzLayoutPaddingTop* ptr() { return &inner_; }
    AzLayoutPaddingTop release() { AzLayoutPaddingTop result = inner_; inner_ = {}; return result; }
    operator AzLayoutPaddingTop() && noexcept { AzLayoutPaddingTop result = inner_; inner_ = {}; return result; }
};

class LayoutRight {
private:
    AzLayoutRight inner_;

public:
    LayoutRight(AzLayoutRight inner) noexcept : inner_(inner) {}
    LayoutRight(const LayoutRight& other) noexcept : inner_(other.inner_) {}
    LayoutRight& operator=(const LayoutRight& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutRight() {}

    [[nodiscard]] static LayoutRight default_();

    bool partialEq(const LayoutRight& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutRight& b) const;
    uint8_t cmp(const LayoutRight& b) const;

    const AzLayoutRight& inner() const { return inner_; }
    AzLayoutRight& inner() { return inner_; }
    const AzLayoutRight* ptr() const { return &inner_; }
    AzLayoutRight* ptr() { return &inner_; }
    AzLayoutRight release() { AzLayoutRight result = inner_; inner_ = {}; return result; }
    operator AzLayoutRight() && noexcept { AzLayoutRight result = inner_; inner_ = {}; return result; }
};

class LayoutTop {
private:
    AzLayoutTop inner_;

public:
    LayoutTop(AzLayoutTop inner) noexcept : inner_(inner) {}
    LayoutTop(const LayoutTop& other) noexcept : inner_(other.inner_) {}
    LayoutTop& operator=(const LayoutTop& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutTop() {}

    [[nodiscard]] static LayoutTop default_();

    bool partialEq(const LayoutTop& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutTop& b) const;
    uint8_t cmp(const LayoutTop& b) const;

    const AzLayoutTop& inner() const { return inner_; }
    AzLayoutTop& inner() { return inner_; }
    const AzLayoutTop* ptr() const { return &inner_; }
    AzLayoutTop* ptr() { return &inner_; }
    AzLayoutTop release() { AzLayoutTop result = inner_; inner_ = {}; return result; }
    operator AzLayoutTop() && noexcept { AzLayoutTop result = inner_; inner_ = {}; return result; }
};

class NormalizedLinearColorStop {
private:
    AzNormalizedLinearColorStop inner_;

    NormalizedLinearColorStop(const NormalizedLinearColorStop&) = delete;
    NormalizedLinearColorStop& operator=(const NormalizedLinearColorStop&) = delete;

public:
    explicit NormalizedLinearColorStop(AzNormalizedLinearColorStop inner) noexcept : inner_(inner) {}

    NormalizedLinearColorStop(NormalizedLinearColorStop&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NormalizedLinearColorStop& operator=(NormalizedLinearColorStop&& other) noexcept {
        if (this != &other) {
            AzNormalizedLinearColorStop_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NormalizedLinearColorStop() { AzNormalizedLinearColorStop_delete(&inner_); }

    void delete_();
    NormalizedLinearColorStop clone() const;
    bool partialEq(const NormalizedLinearColorStop& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NormalizedLinearColorStop& b) const;
    uint8_t cmp(const NormalizedLinearColorStop& b) const;
    String toDbgString() const;

    const AzNormalizedLinearColorStop& inner() const { return inner_; }
    AzNormalizedLinearColorStop& inner() { return inner_; }
    const AzNormalizedLinearColorStop* ptr() const { return &inner_; }
    AzNormalizedLinearColorStop* ptr() { return &inner_; }
    AzNormalizedLinearColorStop release() { AzNormalizedLinearColorStop result = inner_; inner_ = {}; return result; }
    operator AzNormalizedLinearColorStop() && noexcept { AzNormalizedLinearColorStop result = inner_; inner_ = {}; return result; }
};

class NormalizedRadialColorStop {
private:
    AzNormalizedRadialColorStop inner_;

    NormalizedRadialColorStop(const NormalizedRadialColorStop&) = delete;
    NormalizedRadialColorStop& operator=(const NormalizedRadialColorStop&) = delete;

public:
    explicit NormalizedRadialColorStop(AzNormalizedRadialColorStop inner) noexcept : inner_(inner) {}

    NormalizedRadialColorStop(NormalizedRadialColorStop&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NormalizedRadialColorStop& operator=(NormalizedRadialColorStop&& other) noexcept {
        if (this != &other) {
            AzNormalizedRadialColorStop_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NormalizedRadialColorStop() { AzNormalizedRadialColorStop_delete(&inner_); }

    void delete_();
    NormalizedRadialColorStop clone() const;
    bool partialEq(const NormalizedRadialColorStop& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NormalizedRadialColorStop& b) const;
    uint8_t cmp(const NormalizedRadialColorStop& b) const;
    String toDbgString() const;

    const AzNormalizedRadialColorStop& inner() const { return inner_; }
    AzNormalizedRadialColorStop& inner() { return inner_; }
    const AzNormalizedRadialColorStop* ptr() const { return &inner_; }
    AzNormalizedRadialColorStop* ptr() { return &inner_; }
    AzNormalizedRadialColorStop release() { AzNormalizedRadialColorStop result = inner_; inner_ = {}; return result; }
    operator AzNormalizedRadialColorStop() && noexcept { AzNormalizedRadialColorStop result = inner_; inner_ = {}; return result; }
};

class StyleBorderBottomLeftRadius {
private:
    AzStyleBorderBottomLeftRadius inner_;

public:
    StyleBorderBottomLeftRadius(AzStyleBorderBottomLeftRadius inner) noexcept : inner_(inner) {}
    StyleBorderBottomLeftRadius(const StyleBorderBottomLeftRadius& other) noexcept : inner_(other.inner_) {}
    StyleBorderBottomLeftRadius& operator=(const StyleBorderBottomLeftRadius& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBorderBottomLeftRadius() {}

    [[nodiscard]] static StyleBorderBottomLeftRadius default_();

    bool partialEq(const StyleBorderBottomLeftRadius& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBorderBottomLeftRadius& b) const;
    uint8_t cmp(const StyleBorderBottomLeftRadius& b) const;

    const AzStyleBorderBottomLeftRadius& inner() const { return inner_; }
    AzStyleBorderBottomLeftRadius& inner() { return inner_; }
    const AzStyleBorderBottomLeftRadius* ptr() const { return &inner_; }
    AzStyleBorderBottomLeftRadius* ptr() { return &inner_; }
    AzStyleBorderBottomLeftRadius release() { AzStyleBorderBottomLeftRadius result = inner_; inner_ = {}; return result; }
    operator AzStyleBorderBottomLeftRadius() && noexcept { AzStyleBorderBottomLeftRadius result = inner_; inner_ = {}; return result; }
};

class StyleBorderBottomRightRadius {
private:
    AzStyleBorderBottomRightRadius inner_;

public:
    StyleBorderBottomRightRadius(AzStyleBorderBottomRightRadius inner) noexcept : inner_(inner) {}
    StyleBorderBottomRightRadius(const StyleBorderBottomRightRadius& other) noexcept : inner_(other.inner_) {}
    StyleBorderBottomRightRadius& operator=(const StyleBorderBottomRightRadius& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBorderBottomRightRadius() {}

    [[nodiscard]] static StyleBorderBottomRightRadius default_();

    bool partialEq(const StyleBorderBottomRightRadius& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBorderBottomRightRadius& b) const;
    uint8_t cmp(const StyleBorderBottomRightRadius& b) const;

    const AzStyleBorderBottomRightRadius& inner() const { return inner_; }
    AzStyleBorderBottomRightRadius& inner() { return inner_; }
    const AzStyleBorderBottomRightRadius* ptr() const { return &inner_; }
    AzStyleBorderBottomRightRadius* ptr() { return &inner_; }
    AzStyleBorderBottomRightRadius release() { AzStyleBorderBottomRightRadius result = inner_; inner_ = {}; return result; }
    operator AzStyleBorderBottomRightRadius() && noexcept { AzStyleBorderBottomRightRadius result = inner_; inner_ = {}; return result; }
};

class LayoutBorderBottomWidth {
private:
    AzLayoutBorderBottomWidth inner_;

public:
    LayoutBorderBottomWidth(AzLayoutBorderBottomWidth inner) noexcept : inner_(inner) {}
    LayoutBorderBottomWidth(const LayoutBorderBottomWidth& other) noexcept : inner_(other.inner_) {}
    LayoutBorderBottomWidth& operator=(const LayoutBorderBottomWidth& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutBorderBottomWidth() {}

    bool partialEq(const LayoutBorderBottomWidth& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutBorderBottomWidth& b) const;
    uint8_t cmp(const LayoutBorderBottomWidth& b) const;

    const AzLayoutBorderBottomWidth& inner() const { return inner_; }
    AzLayoutBorderBottomWidth& inner() { return inner_; }
    const AzLayoutBorderBottomWidth* ptr() const { return &inner_; }
    AzLayoutBorderBottomWidth* ptr() { return &inner_; }
    AzLayoutBorderBottomWidth release() { AzLayoutBorderBottomWidth result = inner_; inner_ = {}; return result; }
    operator AzLayoutBorderBottomWidth() && noexcept { AzLayoutBorderBottomWidth result = inner_; inner_ = {}; return result; }
};

class LayoutBorderLeftWidth {
private:
    AzLayoutBorderLeftWidth inner_;

public:
    LayoutBorderLeftWidth(AzLayoutBorderLeftWidth inner) noexcept : inner_(inner) {}
    LayoutBorderLeftWidth(const LayoutBorderLeftWidth& other) noexcept : inner_(other.inner_) {}
    LayoutBorderLeftWidth& operator=(const LayoutBorderLeftWidth& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutBorderLeftWidth() {}

    bool partialEq(const LayoutBorderLeftWidth& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutBorderLeftWidth& b) const;
    uint8_t cmp(const LayoutBorderLeftWidth& b) const;

    const AzLayoutBorderLeftWidth& inner() const { return inner_; }
    AzLayoutBorderLeftWidth& inner() { return inner_; }
    const AzLayoutBorderLeftWidth* ptr() const { return &inner_; }
    AzLayoutBorderLeftWidth* ptr() { return &inner_; }
    AzLayoutBorderLeftWidth release() { AzLayoutBorderLeftWidth result = inner_; inner_ = {}; return result; }
    operator AzLayoutBorderLeftWidth() && noexcept { AzLayoutBorderLeftWidth result = inner_; inner_ = {}; return result; }
};

class LayoutBorderRightWidth {
private:
    AzLayoutBorderRightWidth inner_;

public:
    LayoutBorderRightWidth(AzLayoutBorderRightWidth inner) noexcept : inner_(inner) {}
    LayoutBorderRightWidth(const LayoutBorderRightWidth& other) noexcept : inner_(other.inner_) {}
    LayoutBorderRightWidth& operator=(const LayoutBorderRightWidth& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutBorderRightWidth() {}

    bool partialEq(const LayoutBorderRightWidth& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutBorderRightWidth& b) const;
    uint8_t cmp(const LayoutBorderRightWidth& b) const;

    const AzLayoutBorderRightWidth& inner() const { return inner_; }
    AzLayoutBorderRightWidth& inner() { return inner_; }
    const AzLayoutBorderRightWidth* ptr() const { return &inner_; }
    AzLayoutBorderRightWidth* ptr() { return &inner_; }
    AzLayoutBorderRightWidth release() { AzLayoutBorderRightWidth result = inner_; inner_ = {}; return result; }
    operator AzLayoutBorderRightWidth() && noexcept { AzLayoutBorderRightWidth result = inner_; inner_ = {}; return result; }
};

class StyleBorderTopLeftRadius {
private:
    AzStyleBorderTopLeftRadius inner_;

public:
    StyleBorderTopLeftRadius(AzStyleBorderTopLeftRadius inner) noexcept : inner_(inner) {}
    StyleBorderTopLeftRadius(const StyleBorderTopLeftRadius& other) noexcept : inner_(other.inner_) {}
    StyleBorderTopLeftRadius& operator=(const StyleBorderTopLeftRadius& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBorderTopLeftRadius() {}

    [[nodiscard]] static StyleBorderTopLeftRadius default_();

    bool partialEq(const StyleBorderTopLeftRadius& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBorderTopLeftRadius& b) const;
    uint8_t cmp(const StyleBorderTopLeftRadius& b) const;

    const AzStyleBorderTopLeftRadius& inner() const { return inner_; }
    AzStyleBorderTopLeftRadius& inner() { return inner_; }
    const AzStyleBorderTopLeftRadius* ptr() const { return &inner_; }
    AzStyleBorderTopLeftRadius* ptr() { return &inner_; }
    AzStyleBorderTopLeftRadius release() { AzStyleBorderTopLeftRadius result = inner_; inner_ = {}; return result; }
    operator AzStyleBorderTopLeftRadius() && noexcept { AzStyleBorderTopLeftRadius result = inner_; inner_ = {}; return result; }
};

class StyleBorderTopRightRadius {
private:
    AzStyleBorderTopRightRadius inner_;

public:
    StyleBorderTopRightRadius(AzStyleBorderTopRightRadius inner) noexcept : inner_(inner) {}
    StyleBorderTopRightRadius(const StyleBorderTopRightRadius& other) noexcept : inner_(other.inner_) {}
    StyleBorderTopRightRadius& operator=(const StyleBorderTopRightRadius& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBorderTopRightRadius() {}

    [[nodiscard]] static StyleBorderTopRightRadius default_();

    bool partialEq(const StyleBorderTopRightRadius& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBorderTopRightRadius& b) const;
    uint8_t cmp(const StyleBorderTopRightRadius& b) const;

    const AzStyleBorderTopRightRadius& inner() const { return inner_; }
    AzStyleBorderTopRightRadius& inner() { return inner_; }
    const AzStyleBorderTopRightRadius* ptr() const { return &inner_; }
    AzStyleBorderTopRightRadius* ptr() { return &inner_; }
    AzStyleBorderTopRightRadius release() { AzStyleBorderTopRightRadius result = inner_; inner_ = {}; return result; }
    operator AzStyleBorderTopRightRadius() && noexcept { AzStyleBorderTopRightRadius result = inner_; inner_ = {}; return result; }
};

class LayoutBorderTopWidth {
private:
    AzLayoutBorderTopWidth inner_;

public:
    LayoutBorderTopWidth(AzLayoutBorderTopWidth inner) noexcept : inner_(inner) {}
    LayoutBorderTopWidth(const LayoutBorderTopWidth& other) noexcept : inner_(other.inner_) {}
    LayoutBorderTopWidth& operator=(const LayoutBorderTopWidth& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutBorderTopWidth() {}

    bool partialEq(const LayoutBorderTopWidth& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutBorderTopWidth& b) const;
    uint8_t cmp(const LayoutBorderTopWidth& b) const;

    const AzLayoutBorderTopWidth& inner() const { return inner_; }
    AzLayoutBorderTopWidth& inner() { return inner_; }
    const AzLayoutBorderTopWidth* ptr() const { return &inner_; }
    AzLayoutBorderTopWidth* ptr() { return &inner_; }
    AzLayoutBorderTopWidth release() { AzLayoutBorderTopWidth result = inner_; inner_ = {}; return result; }
    operator AzLayoutBorderTopWidth() && noexcept { AzLayoutBorderTopWidth result = inner_; inner_ = {}; return result; }
};

class StyleFontSize {
private:
    AzStyleFontSize inner_;

public:
    StyleFontSize(AzStyleFontSize inner) noexcept : inner_(inner) {}
    StyleFontSize(const StyleFontSize& other) noexcept : inner_(other.inner_) {}
    StyleFontSize& operator=(const StyleFontSize& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleFontSize() {}

    [[nodiscard]] static StyleFontSize px(float value);
    [[nodiscard]] static StyleFontSize default_();

    bool partialEq(const StyleFontSize& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleFontSize& b) const;
    uint8_t cmp(const StyleFontSize& b) const;
    String toDbgString() const;

    const AzStyleFontSize& inner() const { return inner_; }
    AzStyleFontSize& inner() { return inner_; }
    const AzStyleFontSize* ptr() const { return &inner_; }
    AzStyleFontSize* ptr() { return &inner_; }
    AzStyleFontSize release() { AzStyleFontSize result = inner_; inner_ = {}; return result; }
    operator AzStyleFontSize() && noexcept { AzStyleFontSize result = inner_; inner_ = {}; return result; }
};

class StyleLetterSpacing {
private:
    AzStyleLetterSpacing inner_;

public:
    StyleLetterSpacing(AzStyleLetterSpacing inner) noexcept : inner_(inner) {}
    StyleLetterSpacing(const StyleLetterSpacing& other) noexcept : inner_(other.inner_) {}
    StyleLetterSpacing& operator=(const StyleLetterSpacing& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleLetterSpacing() {}

    [[nodiscard]] static StyleLetterSpacing default_();

    bool partialEq(const StyleLetterSpacing& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleLetterSpacing& b) const;
    uint8_t cmp(const StyleLetterSpacing& b) const;
    String toDbgString() const;

    const AzStyleLetterSpacing& inner() const { return inner_; }
    AzStyleLetterSpacing& inner() { return inner_; }
    const AzStyleLetterSpacing* ptr() const { return &inner_; }
    AzStyleLetterSpacing* ptr() { return &inner_; }
    AzStyleLetterSpacing release() { AzStyleLetterSpacing result = inner_; inner_ = {}; return result; }
    operator AzStyleLetterSpacing() && noexcept { AzStyleLetterSpacing result = inner_; inner_ = {}; return result; }
};

class StyleLineHeight {
private:
    AzStyleLineHeight inner_;

public:
    StyleLineHeight(AzStyleLineHeight inner) noexcept : inner_(inner) {}
    StyleLineHeight(const StyleLineHeight& other) noexcept : inner_(other.inner_) {}
    StyleLineHeight& operator=(const StyleLineHeight& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleLineHeight() {}

    [[nodiscard]] static StyleLineHeight default_();

    bool partialEq(const StyleLineHeight& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleLineHeight& b) const;
    uint8_t cmp(const StyleLineHeight& b) const;

    const AzStyleLineHeight& inner() const { return inner_; }
    AzStyleLineHeight& inner() { return inner_; }
    const AzStyleLineHeight* ptr() const { return &inner_; }
    AzStyleLineHeight* ptr() { return &inner_; }
    AzStyleLineHeight release() { AzStyleLineHeight result = inner_; inner_ = {}; return result; }
    operator AzStyleLineHeight() && noexcept { AzStyleLineHeight result = inner_; inner_ = {}; return result; }
};

class StyleOpacity {
private:
    AzStyleOpacity inner_;

public:
    StyleOpacity(AzStyleOpacity inner) noexcept : inner_(inner) {}
    StyleOpacity(const StyleOpacity& other) noexcept : inner_(other.inner_) {}
    StyleOpacity& operator=(const StyleOpacity& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleOpacity() {}

    [[nodiscard]] static StyleOpacity default_();

    bool partialEq(const StyleOpacity& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleOpacity& b) const;
    uint8_t cmp(const StyleOpacity& b) const;

    const AzStyleOpacity& inner() const { return inner_; }
    AzStyleOpacity& inner() { return inner_; }
    const AzStyleOpacity* ptr() const { return &inner_; }
    AzStyleOpacity* ptr() { return &inner_; }
    AzStyleOpacity release() { AzStyleOpacity result = inner_; inner_ = {}; return result; }
    operator AzStyleOpacity() && noexcept { AzStyleOpacity result = inner_; inner_ = {}; return result; }
};

class StyleTransformOrigin {
private:
    AzStyleTransformOrigin inner_;

public:
    StyleTransformOrigin(AzStyleTransformOrigin inner) noexcept : inner_(inner) {}
    StyleTransformOrigin(const StyleTransformOrigin& other) noexcept : inner_(other.inner_) {}
    StyleTransformOrigin& operator=(const StyleTransformOrigin& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleTransformOrigin() {}

    [[nodiscard]] static StyleTransformOrigin default_();

    bool partialEq(const StyleTransformOrigin& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleTransformOrigin& b) const;
    uint8_t cmp(const StyleTransformOrigin& b) const;
    String toDbgString() const;

    const AzStyleTransformOrigin& inner() const { return inner_; }
    AzStyleTransformOrigin& inner() { return inner_; }
    const AzStyleTransformOrigin* ptr() const { return &inner_; }
    AzStyleTransformOrigin* ptr() { return &inner_; }
    AzStyleTransformOrigin release() { AzStyleTransformOrigin result = inner_; inner_ = {}; return result; }
    operator AzStyleTransformOrigin() && noexcept { AzStyleTransformOrigin result = inner_; inner_ = {}; return result; }
};

class StyleTransformTranslate2D {
private:
    AzStyleTransformTranslate2D inner_;

public:
    StyleTransformTranslate2D(AzStyleTransformTranslate2D inner) noexcept : inner_(inner) {}
    StyleTransformTranslate2D(const StyleTransformTranslate2D& other) noexcept : inner_(other.inner_) {}
    StyleTransformTranslate2D& operator=(const StyleTransformTranslate2D& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleTransformTranslate2D() {}

    bool partialEq(const StyleTransformTranslate2D& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleTransformTranslate2D& b) const;
    uint8_t cmp(const StyleTransformTranslate2D& b) const;
    String toDbgString() const;

    const AzStyleTransformTranslate2D& inner() const { return inner_; }
    AzStyleTransformTranslate2D& inner() { return inner_; }
    const AzStyleTransformTranslate2D* ptr() const { return &inner_; }
    AzStyleTransformTranslate2D* ptr() { return &inner_; }
    AzStyleTransformTranslate2D release() { AzStyleTransformTranslate2D result = inner_; inner_ = {}; return result; }
    operator AzStyleTransformTranslate2D() && noexcept { AzStyleTransformTranslate2D result = inner_; inner_ = {}; return result; }
};

class StyleTransformTranslate3D {
private:
    AzStyleTransformTranslate3D inner_;

public:
    StyleTransformTranslate3D(AzStyleTransformTranslate3D inner) noexcept : inner_(inner) {}
    StyleTransformTranslate3D(const StyleTransformTranslate3D& other) noexcept : inner_(other.inner_) {}
    StyleTransformTranslate3D& operator=(const StyleTransformTranslate3D& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleTransformTranslate3D() {}

    bool partialEq(const StyleTransformTranslate3D& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleTransformTranslate3D& b) const;
    uint8_t cmp(const StyleTransformTranslate3D& b) const;
    String toDbgString() const;

    const AzStyleTransformTranslate3D& inner() const { return inner_; }
    AzStyleTransformTranslate3D& inner() { return inner_; }
    const AzStyleTransformTranslate3D* ptr() const { return &inner_; }
    AzStyleTransformTranslate3D* ptr() { return &inner_; }
    AzStyleTransformTranslate3D release() { AzStyleTransformTranslate3D result = inner_; inner_ = {}; return result; }
    operator AzStyleTransformTranslate3D() && noexcept { AzStyleTransformTranslate3D result = inner_; inner_ = {}; return result; }
};

class StyleTransformRotate3D {
private:
    AzStyleTransformRotate3D inner_;

public:
    StyleTransformRotate3D(AzStyleTransformRotate3D inner) noexcept : inner_(inner) {}
    StyleTransformRotate3D(const StyleTransformRotate3D& other) noexcept : inner_(other.inner_) {}
    StyleTransformRotate3D& operator=(const StyleTransformRotate3D& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleTransformRotate3D() {}

    bool partialEq(const StyleTransformRotate3D& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleTransformRotate3D& b) const;
    uint8_t cmp(const StyleTransformRotate3D& b) const;
    String toDbgString() const;

    const AzStyleTransformRotate3D& inner() const { return inner_; }
    AzStyleTransformRotate3D& inner() { return inner_; }
    const AzStyleTransformRotate3D* ptr() const { return &inner_; }
    AzStyleTransformRotate3D* ptr() { return &inner_; }
    AzStyleTransformRotate3D release() { AzStyleTransformRotate3D result = inner_; inner_ = {}; return result; }
    operator AzStyleTransformRotate3D() && noexcept { AzStyleTransformRotate3D result = inner_; inner_ = {}; return result; }
};

class StyleTransformSkew2D {
private:
    AzStyleTransformSkew2D inner_;

public:
    StyleTransformSkew2D(AzStyleTransformSkew2D inner) noexcept : inner_(inner) {}
    StyleTransformSkew2D(const StyleTransformSkew2D& other) noexcept : inner_(other.inner_) {}
    StyleTransformSkew2D& operator=(const StyleTransformSkew2D& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleTransformSkew2D() {}

    bool partialEq(const StyleTransformSkew2D& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleTransformSkew2D& b) const;
    uint8_t cmp(const StyleTransformSkew2D& b) const;
    String toDbgString() const;

    const AzStyleTransformSkew2D& inner() const { return inner_; }
    AzStyleTransformSkew2D& inner() { return inner_; }
    const AzStyleTransformSkew2D* ptr() const { return &inner_; }
    AzStyleTransformSkew2D* ptr() { return &inner_; }
    AzStyleTransformSkew2D release() { AzStyleTransformSkew2D result = inner_; inner_ = {}; return result; }
    operator AzStyleTransformSkew2D() && noexcept { AzStyleTransformSkew2D result = inner_; inner_ = {}; return result; }
};

class StyleWordSpacing {
private:
    AzStyleWordSpacing inner_;

public:
    StyleWordSpacing(AzStyleWordSpacing inner) noexcept : inner_(inner) {}
    StyleWordSpacing(const StyleWordSpacing& other) noexcept : inner_(other.inner_) {}
    StyleWordSpacing& operator=(const StyleWordSpacing& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleWordSpacing() {}

    [[nodiscard]] static StyleWordSpacing default_();

    bool partialEq(const StyleWordSpacing& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleWordSpacing& b) const;
    uint8_t cmp(const StyleWordSpacing& b) const;
    String toDbgString() const;

    const AzStyleWordSpacing& inner() const { return inner_; }
    AzStyleWordSpacing& inner() { return inner_; }
    const AzStyleWordSpacing* ptr() const { return &inner_; }
    AzStyleWordSpacing* ptr() { return &inner_; }
    AzStyleWordSpacing release() { AzStyleWordSpacing result = inner_; inner_ = {}; return result; }
    operator AzStyleWordSpacing() && noexcept { AzStyleWordSpacing result = inner_; inner_ = {}; return result; }
};

class StylePerspectiveOrigin {
private:
    AzStylePerspectiveOrigin inner_;

public:
    StylePerspectiveOrigin(AzStylePerspectiveOrigin inner) noexcept : inner_(inner) {}
    StylePerspectiveOrigin(const StylePerspectiveOrigin& other) noexcept : inner_(other.inner_) {}
    StylePerspectiveOrigin& operator=(const StylePerspectiveOrigin& other) noexcept { inner_ = other.inner_; return *this; }
    ~StylePerspectiveOrigin() {}

    [[nodiscard]] static StylePerspectiveOrigin default_();

    bool partialEq(const StylePerspectiveOrigin& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StylePerspectiveOrigin& b) const;
    uint8_t cmp(const StylePerspectiveOrigin& b) const;
    String toDbgString() const;

    const AzStylePerspectiveOrigin& inner() const { return inner_; }
    AzStylePerspectiveOrigin& inner() { return inner_; }
    const AzStylePerspectiveOrigin* ptr() const { return &inner_; }
    AzStylePerspectiveOrigin* ptr() { return &inner_; }
    AzStylePerspectiveOrigin release() { AzStylePerspectiveOrigin result = inner_; inner_ = {}; return result; }
    operator AzStylePerspectiveOrigin() && noexcept { AzStylePerspectiveOrigin result = inner_; inner_ = {}; return result; }
};

class LayoutGap {
private:
    AzLayoutGap inner_;

public:
    LayoutGap(AzLayoutGap inner) noexcept : inner_(inner) {}
    LayoutGap(const LayoutGap& other) noexcept : inner_(other.inner_) {}
    LayoutGap& operator=(const LayoutGap& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutGap() {}

    [[nodiscard]] static LayoutGap default_();

    bool partialEq(const LayoutGap& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutGap& b) const;
    uint8_t cmp(const LayoutGap& b) const;
    String toDbgString() const;

    const AzLayoutGap& inner() const { return inner_; }
    AzLayoutGap& inner() { return inner_; }
    const AzLayoutGap* ptr() const { return &inner_; }
    AzLayoutGap* ptr() { return &inner_; }
    AzLayoutGap release() { AzLayoutGap result = inner_; inner_ = {}; return result; }
    operator AzLayoutGap() && noexcept { AzLayoutGap result = inner_; inner_ = {}; return result; }
};

class ShapeMargin {
private:
    AzShapeMargin inner_;

public:
    ShapeMargin(AzShapeMargin inner) noexcept : inner_(inner) {}
    ShapeMargin(const ShapeMargin& other) noexcept : inner_(other.inner_) {}
    ShapeMargin& operator=(const ShapeMargin& other) noexcept { inner_ = other.inner_; return *this; }
    ~ShapeMargin() {}

    [[nodiscard]] static ShapeMargin default_();

    bool partialEq(const ShapeMargin& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ShapeMargin& b) const;
    uint8_t cmp(const ShapeMargin& b) const;
    String toDbgString() const;

    const AzShapeMargin& inner() const { return inner_; }
    AzShapeMargin& inner() { return inner_; }
    const AzShapeMargin* ptr() const { return &inner_; }
    AzShapeMargin* ptr() { return &inner_; }
    AzShapeMargin release() { AzShapeMargin result = inner_; inner_ = {}; return result; }
    operator AzShapeMargin() && noexcept { AzShapeMargin result = inner_; inner_ = {}; return result; }
};

class ColumnRuleWidth {
private:
    AzColumnRuleWidth inner_;

public:
    ColumnRuleWidth(AzColumnRuleWidth inner) noexcept : inner_(inner) {}
    ColumnRuleWidth(const ColumnRuleWidth& other) noexcept : inner_(other.inner_) {}
    ColumnRuleWidth& operator=(const ColumnRuleWidth& other) noexcept { inner_ = other.inner_; return *this; }
    ~ColumnRuleWidth() {}

    [[nodiscard]] static ColumnRuleWidth default_();

    bool partialEq(const ColumnRuleWidth& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ColumnRuleWidth& b) const;
    uint8_t cmp(const ColumnRuleWidth& b) const;
    String toDbgString() const;

    const AzColumnRuleWidth& inner() const { return inner_; }
    AzColumnRuleWidth& inner() { return inner_; }
    const AzColumnRuleWidth* ptr() const { return &inner_; }
    AzColumnRuleWidth* ptr() { return &inner_; }
    AzColumnRuleWidth release() { AzColumnRuleWidth result = inner_; inner_ = {}; return result; }
    operator AzColumnRuleWidth() && noexcept { AzColumnRuleWidth result = inner_; inner_ = {}; return result; }
};

class StyleTextIndent {
private:
    AzStyleTextIndent inner_;

public:
    StyleTextIndent(AzStyleTextIndent inner) noexcept : inner_(inner) {}
    StyleTextIndent(const StyleTextIndent& other) noexcept : inner_(other.inner_) {}
    StyleTextIndent& operator=(const StyleTextIndent& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleTextIndent() {}

    [[nodiscard]] static StyleTextIndent default_();

    bool partialEq(const StyleTextIndent& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleTextIndent& b) const;
    uint8_t cmp(const StyleTextIndent& b) const;
    String toDbgString() const;

    const AzStyleTextIndent& inner() const { return inner_; }
    AzStyleTextIndent& inner() { return inner_; }
    const AzStyleTextIndent* ptr() const { return &inner_; }
    AzStyleTextIndent* ptr() { return &inner_; }
    AzStyleTextIndent release() { AzStyleTextIndent result = inner_; inner_ = {}; return result; }
    operator AzStyleTextIndent() && noexcept { AzStyleTextIndent result = inner_; inner_ = {}; return result; }
};

class LayoutBorderSpacing {
private:
    AzLayoutBorderSpacing inner_;

public:
    LayoutBorderSpacing(AzLayoutBorderSpacing inner) noexcept : inner_(inner) {}
    LayoutBorderSpacing(const LayoutBorderSpacing& other) noexcept : inner_(other.inner_) {}
    LayoutBorderSpacing& operator=(const LayoutBorderSpacing& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutBorderSpacing() {}

    [[nodiscard]] static LayoutBorderSpacing default_();

    bool partialEq(const LayoutBorderSpacing& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutBorderSpacing& b) const;
    uint8_t cmp(const LayoutBorderSpacing& b) const;
    String toDbgString() const;

    const AzLayoutBorderSpacing& inner() const { return inner_; }
    AzLayoutBorderSpacing& inner() { return inner_; }
    const AzLayoutBorderSpacing* ptr() const { return &inner_; }
    AzLayoutBorderSpacing* ptr() { return &inner_; }
    AzLayoutBorderSpacing release() { AzLayoutBorderSpacing result = inner_; inner_ = {}; return result; }
    operator AzLayoutBorderSpacing() && noexcept { AzLayoutBorderSpacing result = inner_; inner_ = {}; return result; }
};

class LayoutPaddingInlineStart {
private:
    AzLayoutPaddingInlineStart inner_;

public:
    LayoutPaddingInlineStart(AzLayoutPaddingInlineStart inner) noexcept : inner_(inner) {}
    LayoutPaddingInlineStart(const LayoutPaddingInlineStart& other) noexcept : inner_(other.inner_) {}
    LayoutPaddingInlineStart& operator=(const LayoutPaddingInlineStart& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutPaddingInlineStart() {}

    [[nodiscard]] static LayoutPaddingInlineStart default_();

    bool partialEq(const LayoutPaddingInlineStart& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutPaddingInlineStart& b) const;
    uint8_t cmp(const LayoutPaddingInlineStart& b) const;
    String toDbgString() const;

    const AzLayoutPaddingInlineStart& inner() const { return inner_; }
    AzLayoutPaddingInlineStart& inner() { return inner_; }
    const AzLayoutPaddingInlineStart* ptr() const { return &inner_; }
    AzLayoutPaddingInlineStart* ptr() { return &inner_; }
    AzLayoutPaddingInlineStart release() { AzLayoutPaddingInlineStart result = inner_; inner_ = {}; return result; }
    operator AzLayoutPaddingInlineStart() && noexcept { AzLayoutPaddingInlineStart result = inner_; inner_ = {}; return result; }
};

class LayoutColumnGap {
private:
    AzLayoutColumnGap inner_;

public:
    LayoutColumnGap(AzLayoutColumnGap inner) noexcept : inner_(inner) {}
    LayoutColumnGap(const LayoutColumnGap& other) noexcept : inner_(other.inner_) {}
    LayoutColumnGap& operator=(const LayoutColumnGap& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutColumnGap() {}

    [[nodiscard]] static LayoutColumnGap default_();

    bool partialEq(const LayoutColumnGap& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutColumnGap& b) const;
    uint8_t cmp(const LayoutColumnGap& b) const;
    String toDbgString() const;

    const AzLayoutColumnGap& inner() const { return inner_; }
    AzLayoutColumnGap& inner() { return inner_; }
    const AzLayoutColumnGap* ptr() const { return &inner_; }
    AzLayoutColumnGap* ptr() { return &inner_; }
    AzLayoutColumnGap release() { AzLayoutColumnGap result = inner_; inner_ = {}; return result; }
    operator AzLayoutColumnGap() && noexcept { AzLayoutColumnGap result = inner_; inner_ = {}; return result; }
};

class LayoutPaddingInlineEnd {
private:
    AzLayoutPaddingInlineEnd inner_;

public:
    LayoutPaddingInlineEnd(AzLayoutPaddingInlineEnd inner) noexcept : inner_(inner) {}
    LayoutPaddingInlineEnd(const LayoutPaddingInlineEnd& other) noexcept : inner_(other.inner_) {}
    LayoutPaddingInlineEnd& operator=(const LayoutPaddingInlineEnd& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutPaddingInlineEnd() {}

    [[nodiscard]] static LayoutPaddingInlineEnd default_();

    bool partialEq(const LayoutPaddingInlineEnd& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutPaddingInlineEnd& b) const;
    uint8_t cmp(const LayoutPaddingInlineEnd& b) const;
    String toDbgString() const;

    const AzLayoutPaddingInlineEnd& inner() const { return inner_; }
    AzLayoutPaddingInlineEnd& inner() { return inner_; }
    const AzLayoutPaddingInlineEnd* ptr() const { return &inner_; }
    AzLayoutPaddingInlineEnd* ptr() { return &inner_; }
    AzLayoutPaddingInlineEnd release() { AzLayoutPaddingInlineEnd result = inner_; inner_ = {}; return result; }
    operator AzLayoutPaddingInlineEnd() && noexcept { AzLayoutPaddingInlineEnd result = inner_; inner_ = {}; return result; }
};

class LayoutRowGap {
private:
    AzLayoutRowGap inner_;

public:
    LayoutRowGap(AzLayoutRowGap inner) noexcept : inner_(inner) {}
    LayoutRowGap(const LayoutRowGap& other) noexcept : inner_(other.inner_) {}
    LayoutRowGap& operator=(const LayoutRowGap& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutRowGap() {}

    [[nodiscard]] static LayoutRowGap default_();

    bool partialEq(const LayoutRowGap& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutRowGap& b) const;
    uint8_t cmp(const LayoutRowGap& b) const;
    String toDbgString() const;

    const AzLayoutRowGap& inner() const { return inner_; }
    AzLayoutRowGap& inner() { return inner_; }
    const AzLayoutRowGap* ptr() const { return &inner_; }
    AzLayoutRowGap* ptr() { return &inner_; }
    AzLayoutRowGap release() { AzLayoutRowGap result = inner_; inner_ = {}; return result; }
    operator AzLayoutRowGap() && noexcept { AzLayoutRowGap result = inner_; inner_ = {}; return result; }
};

class LayoutInsetBottom {
private:
    AzLayoutInsetBottom inner_;

public:
    LayoutInsetBottom(AzLayoutInsetBottom inner) noexcept : inner_(inner) {}
    LayoutInsetBottom(const LayoutInsetBottom& other) noexcept : inner_(other.inner_) {}
    LayoutInsetBottom& operator=(const LayoutInsetBottom& other) noexcept { inner_ = other.inner_; return *this; }
    ~LayoutInsetBottom() {}

    [[nodiscard]] static LayoutInsetBottom default_();

    bool partialEq(const LayoutInsetBottom& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutInsetBottom& b) const;
    uint8_t cmp(const LayoutInsetBottom& b) const;

    const AzLayoutInsetBottom& inner() const { return inner_; }
    AzLayoutInsetBottom& inner() { return inner_; }
    const AzLayoutInsetBottom* ptr() const { return &inner_; }
    AzLayoutInsetBottom* ptr() { return &inner_; }
    AzLayoutInsetBottom release() { AzLayoutInsetBottom result = inner_; inner_ = {}; return result; }
    operator AzLayoutInsetBottom() && noexcept { AzLayoutInsetBottom result = inner_; inner_ = {}; return result; }
};

class SystemColors {
private:
    AzSystemColors inner_;

    SystemColors(const SystemColors&) = delete;
    SystemColors& operator=(const SystemColors&) = delete;

public:
    explicit SystemColors(AzSystemColors inner) noexcept : inner_(inner) {}

    SystemColors(SystemColors&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SystemColors& operator=(SystemColors&& other) noexcept {
        if (this != &other) {
            AzSystemColors_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SystemColors() { AzSystemColors_delete(&inner_); }

    [[nodiscard]] static SystemColors default_();

    void delete_();
    SystemColors clone() const;
    bool partialEq(const SystemColors& b) const;
    String toDbgString() const;

    const AzSystemColors& inner() const { return inner_; }
    AzSystemColors& inner() { return inner_; }
    const AzSystemColors* ptr() const { return &inner_; }
    AzSystemColors* ptr() { return &inner_; }
    AzSystemColors release() { AzSystemColors result = inner_; inner_ = {}; return result; }
    operator AzSystemColors() && noexcept { AzSystemColors result = inner_; inner_ = {}; return result; }
};

class CaretWidth {
private:
    AzCaretWidth inner_;

public:
    CaretWidth(AzCaretWidth inner) noexcept : inner_(inner) {}
    CaretWidth(const CaretWidth& other) noexcept : inner_(other.inner_) {}
    CaretWidth& operator=(const CaretWidth& other) noexcept { inner_ = other.inner_; return *this; }
    ~CaretWidth() {}

    [[nodiscard]] static CaretWidth default_();

    bool partialEq(const CaretWidth& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CaretWidth& b) const;
    uint8_t cmp(const CaretWidth& b) const;
    String toDbgString() const;

    const AzCaretWidth& inner() const { return inner_; }
    AzCaretWidth& inner() { return inner_; }
    const AzCaretWidth* ptr() const { return &inner_; }
    AzCaretWidth* ptr() { return &inner_; }
    AzCaretWidth release() { AzCaretWidth result = inner_; inner_ = {}; return result; }
    operator AzCaretWidth() && noexcept { AzCaretWidth result = inner_; inner_ = {}; return result; }
};

class StyleTabSize {
private:
    AzStyleTabSize inner_;

public:
    StyleTabSize(AzStyleTabSize inner) noexcept : inner_(inner) {}
    StyleTabSize(const StyleTabSize& other) noexcept : inner_(other.inner_) {}
    StyleTabSize& operator=(const StyleTabSize& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleTabSize() {}

    [[nodiscard]] static StyleTabSize default_();

    bool partialEq(const StyleTabSize& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleTabSize& b) const;
    uint8_t cmp(const StyleTabSize& b) const;
    String toDbgString() const;

    const AzStyleTabSize& inner() const { return inner_; }
    AzStyleTabSize& inner() { return inner_; }
    const AzStyleTabSize* ptr() const { return &inner_; }
    AzStyleTabSize* ptr() { return &inner_; }
    AzStyleTabSize release() { AzStyleTabSize result = inner_; inner_ = {}; return result; }
    operator AzStyleTabSize() && noexcept { AzStyleTabSize result = inner_; inner_ = {}; return result; }
};

class StyleOverflowClipMargin {
private:
    AzStyleOverflowClipMargin inner_;

public:
    StyleOverflowClipMargin(AzStyleOverflowClipMargin inner) noexcept : inner_(inner) {}
    StyleOverflowClipMargin(const StyleOverflowClipMargin& other) noexcept : inner_(other.inner_) {}
    StyleOverflowClipMargin& operator=(const StyleOverflowClipMargin& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleOverflowClipMargin() {}

    [[nodiscard]] static StyleOverflowClipMargin default_();

    bool partialEq(const StyleOverflowClipMargin& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleOverflowClipMargin& b) const;
    uint8_t cmp(const StyleOverflowClipMargin& b) const;
    String toDbgString() const;

    const AzStyleOverflowClipMargin& inner() const { return inner_; }
    AzStyleOverflowClipMargin& inner() { return inner_; }
    const AzStyleOverflowClipMargin* ptr() const { return &inner_; }
    AzStyleOverflowClipMargin* ptr() { return &inner_; }
    AzStyleOverflowClipMargin release() { AzStyleOverflowClipMargin result = inner_; inner_ = {}; return result; }
    operator AzStyleOverflowClipMargin() && noexcept { AzStyleOverflowClipMargin result = inner_; inner_ = {}; return result; }
};

class Texture {
private:
    AzTexture inner_;

    Texture(const Texture&) = delete;
    Texture& operator=(const Texture&) = delete;

public:
    explicit Texture(AzTexture inner) noexcept : inner_(inner) {}

    Texture(Texture&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Texture& operator=(Texture&& other) noexcept {
        if (this != &other) {
            AzTexture_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Texture() { AzTexture_delete(&inner_); }

    [[nodiscard]] static Texture create(AzGLuint texture_id, TextureFlags flags, AzPhysicalSizeU32 size, ColorU background_color, GlContextPtr gl_context, AzRawImageFormat format);
    [[nodiscard]] static Texture allocate_rgba8(GlContextPtr gl_context, AzPhysicalSizeU32 size, ColorU background);
    [[nodiscard]] static Texture allocate_clip_mask(GlContextPtr gl, AzPhysicalSizeU32 size, ColorU background);

    void clear();
    bool apply_fxaa();
    bool draw_tesselated_svg_gpu_node(TessellatedGPUSvgNode node, AzPhysicalSizeU32 size, ColorU color, StyleTransformVec transforms);
    ImageDescriptor get_descriptor() const;
    bool draw_tesselated_colored_svg_gpu_node(TessellatedColoredGPUSvgNode node, AzPhysicalSizeU32 size, StyleTransformVec transforms);
    void delete_();
    Texture clone() const;

    const AzTexture& inner() const { return inner_; }
    AzTexture& inner() { return inner_; }
    const AzTexture* ptr() const { return &inner_; }
    AzTexture* ptr() { return &inner_; }
    AzTexture release() { AzTexture result = inner_; inner_ = {}; return result; }
    operator AzTexture() && noexcept { AzTexture result = inner_; inner_ = {}; return result; }
};

class ImageMask {
private:
    AzImageMask inner_;

    ImageMask(const ImageMask&) = delete;
    ImageMask& operator=(const ImageMask&) = delete;

public:
    explicit ImageMask(AzImageMask inner) noexcept : inner_(inner) {}

    ImageMask(ImageMask&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ImageMask& operator=(ImageMask&& other) noexcept {
        if (this != &other) {
            AzImageMask_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ImageMask() { AzImageMask_delete(&inner_); }

    void delete_();
    ImageMask clone() const;
    bool partialEq(const ImageMask& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ImageMask& b) const;
    uint8_t cmp(const ImageMask& b) const;
    String toDbgString() const;

    const AzImageMask& inner() const { return inner_; }
    AzImageMask& inner() { return inner_; }
    const AzImageMask* ptr() const { return &inner_; }
    AzImageMask* ptr() { return &inner_; }
    AzImageMask release() { AzImageMask result = inner_; inner_ = {}; return result; }
    operator AzImageMask() && noexcept { AzImageMask result = inner_; inner_ = {}; return result; }
};

class SvgStrokeStyle {
private:
    AzSvgStrokeStyle inner_;

public:
    SvgStrokeStyle(AzSvgStrokeStyle inner) noexcept : inner_(inner) {}
    SvgStrokeStyle(const SvgStrokeStyle& other) noexcept : inner_(other.inner_) {}
    SvgStrokeStyle& operator=(const SvgStrokeStyle& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgStrokeStyle() {}

    [[nodiscard]] static SvgStrokeStyle default_();

    bool partialEq(const SvgStrokeStyle& b) const;
    uint8_t partialCmp(const SvgStrokeStyle& b) const;
    String toDbgString() const;

    const AzSvgStrokeStyle& inner() const { return inner_; }
    AzSvgStrokeStyle& inner() { return inner_; }
    const AzSvgStrokeStyle* ptr() const { return &inner_; }
    AzSvgStrokeStyle* ptr() { return &inner_; }
    AzSvgStrokeStyle release() { AzSvgStrokeStyle result = inner_; inner_ = {}; return result; }
    operator AzSvgStrokeStyle() && noexcept { AzSvgStrokeStyle result = inner_; inner_ = {}; return result; }
};

class InstantPtr {
private:
    AzInstantPtr inner_;

    InstantPtr(const InstantPtr&) = delete;
    InstantPtr& operator=(const InstantPtr&) = delete;

public:
    explicit InstantPtr(AzInstantPtr inner) noexcept : inner_(inner) {}

    InstantPtr(InstantPtr&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    InstantPtr& operator=(InstantPtr&& other) noexcept {
        if (this != &other) {
            AzInstantPtr_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~InstantPtr() { AzInstantPtr_delete(&inner_); }

    void delete_();
    InstantPtr clone() const;
    bool partialEq(const InstantPtr& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const InstantPtr& b) const;
    uint8_t cmp(const InstantPtr& b) const;
    String toDbgString() const;

    const AzInstantPtr& inner() const { return inner_; }
    AzInstantPtr& inner() { return inner_; }
    const AzInstantPtr* ptr() const { return &inner_; }
    AzInstantPtr* ptr() { return &inner_; }
    AzInstantPtr release() { AzInstantPtr result = inner_; inner_ = {}; return result; }
    operator AzInstantPtr() && noexcept { AzInstantPtr result = inner_; inner_ = {}; return result; }
};

class ListViewRowVec {
private:
    AzListViewRowVec inner_;

    ListViewRowVec(const ListViewRowVec&) = delete;
    ListViewRowVec& operator=(const ListViewRowVec&) = delete;

public:
    explicit ListViewRowVec(AzListViewRowVec inner) noexcept : inner_(inner) {}

    ListViewRowVec(ListViewRowVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ListViewRowVec& operator=(ListViewRowVec&& other) noexcept {
        if (this != &other) {
            AzListViewRowVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ListViewRowVec() { AzListViewRowVec_delete(&inner_); }

    static ListViewRowVec create();
    static ListViewRowVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionListViewRow get(size_t index) const;
    static ListViewRowVec from_item(ListViewRow item);
    static ListViewRowVec copy_from_ptr(const ListViewRow& ptr, size_t len);
    OptionListViewRow c_get(size_t index) const;
    ListViewRowVecSlice as_c_slice() const;
    ListViewRowVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ListViewRowVec clone() const;
    String toDbgString() const;

    const AzListViewRowVec& inner() const { return inner_; }
    AzListViewRowVec& inner() { return inner_; }
    const AzListViewRowVec* ptr() const { return &inner_; }
    AzListViewRowVec* ptr() { return &inner_; }
    AzListViewRowVec release() { AzListViewRowVec result = inner_; inner_ = {}; return result; }
    operator AzListViewRowVec() && noexcept { AzListViewRowVec result = inner_; inner_ = {}; return result; }
};

class StyleFilterVec {
private:
    AzStyleFilterVec inner_;

    StyleFilterVec(const StyleFilterVec&) = delete;
    StyleFilterVec& operator=(const StyleFilterVec&) = delete;

public:
    explicit StyleFilterVec(AzStyleFilterVec inner) noexcept : inner_(inner) {}

    StyleFilterVec(StyleFilterVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyleFilterVec& operator=(StyleFilterVec&& other) noexcept {
        if (this != &other) {
            AzStyleFilterVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyleFilterVec() { AzStyleFilterVec_delete(&inner_); }

    static StyleFilterVec create();
    static StyleFilterVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionStyleFilter get(size_t index) const;
    static StyleFilterVec from_item(AzStyleFilter item);
    static StyleFilterVec copy_from_ptr(const AzStyleFilter* ptr, size_t len);
    OptionStyleFilter c_get(size_t index) const;
    StyleFilterVecSlice as_c_slice() const;
    StyleFilterVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    StyleFilterVec clone() const;
    bool partialEq(const StyleFilterVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleFilterVec& b) const;
    uint8_t cmp(const StyleFilterVec& b) const;
    String toDbgString() const;

    const AzStyleFilterVec& inner() const { return inner_; }
    AzStyleFilterVec& inner() { return inner_; }
    const AzStyleFilterVec* ptr() const { return &inner_; }
    AzStyleFilterVec* ptr() { return &inner_; }
    AzStyleFilterVec release() { AzStyleFilterVec result = inner_; inner_ = {}; return result; }
    operator AzStyleFilterVec() && noexcept { AzStyleFilterVec result = inner_; inner_ = {}; return result; }
};

class AccessibilityStateVec {
private:
    AzAccessibilityStateVec inner_;

    AccessibilityStateVec(const AccessibilityStateVec&) = delete;
    AccessibilityStateVec& operator=(const AccessibilityStateVec&) = delete;

public:
    explicit AccessibilityStateVec(AzAccessibilityStateVec inner) noexcept : inner_(inner) {}

    AccessibilityStateVec(AccessibilityStateVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    AccessibilityStateVec& operator=(AccessibilityStateVec&& other) noexcept {
        if (this != &other) {
            AzAccessibilityStateVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~AccessibilityStateVec() { AzAccessibilityStateVec_delete(&inner_); }

    static AccessibilityStateVec create();
    static AccessibilityStateVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionAccessibilityState get(size_t index) const;
    static AccessibilityStateVec from_item(AzAccessibilityState item);
    static AccessibilityStateVec copy_from_ptr(const AzAccessibilityState* ptr, size_t len);
    OptionAccessibilityState c_get(size_t index) const;
    AccessibilityStateVecSlice as_c_slice() const;
    AccessibilityStateVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    AccessibilityStateVec clone() const;
    bool partialEq(const AccessibilityStateVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const AccessibilityStateVec& b) const;
    uint8_t cmp(const AccessibilityStateVec& b) const;
    String toDbgString() const;

    const AzAccessibilityStateVec& inner() const { return inner_; }
    AzAccessibilityStateVec& inner() { return inner_; }
    const AzAccessibilityStateVec* ptr() const { return &inner_; }
    AzAccessibilityStateVec* ptr() { return &inner_; }
    AzAccessibilityStateVec release() { AzAccessibilityStateVec result = inner_; inner_ = {}; return result; }
    operator AzAccessibilityStateVec() && noexcept { AzAccessibilityStateVec result = inner_; inner_ = {}; return result; }
};

class MenuItemVec {
private:
    AzMenuItemVec inner_;

    MenuItemVec(const MenuItemVec&) = delete;
    MenuItemVec& operator=(const MenuItemVec&) = delete;

public:
    explicit MenuItemVec(AzMenuItemVec inner) noexcept : inner_(inner) {}

    MenuItemVec(MenuItemVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MenuItemVec& operator=(MenuItemVec&& other) noexcept {
        if (this != &other) {
            AzMenuItemVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MenuItemVec() { AzMenuItemVec_delete(&inner_); }

    static MenuItemVec create();
    static MenuItemVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionMenuItem get(size_t index) const;
    static MenuItemVec from_item(AzMenuItem item);
    static MenuItemVec copy_from_ptr(const AzMenuItem* ptr, size_t len);
    OptionMenuItem c_get(size_t index) const;
    MenuItemVecSlice as_c_slice() const;
    MenuItemVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    MenuItemVec clone() const;
    bool partialEq(const MenuItemVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const MenuItemVec& b) const;
    uint8_t cmp(const MenuItemVec& b) const;
    String toDbgString() const;

    const AzMenuItemVec& inner() const { return inner_; }
    AzMenuItemVec& inner() { return inner_; }
    const AzMenuItemVec* ptr() const { return &inner_; }
    AzMenuItemVec* ptr() { return &inner_; }
    AzMenuItemVec release() { AzMenuItemVec result = inner_; inner_ = {}; return result; }
    operator AzMenuItemVec() && noexcept { AzMenuItemVec result = inner_; inner_ = {}; return result; }
};

class StyleFontFamilyVec {
private:
    AzStyleFontFamilyVec inner_;

    StyleFontFamilyVec(const StyleFontFamilyVec&) = delete;
    StyleFontFamilyVec& operator=(const StyleFontFamilyVec&) = delete;

public:
    explicit StyleFontFamilyVec(AzStyleFontFamilyVec inner) noexcept : inner_(inner) {}

    StyleFontFamilyVec(StyleFontFamilyVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyleFontFamilyVec& operator=(StyleFontFamilyVec&& other) noexcept {
        if (this != &other) {
            AzStyleFontFamilyVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyleFontFamilyVec() { AzStyleFontFamilyVec_delete(&inner_); }

    static StyleFontFamilyVec create();
    static StyleFontFamilyVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionStyleFontFamily get(size_t index) const;
    static StyleFontFamilyVec from_item(AzStyleFontFamily item);
    static StyleFontFamilyVec copy_from_ptr(const AzStyleFontFamily* ptr, size_t len);
    OptionStyleFontFamily c_get(size_t index) const;
    StyleFontFamilyVecSlice as_c_slice() const;
    StyleFontFamilyVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    StyleFontFamilyVec clone() const;
    bool partialEq(const StyleFontFamilyVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleFontFamilyVec& b) const;
    uint8_t cmp(const StyleFontFamilyVec& b) const;
    String toDbgString() const;

    const AzStyleFontFamilyVec& inner() const { return inner_; }
    AzStyleFontFamilyVec& inner() { return inner_; }
    const AzStyleFontFamilyVec* ptr() const { return &inner_; }
    AzStyleFontFamilyVec* ptr() { return &inner_; }
    AzStyleFontFamilyVec release() { AzStyleFontFamilyVec result = inner_; inner_ = {}; return result; }
    operator AzStyleFontFamilyVec() && noexcept { AzStyleFontFamilyVec result = inner_; inner_ = {}; return result; }
};

class DomVec {
private:
    AzDomVec inner_;

    DomVec(const DomVec&) = delete;
    DomVec& operator=(const DomVec&) = delete;

public:
    explicit DomVec(AzDomVec inner) noexcept : inner_(inner) {}

    DomVec(DomVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DomVec& operator=(DomVec&& other) noexcept {
        if (this != &other) {
            AzDomVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DomVec() { AzDomVec_delete(&inner_); }

    static DomVec create();
    static DomVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionDom get(size_t index) const;
    static DomVec from_item(Dom item);
    static DomVec copy_from_ptr(const Dom& ptr, size_t len);
    OptionDom c_get(size_t index) const;
    DomVecSlice as_c_slice() const;
    DomVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    DomVec clone() const;
    bool partialEq(const DomVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const DomVec& b) const;
    uint8_t cmp(const DomVec& b) const;
    String toDbgString() const;

    const AzDomVec& inner() const { return inner_; }
    AzDomVec& inner() { return inner_; }
    const AzDomVec* ptr() const { return &inner_; }
    AzDomVec* ptr() { return &inner_; }
    AzDomVec release() { AzDomVec result = inner_; inner_ = {}; return result; }
    operator AzDomVec() && noexcept { AzDomVec result = inner_; inner_ = {}; return result; }
};

class IdOrClassVec {
private:
    AzIdOrClassVec inner_;

    IdOrClassVec(const IdOrClassVec&) = delete;
    IdOrClassVec& operator=(const IdOrClassVec&) = delete;

public:
    explicit IdOrClassVec(AzIdOrClassVec inner) noexcept : inner_(inner) {}

    IdOrClassVec(IdOrClassVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    IdOrClassVec& operator=(IdOrClassVec&& other) noexcept {
        if (this != &other) {
            AzIdOrClassVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~IdOrClassVec() { AzIdOrClassVec_delete(&inner_); }

    static IdOrClassVec create();
    static IdOrClassVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionIdOrClass get(size_t index) const;
    static IdOrClassVec from_item(AzIdOrClass item);
    static IdOrClassVec copy_from_ptr(const AzIdOrClass* ptr, size_t len);
    OptionIdOrClass c_get(size_t index) const;
    IdOrClassVecSlice as_c_slice() const;
    IdOrClassVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    IdOrClassVec clone() const;
    bool partialEq(const IdOrClassVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const IdOrClassVec& b) const;
    uint8_t cmp(const IdOrClassVec& b) const;
    String toDbgString() const;

    const AzIdOrClassVec& inner() const { return inner_; }
    AzIdOrClassVec& inner() { return inner_; }
    const AzIdOrClassVec* ptr() const { return &inner_; }
    AzIdOrClassVec* ptr() { return &inner_; }
    AzIdOrClassVec release() { AzIdOrClassVec result = inner_; inner_ = {}; return result; }
    operator AzIdOrClassVec() && noexcept { AzIdOrClassVec result = inner_; inner_ = {}; return result; }
};

class DynamicSelectorVec {
private:
    AzDynamicSelectorVec inner_;

    DynamicSelectorVec(const DynamicSelectorVec&) = delete;
    DynamicSelectorVec& operator=(const DynamicSelectorVec&) = delete;

public:
    explicit DynamicSelectorVec(AzDynamicSelectorVec inner) noexcept : inner_(inner) {}

    DynamicSelectorVec(DynamicSelectorVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DynamicSelectorVec& operator=(DynamicSelectorVec&& other) noexcept {
        if (this != &other) {
            AzDynamicSelectorVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DynamicSelectorVec() { AzDynamicSelectorVec_delete(&inner_); }

    static DynamicSelectorVec create();
    static DynamicSelectorVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionDynamicSelector get(size_t index) const;
    static DynamicSelectorVec from_item(AzDynamicSelector item);
    static DynamicSelectorVec copy_from_ptr(const AzDynamicSelector* ptr, size_t len);
    OptionDynamicSelector c_get(size_t index) const;
    DynamicSelectorVecSlice as_c_slice() const;
    DynamicSelectorVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    DynamicSelectorVec clone() const;
    bool partialEq(const DynamicSelectorVec& b) const;
    String toDbgString() const;

    const AzDynamicSelectorVec& inner() const { return inner_; }
    AzDynamicSelectorVec& inner() { return inner_; }
    const AzDynamicSelectorVec* ptr() const { return &inner_; }
    AzDynamicSelectorVec* ptr() { return &inner_; }
    AzDynamicSelectorVec release() { AzDynamicSelectorVec result = inner_; inner_ = {}; return result; }
    operator AzDynamicSelectorVec() && noexcept { AzDynamicSelectorVec result = inner_; inner_ = {}; return result; }
};

class CssPropertyWithConditionsVec {
private:
    AzCssPropertyWithConditionsVec inner_;

    CssPropertyWithConditionsVec(const CssPropertyWithConditionsVec&) = delete;
    CssPropertyWithConditionsVec& operator=(const CssPropertyWithConditionsVec&) = delete;

public:
    explicit CssPropertyWithConditionsVec(AzCssPropertyWithConditionsVec inner) noexcept : inner_(inner) {}

    CssPropertyWithConditionsVec(CssPropertyWithConditionsVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssPropertyWithConditionsVec& operator=(CssPropertyWithConditionsVec&& other) noexcept {
        if (this != &other) {
            AzCssPropertyWithConditionsVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssPropertyWithConditionsVec() { AzCssPropertyWithConditionsVec_delete(&inner_); }

    static CssPropertyWithConditionsVec create();
    static CssPropertyWithConditionsVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionCssPropertyWithConditions get(size_t index) const;
    static CssPropertyWithConditionsVec from_item(CssPropertyWithConditions item);
    static CssPropertyWithConditionsVec copy_from_ptr(const CssPropertyWithConditions& ptr, size_t len);
    OptionCssPropertyWithConditions c_get(size_t index) const;
    CssPropertyWithConditionsVecSlice as_c_slice() const;
    CssPropertyWithConditionsVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    CssPropertyWithConditionsVec clone() const;
    bool partialEq(const CssPropertyWithConditionsVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CssPropertyWithConditionsVec& b) const;
    uint8_t cmp(const CssPropertyWithConditionsVec& b) const;
    String toDbgString() const;

    const AzCssPropertyWithConditionsVec& inner() const { return inner_; }
    AzCssPropertyWithConditionsVec& inner() { return inner_; }
    const AzCssPropertyWithConditionsVec* ptr() const { return &inner_; }
    AzCssPropertyWithConditionsVec* ptr() { return &inner_; }
    AzCssPropertyWithConditionsVec release() { AzCssPropertyWithConditionsVec result = inner_; inner_ = {}; return result; }
    operator AzCssPropertyWithConditionsVec() && noexcept { AzCssPropertyWithConditionsVec result = inner_; inner_ = {}; return result; }
};

class StyleBackgroundContentVec {
private:
    AzStyleBackgroundContentVec inner_;

    StyleBackgroundContentVec(const StyleBackgroundContentVec&) = delete;
    StyleBackgroundContentVec& operator=(const StyleBackgroundContentVec&) = delete;

public:
    explicit StyleBackgroundContentVec(AzStyleBackgroundContentVec inner) noexcept : inner_(inner) {}

    StyleBackgroundContentVec(StyleBackgroundContentVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyleBackgroundContentVec& operator=(StyleBackgroundContentVec&& other) noexcept {
        if (this != &other) {
            AzStyleBackgroundContentVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyleBackgroundContentVec() { AzStyleBackgroundContentVec_delete(&inner_); }

    static StyleBackgroundContentVec create();
    static StyleBackgroundContentVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionStyleBackgroundContent get(size_t index) const;
    static StyleBackgroundContentVec from_item(AzStyleBackgroundContent item);
    static StyleBackgroundContentVec copy_from_ptr(const AzStyleBackgroundContent* ptr, size_t len);
    OptionStyleBackgroundContent c_get(size_t index) const;
    StyleBackgroundContentVecSlice as_c_slice() const;
    StyleBackgroundContentVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    StyleBackgroundContentVec clone() const;
    bool partialEq(const StyleBackgroundContentVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBackgroundContentVec& b) const;
    uint8_t cmp(const StyleBackgroundContentVec& b) const;
    String toDbgString() const;

    const AzStyleBackgroundContentVec& inner() const { return inner_; }
    AzStyleBackgroundContentVec& inner() { return inner_; }
    const AzStyleBackgroundContentVec* ptr() const { return &inner_; }
    AzStyleBackgroundContentVec* ptr() { return &inner_; }
    AzStyleBackgroundContentVec release() { AzStyleBackgroundContentVec result = inner_; inner_ = {}; return result; }
    operator AzStyleBackgroundContentVec() && noexcept { AzStyleBackgroundContentVec result = inner_; inner_ = {}; return result; }
};

class StyleBackgroundPositionVec {
private:
    AzStyleBackgroundPositionVec inner_;

    StyleBackgroundPositionVec(const StyleBackgroundPositionVec&) = delete;
    StyleBackgroundPositionVec& operator=(const StyleBackgroundPositionVec&) = delete;

public:
    explicit StyleBackgroundPositionVec(AzStyleBackgroundPositionVec inner) noexcept : inner_(inner) {}

    StyleBackgroundPositionVec(StyleBackgroundPositionVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyleBackgroundPositionVec& operator=(StyleBackgroundPositionVec&& other) noexcept {
        if (this != &other) {
            AzStyleBackgroundPositionVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyleBackgroundPositionVec() { AzStyleBackgroundPositionVec_delete(&inner_); }

    static StyleBackgroundPositionVec create();
    static StyleBackgroundPositionVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionStyleBackgroundPosition get(size_t index) const;
    static StyleBackgroundPositionVec from_item(StyleBackgroundPosition item);
    static StyleBackgroundPositionVec copy_from_ptr(const StyleBackgroundPosition& ptr, size_t len);
    OptionStyleBackgroundPosition c_get(size_t index) const;
    StyleBackgroundPositionVecSlice as_c_slice() const;
    StyleBackgroundPositionVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    StyleBackgroundPositionVec clone() const;
    bool partialEq(const StyleBackgroundPositionVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBackgroundPositionVec& b) const;
    uint8_t cmp(const StyleBackgroundPositionVec& b) const;
    String toDbgString() const;

    const AzStyleBackgroundPositionVec& inner() const { return inner_; }
    AzStyleBackgroundPositionVec& inner() { return inner_; }
    const AzStyleBackgroundPositionVec* ptr() const { return &inner_; }
    AzStyleBackgroundPositionVec* ptr() { return &inner_; }
    AzStyleBackgroundPositionVec release() { AzStyleBackgroundPositionVec result = inner_; inner_ = {}; return result; }
    operator AzStyleBackgroundPositionVec() && noexcept { AzStyleBackgroundPositionVec result = inner_; inner_ = {}; return result; }
};

class StyleBackgroundRepeatVec {
private:
    AzStyleBackgroundRepeatVec inner_;

    StyleBackgroundRepeatVec(const StyleBackgroundRepeatVec&) = delete;
    StyleBackgroundRepeatVec& operator=(const StyleBackgroundRepeatVec&) = delete;

public:
    explicit StyleBackgroundRepeatVec(AzStyleBackgroundRepeatVec inner) noexcept : inner_(inner) {}

    StyleBackgroundRepeatVec(StyleBackgroundRepeatVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyleBackgroundRepeatVec& operator=(StyleBackgroundRepeatVec&& other) noexcept {
        if (this != &other) {
            AzStyleBackgroundRepeatVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyleBackgroundRepeatVec() { AzStyleBackgroundRepeatVec_delete(&inner_); }

    static StyleBackgroundRepeatVec create();
    static StyleBackgroundRepeatVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionStyleBackgroundRepeat get(size_t index) const;
    static StyleBackgroundRepeatVec from_item(AzStyleBackgroundRepeat item);
    static StyleBackgroundRepeatVec copy_from_ptr(const AzStyleBackgroundRepeat* ptr, size_t len);
    OptionStyleBackgroundRepeat c_get(size_t index) const;
    StyleBackgroundRepeatVecSlice as_c_slice() const;
    StyleBackgroundRepeatVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    StyleBackgroundRepeatVec clone() const;
    bool partialEq(const StyleBackgroundRepeatVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBackgroundRepeatVec& b) const;
    uint8_t cmp(const StyleBackgroundRepeatVec& b) const;
    String toDbgString() const;

    const AzStyleBackgroundRepeatVec& inner() const { return inner_; }
    AzStyleBackgroundRepeatVec& inner() { return inner_; }
    const AzStyleBackgroundRepeatVec* ptr() const { return &inner_; }
    AzStyleBackgroundRepeatVec* ptr() { return &inner_; }
    AzStyleBackgroundRepeatVec release() { AzStyleBackgroundRepeatVec result = inner_; inner_ = {}; return result; }
    operator AzStyleBackgroundRepeatVec() && noexcept { AzStyleBackgroundRepeatVec result = inner_; inner_ = {}; return result; }
};

class StyleBackgroundSizeVec {
private:
    AzStyleBackgroundSizeVec inner_;

    StyleBackgroundSizeVec(const StyleBackgroundSizeVec&) = delete;
    StyleBackgroundSizeVec& operator=(const StyleBackgroundSizeVec&) = delete;

public:
    explicit StyleBackgroundSizeVec(AzStyleBackgroundSizeVec inner) noexcept : inner_(inner) {}

    StyleBackgroundSizeVec(StyleBackgroundSizeVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyleBackgroundSizeVec& operator=(StyleBackgroundSizeVec&& other) noexcept {
        if (this != &other) {
            AzStyleBackgroundSizeVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyleBackgroundSizeVec() { AzStyleBackgroundSizeVec_delete(&inner_); }

    static StyleBackgroundSizeVec create();
    static StyleBackgroundSizeVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionStyleBackgroundSize get(size_t index) const;
    static StyleBackgroundSizeVec from_item(AzStyleBackgroundSize item);
    static StyleBackgroundSizeVec copy_from_ptr(const AzStyleBackgroundSize* ptr, size_t len);
    OptionStyleBackgroundSize c_get(size_t index) const;
    StyleBackgroundSizeVecSlice as_c_slice() const;
    StyleBackgroundSizeVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    StyleBackgroundSizeVec clone() const;
    bool partialEq(const StyleBackgroundSizeVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBackgroundSizeVec& b) const;
    uint8_t cmp(const StyleBackgroundSizeVec& b) const;
    String toDbgString() const;

    const AzStyleBackgroundSizeVec& inner() const { return inner_; }
    AzStyleBackgroundSizeVec& inner() { return inner_; }
    const AzStyleBackgroundSizeVec* ptr() const { return &inner_; }
    AzStyleBackgroundSizeVec* ptr() { return &inner_; }
    AzStyleBackgroundSizeVec release() { AzStyleBackgroundSizeVec result = inner_; inner_ = {}; return result; }
    operator AzStyleBackgroundSizeVec() && noexcept { AzStyleBackgroundSizeVec result = inner_; inner_ = {}; return result; }
};

class StyleTransformVec {
private:
    AzStyleTransformVec inner_;

    StyleTransformVec(const StyleTransformVec&) = delete;
    StyleTransformVec& operator=(const StyleTransformVec&) = delete;

public:
    explicit StyleTransformVec(AzStyleTransformVec inner) noexcept : inner_(inner) {}

    StyleTransformVec(StyleTransformVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyleTransformVec& operator=(StyleTransformVec&& other) noexcept {
        if (this != &other) {
            AzStyleTransformVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyleTransformVec() { AzStyleTransformVec_delete(&inner_); }

    static StyleTransformVec create();
    static StyleTransformVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionStyleTransform get(size_t index) const;
    static StyleTransformVec from_item(AzStyleTransform item);
    static StyleTransformVec copy_from_ptr(const AzStyleTransform* ptr, size_t len);
    OptionStyleTransform c_get(size_t index) const;
    StyleTransformVecSlice as_c_slice() const;
    StyleTransformVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    StyleTransformVec clone() const;
    bool partialEq(const StyleTransformVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleTransformVec& b) const;
    uint8_t cmp(const StyleTransformVec& b) const;
    String toDbgString() const;

    const AzStyleTransformVec& inner() const { return inner_; }
    AzStyleTransformVec& inner() { return inner_; }
    const AzStyleTransformVec* ptr() const { return &inner_; }
    AzStyleTransformVec* ptr() { return &inner_; }
    AzStyleTransformVec release() { AzStyleTransformVec result = inner_; inner_ = {}; return result; }
    operator AzStyleTransformVec() && noexcept { AzStyleTransformVec result = inner_; inner_ = {}; return result; }
};

class SvgVertexVec {
private:
    AzSvgVertexVec inner_;

    SvgVertexVec(const SvgVertexVec&) = delete;
    SvgVertexVec& operator=(const SvgVertexVec&) = delete;

public:
    explicit SvgVertexVec(AzSvgVertexVec inner) noexcept : inner_(inner) {}

    SvgVertexVec(SvgVertexVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SvgVertexVec& operator=(SvgVertexVec&& other) noexcept {
        if (this != &other) {
            AzSvgVertexVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SvgVertexVec() { AzSvgVertexVec_delete(&inner_); }

    static SvgVertexVec create();
    static SvgVertexVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionSvgVertex get(size_t index) const;
    static SvgVertexVec from_item(SvgVertex item);
    static SvgVertexVec copy_from_ptr(const SvgVertex& ptr, size_t len);
    OptionSvgVertex c_get(size_t index) const;
    SvgVertexVecSlice as_c_slice() const;
    SvgVertexVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    SvgVertexVec clone() const;
    bool partialEq(const SvgVertexVec& b) const;
    uint8_t partialCmp(const SvgVertexVec& b) const;
    String toDbgString() const;

    const AzSvgVertexVec& inner() const { return inner_; }
    AzSvgVertexVec& inner() { return inner_; }
    const AzSvgVertexVec* ptr() const { return &inner_; }
    AzSvgVertexVec* ptr() { return &inner_; }
    AzSvgVertexVec release() { AzSvgVertexVec result = inner_; inner_ = {}; return result; }
    operator AzSvgVertexVec() && noexcept { AzSvgVertexVec result = inner_; inner_ = {}; return result; }
};

class U32Vec {
private:
    AzU32Vec inner_;

    U32Vec(const U32Vec&) = delete;
    U32Vec& operator=(const U32Vec&) = delete;

public:
    explicit U32Vec(AzU32Vec inner) noexcept : inner_(inner) {}

    U32Vec(U32Vec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    U32Vec& operator=(U32Vec&& other) noexcept {
        if (this != &other) {
            AzU32Vec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~U32Vec() { AzU32Vec_delete(&inner_); }

    static U32Vec create();
    static U32Vec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionU32 get(size_t index) const;
    static U32Vec from_item(uint32_t item);
    static U32Vec copy_from_ptr(const uint32_t* ptr, size_t len);
    OptionU32 c_get(size_t index) const;
    U32VecSlice as_c_slice() const;
    U32VecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    U32Vec clone() const;
    bool partialEq(const U32Vec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const U32Vec& b) const;
    uint8_t cmp(const U32Vec& b) const;
    String toDbgString() const;

    const AzU32Vec& inner() const { return inner_; }
    AzU32Vec& inner() { return inner_; }
    const AzU32Vec* ptr() const { return &inner_; }
    AzU32Vec* ptr() { return &inner_; }
    AzU32Vec release() { AzU32Vec result = inner_; inner_ = {}; return result; }
    operator AzU32Vec() && noexcept { AzU32Vec result = inner_; inner_ = {}; return result; }
};

class VirtualKeyCodeVec {
private:
    AzVirtualKeyCodeVec inner_;

    VirtualKeyCodeVec(const VirtualKeyCodeVec&) = delete;
    VirtualKeyCodeVec& operator=(const VirtualKeyCodeVec&) = delete;

public:
    explicit VirtualKeyCodeVec(AzVirtualKeyCodeVec inner) noexcept : inner_(inner) {}

    VirtualKeyCodeVec(VirtualKeyCodeVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VirtualKeyCodeVec& operator=(VirtualKeyCodeVec&& other) noexcept {
        if (this != &other) {
            AzVirtualKeyCodeVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VirtualKeyCodeVec() { AzVirtualKeyCodeVec_delete(&inner_); }

    static VirtualKeyCodeVec create();
    static VirtualKeyCodeVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionVirtualKeyCode get(size_t index) const;
    static VirtualKeyCodeVec from_item(AzVirtualKeyCode item);
    static VirtualKeyCodeVec copy_from_ptr(const AzVirtualKeyCode* ptr, size_t len);
    OptionVirtualKeyCode c_get(size_t index) const;
    VirtualKeyCodeVecSlice as_c_slice() const;
    VirtualKeyCodeVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    VirtualKeyCodeVec clone() const;
    bool partialEq(const VirtualKeyCodeVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const VirtualKeyCodeVec& b) const;
    uint8_t cmp(const VirtualKeyCodeVec& b) const;
    String toDbgString() const;

    const AzVirtualKeyCodeVec& inner() const { return inner_; }
    AzVirtualKeyCodeVec& inner() { return inner_; }
    const AzVirtualKeyCodeVec* ptr() const { return &inner_; }
    AzVirtualKeyCodeVec* ptr() { return &inner_; }
    AzVirtualKeyCodeVec release() { AzVirtualKeyCodeVec result = inner_; inner_ = {}; return result; }
    operator AzVirtualKeyCodeVec() && noexcept { AzVirtualKeyCodeVec result = inner_; inner_ = {}; return result; }
};

class CascadeInfoVec {
private:
    AzCascadeInfoVec inner_;

    CascadeInfoVec(const CascadeInfoVec&) = delete;
    CascadeInfoVec& operator=(const CascadeInfoVec&) = delete;

public:
    explicit CascadeInfoVec(AzCascadeInfoVec inner) noexcept : inner_(inner) {}

    CascadeInfoVec(CascadeInfoVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CascadeInfoVec& operator=(CascadeInfoVec&& other) noexcept {
        if (this != &other) {
            AzCascadeInfoVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CascadeInfoVec() { AzCascadeInfoVec_delete(&inner_); }

    static CascadeInfoVec create();
    static CascadeInfoVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionCascadeInfo get(size_t index) const;
    static CascadeInfoVec from_item(CascadeInfo item);
    static CascadeInfoVec copy_from_ptr(const CascadeInfo& ptr, size_t len);
    OptionCascadeInfo c_get(size_t index) const;
    CascadeInfoVecSlice as_c_slice() const;
    CascadeInfoVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    CascadeInfoVec clone() const;
    bool partialEq(const CascadeInfoVec& b) const;
    uint8_t partialCmp(const CascadeInfoVec& b) const;
    String toDbgString() const;

    const AzCascadeInfoVec& inner() const { return inner_; }
    AzCascadeInfoVec& inner() { return inner_; }
    const AzCascadeInfoVec* ptr() const { return &inner_; }
    AzCascadeInfoVec* ptr() { return &inner_; }
    AzCascadeInfoVec release() { AzCascadeInfoVec result = inner_; inner_ = {}; return result; }
    operator AzCascadeInfoVec() && noexcept { AzCascadeInfoVec result = inner_; inner_ = {}; return result; }
};

class CssDeclarationVec {
private:
    AzCssDeclarationVec inner_;

    CssDeclarationVec(const CssDeclarationVec&) = delete;
    CssDeclarationVec& operator=(const CssDeclarationVec&) = delete;

public:
    explicit CssDeclarationVec(AzCssDeclarationVec inner) noexcept : inner_(inner) {}

    CssDeclarationVec(CssDeclarationVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssDeclarationVec& operator=(CssDeclarationVec&& other) noexcept {
        if (this != &other) {
            AzCssDeclarationVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssDeclarationVec() { AzCssDeclarationVec_delete(&inner_); }

    static CssDeclarationVec create();
    static CssDeclarationVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionCssDeclaration get(size_t index) const;
    static CssDeclarationVec from_item(AzCssDeclaration item);
    static CssDeclarationVec copy_from_ptr(const AzCssDeclaration* ptr, size_t len);
    OptionCssDeclaration c_get(size_t index) const;
    CssDeclarationVecSlice as_c_slice() const;
    CssDeclarationVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    CssDeclarationVec clone() const;
    bool partialEq(const CssDeclarationVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CssDeclarationVec& b) const;
    uint8_t cmp(const CssDeclarationVec& b) const;
    String toDbgString() const;

    const AzCssDeclarationVec& inner() const { return inner_; }
    AzCssDeclarationVec& inner() { return inner_; }
    const AzCssDeclarationVec* ptr() const { return &inner_; }
    AzCssDeclarationVec* ptr() { return &inner_; }
    AzCssDeclarationVec release() { AzCssDeclarationVec result = inner_; inner_ = {}; return result; }
    operator AzCssDeclarationVec() && noexcept { AzCssDeclarationVec result = inner_; inner_ = {}; return result; }
};

class CssPathSelectorVec {
private:
    AzCssPathSelectorVec inner_;

    CssPathSelectorVec(const CssPathSelectorVec&) = delete;
    CssPathSelectorVec& operator=(const CssPathSelectorVec&) = delete;

public:
    explicit CssPathSelectorVec(AzCssPathSelectorVec inner) noexcept : inner_(inner) {}

    CssPathSelectorVec(CssPathSelectorVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssPathSelectorVec& operator=(CssPathSelectorVec&& other) noexcept {
        if (this != &other) {
            AzCssPathSelectorVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssPathSelectorVec() { AzCssPathSelectorVec_delete(&inner_); }

    static CssPathSelectorVec create();
    static CssPathSelectorVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionCssPathSelector get(size_t index) const;
    static CssPathSelectorVec from_item(AzCssPathSelector item);
    static CssPathSelectorVec copy_from_ptr(const AzCssPathSelector* ptr, size_t len);
    OptionCssPathSelector c_get(size_t index) const;
    CssPathSelectorVecSlice as_c_slice() const;
    CssPathSelectorVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    CssPathSelectorVec clone() const;
    bool partialEq(const CssPathSelectorVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CssPathSelectorVec& b) const;
    uint8_t cmp(const CssPathSelectorVec& b) const;
    String toDbgString() const;

    const AzCssPathSelectorVec& inner() const { return inner_; }
    AzCssPathSelectorVec& inner() { return inner_; }
    const AzCssPathSelectorVec* ptr() const { return &inner_; }
    AzCssPathSelectorVec* ptr() { return &inner_; }
    AzCssPathSelectorVec release() { AzCssPathSelectorVec result = inner_; inner_ = {}; return result; }
    operator AzCssPathSelectorVec() && noexcept { AzCssPathSelectorVec result = inner_; inner_ = {}; return result; }
};

class CssVec {
private:
    AzCssVec inner_;

    CssVec(const CssVec&) = delete;
    CssVec& operator=(const CssVec&) = delete;

public:
    explicit CssVec(AzCssVec inner) noexcept : inner_(inner) {}

    CssVec(CssVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssVec& operator=(CssVec&& other) noexcept {
        if (this != &other) {
            AzCssVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssVec() { AzCssVec_delete(&inner_); }

    static CssVec create();
    static CssVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionCss get(size_t index) const;
    static CssVec from_item(Css item);
    static CssVec copy_from_ptr(const Css& ptr, size_t len);
    OptionCss c_get(size_t index) const;
    CssVecSlice as_c_slice() const;
    CssVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    CssVec clone() const;
    bool partialEq(const CssVec& b) const;
    uint8_t partialCmp(const CssVec& b) const;
    String toDbgString() const;

    const AzCssVec& inner() const { return inner_; }
    AzCssVec& inner() { return inner_; }
    const AzCssVec* ptr() const { return &inner_; }
    AzCssVec* ptr() { return &inner_; }
    AzCssVec release() { AzCssVec result = inner_; inner_ = {}; return result; }
    operator AzCssVec() && noexcept { AzCssVec result = inner_; inner_ = {}; return result; }
};

class CssRuleBlockVec {
private:
    AzCssRuleBlockVec inner_;

    CssRuleBlockVec(const CssRuleBlockVec&) = delete;
    CssRuleBlockVec& operator=(const CssRuleBlockVec&) = delete;

public:
    explicit CssRuleBlockVec(AzCssRuleBlockVec inner) noexcept : inner_(inner) {}

    CssRuleBlockVec(CssRuleBlockVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssRuleBlockVec& operator=(CssRuleBlockVec&& other) noexcept {
        if (this != &other) {
            AzCssRuleBlockVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssRuleBlockVec() { AzCssRuleBlockVec_delete(&inner_); }

    static CssRuleBlockVec create();
    static CssRuleBlockVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionCssRuleBlock get(size_t index) const;
    static CssRuleBlockVec from_item(CssRuleBlock item);
    static CssRuleBlockVec copy_from_ptr(const CssRuleBlock& ptr, size_t len);
    OptionCssRuleBlock c_get(size_t index) const;
    CssRuleBlockVecSlice as_c_slice() const;
    CssRuleBlockVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    CssRuleBlockVec clone() const;
    bool partialEq(const CssRuleBlockVec& b) const;
    uint8_t partialCmp(const CssRuleBlockVec& b) const;
    String toDbgString() const;

    const AzCssRuleBlockVec& inner() const { return inner_; }
    AzCssRuleBlockVec& inner() { return inner_; }
    const AzCssRuleBlockVec* ptr() const { return &inner_; }
    AzCssRuleBlockVec* ptr() { return &inner_; }
    AzCssRuleBlockVec release() { AzCssRuleBlockVec result = inner_; inner_ = {}; return result; }
    operator AzCssRuleBlockVec() && noexcept { AzCssRuleBlockVec result = inner_; inner_ = {}; return result; }
};

class U16Vec {
private:
    AzU16Vec inner_;

    U16Vec(const U16Vec&) = delete;
    U16Vec& operator=(const U16Vec&) = delete;

public:
    explicit U16Vec(AzU16Vec inner) noexcept : inner_(inner) {}

    U16Vec(U16Vec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    U16Vec& operator=(U16Vec&& other) noexcept {
        if (this != &other) {
            AzU16Vec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~U16Vec() { AzU16Vec_delete(&inner_); }

    static U16Vec create();
    static U16Vec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionU16 get(size_t index) const;
    static U16Vec from_item(uint16_t item);
    static U16Vec copy_from_ptr(const uint16_t* ptr, size_t len);
    OptionU16 c_get(size_t index) const;
    U16VecSlice as_c_slice() const;
    U16VecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    U16Vec clone() const;
    bool partialEq(const U16Vec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const U16Vec& b) const;
    uint8_t cmp(const U16Vec& b) const;
    String toDbgString() const;

    const AzU16Vec& inner() const { return inner_; }
    AzU16Vec& inner() { return inner_; }
    const AzU16Vec* ptr() const { return &inner_; }
    AzU16Vec* ptr() { return &inner_; }
    AzU16Vec release() { AzU16Vec result = inner_; inner_ = {}; return result; }
    operator AzU16Vec() && noexcept { AzU16Vec result = inner_; inner_ = {}; return result; }
};

class F32Vec {
private:
    AzF32Vec inner_;

    F32Vec(const F32Vec&) = delete;
    F32Vec& operator=(const F32Vec&) = delete;

public:
    explicit F32Vec(AzF32Vec inner) noexcept : inner_(inner) {}

    F32Vec(F32Vec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    F32Vec& operator=(F32Vec&& other) noexcept {
        if (this != &other) {
            AzF32Vec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~F32Vec() { AzF32Vec_delete(&inner_); }

    static F32Vec create();
    static F32Vec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionF32 get(size_t index) const;
    static F32Vec from_item(float item);
    static F32Vec copy_from_ptr(const float* ptr, size_t len);
    OptionF32 c_get(size_t index) const;
    F32VecSlice as_c_slice() const;
    F32VecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    F32Vec clone() const;
    bool partialEq(const F32Vec& b) const;
    uint8_t partialCmp(const F32Vec& b) const;
    String toDbgString() const;

    const AzF32Vec& inner() const { return inner_; }
    AzF32Vec& inner() { return inner_; }
    const AzF32Vec* ptr() const { return &inner_; }
    AzF32Vec* ptr() { return &inner_; }
    AzF32Vec release() { AzF32Vec result = inner_; inner_ = {}; return result; }
    operator AzF32Vec() && noexcept { AzF32Vec result = inner_; inner_ = {}; return result; }
};

class U8Vec {
private:
    AzU8Vec inner_;

    U8Vec(const U8Vec&) = delete;
    U8Vec& operator=(const U8Vec&) = delete;

public:
    explicit U8Vec(AzU8Vec inner) noexcept : inner_(inner) {}

    U8Vec(U8Vec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    U8Vec& operator=(U8Vec&& other) noexcept {
        if (this != &other) {
            AzU8Vec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~U8Vec() { AzU8Vec_delete(&inner_); }

    [[nodiscard]] static U8Vec copy_from_bytes(const uint8_t* ptr, size_t start, size_t len);

    U8VecRef as_ref_vec() const;
    static U8Vec create();
    static U8Vec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionU8 get(size_t index) const;
    static U8Vec from_item(uint8_t item);
    static U8Vec copy_from_ptr(const uint8_t* ptr, size_t len);
    OptionU8 c_get(size_t index) const;
    U8VecSlice as_c_slice() const;
    U8VecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    U8Vec clone() const;
    bool partialEq(const U8Vec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const U8Vec& b) const;
    uint8_t cmp(const U8Vec& b) const;
    String toDbgString() const;

    const AzU8Vec& inner() const { return inner_; }
    AzU8Vec& inner() { return inner_; }
    const AzU8Vec* ptr() const { return &inner_; }
    AzU8Vec* ptr() { return &inner_; }
    AzU8Vec release() { AzU8Vec result = inner_; inner_ = {}; return result; }
    operator AzU8Vec() && noexcept { AzU8Vec result = inner_; inner_ = {}; return result; }

    // Iterator support
    const uint8_t* begin() const { return inner_.ptr; }
    const uint8_t* end() const { return inner_.ptr + inner_.len; }
    uint8_t* begin() { return const_cast<uint8_t*>(inner_.ptr); }
    uint8_t* end() { return const_cast<uint8_t*>(inner_.ptr) + inner_.len; }
    size_t size() const { return inner_.len; }
    bool empty() const { return inner_.len == 0; }
    const uint8_t& operator[](size_t i) const { return inner_.ptr[i]; }
    uint8_t& operator[](size_t i) { return const_cast<uint8_t*>(inner_.ptr)[i]; }
    std::vector<uint8_t> toStdVector() const { return std::vector<uint8_t>(begin(), end()); }
    std::span<const uint8_t> toSpan() const { return std::span<const uint8_t>(begin(), size()); }
    std::span<uint8_t> toSpan() { return std::span<uint8_t>(begin(), size()); }
    operator std::span<const uint8_t>() const { return toSpan(); }
};

class GLuintVec {
private:
    AzGLuintVec inner_;

    GLuintVec(const GLuintVec&) = delete;
    GLuintVec& operator=(const GLuintVec&) = delete;

public:
    explicit GLuintVec(AzGLuintVec inner) noexcept : inner_(inner) {}

    GLuintVec(GLuintVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GLuintVec& operator=(GLuintVec&& other) noexcept {
        if (this != &other) {
            AzGLuintVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GLuintVec() { AzGLuintVec_delete(&inner_); }

    static GLuintVec create();
    static GLuintVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionU32 get(size_t index) const;
    static GLuintVec from_item(AzGLuint item);
    static GLuintVec copy_from_ptr(const AzGLuint* ptr, size_t len);
    OptionU32 c_get(size_t index) const;
    GLuintVecSlice as_c_slice() const;
    GLuintVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    GLuintVec clone() const;
    bool partialEq(const GLuintVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GLuintVec& b) const;
    uint8_t cmp(const GLuintVec& b) const;
    String toDbgString() const;

    const AzGLuintVec& inner() const { return inner_; }
    AzGLuintVec& inner() { return inner_; }
    const AzGLuintVec* ptr() const { return &inner_; }
    AzGLuintVec* ptr() { return &inner_; }
    AzGLuintVec release() { AzGLuintVec result = inner_; inner_ = {}; return result; }
    operator AzGLuintVec() && noexcept { AzGLuintVec result = inner_; inner_ = {}; return result; }

    // Iterator support
    const AzGLuint* begin() const { return inner_.ptr; }
    const AzGLuint* end() const { return inner_.ptr + inner_.len; }
    AzGLuint* begin() { return const_cast<AzGLuint*>(inner_.ptr); }
    AzGLuint* end() { return const_cast<AzGLuint*>(inner_.ptr) + inner_.len; }
    size_t size() const { return inner_.len; }
    bool empty() const { return inner_.len == 0; }
    const AzGLuint& operator[](size_t i) const { return inner_.ptr[i]; }
    AzGLuint& operator[](size_t i) { return const_cast<AzGLuint*>(inner_.ptr)[i]; }
    std::vector<AzGLuint> toStdVector() const { return std::vector<AzGLuint>(begin(), end()); }
    std::span<const AzGLuint> toSpan() const { return std::span<const AzGLuint>(begin(), size()); }
    std::span<AzGLuint> toSpan() { return std::span<AzGLuint>(begin(), size()); }
    operator std::span<const AzGLuint>() const { return toSpan(); }
};

class GLintVec {
private:
    AzGLintVec inner_;

    GLintVec(const GLintVec&) = delete;
    GLintVec& operator=(const GLintVec&) = delete;

public:
    explicit GLintVec(AzGLintVec inner) noexcept : inner_(inner) {}

    GLintVec(GLintVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GLintVec& operator=(GLintVec&& other) noexcept {
        if (this != &other) {
            AzGLintVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GLintVec() { AzGLintVec_delete(&inner_); }

    static GLintVec create();
    static GLintVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionI32 get(size_t index) const;
    static GLintVec from_item(AzGLint item);
    static GLintVec copy_from_ptr(const AzGLint* ptr, size_t len);
    OptionI32 c_get(size_t index) const;
    GLintVecSlice as_c_slice() const;
    GLintVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    GLintVec clone() const;
    bool partialEq(const GLintVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GLintVec& b) const;
    uint8_t cmp(const GLintVec& b) const;
    String toDbgString() const;

    const AzGLintVec& inner() const { return inner_; }
    AzGLintVec& inner() { return inner_; }
    const AzGLintVec* ptr() const { return &inner_; }
    AzGLintVec* ptr() { return &inner_; }
    AzGLintVec release() { AzGLintVec result = inner_; inner_ = {}; return result; }
    operator AzGLintVec() && noexcept { AzGLintVec result = inner_; inner_ = {}; return result; }

    // Iterator support
    const AzGLint* begin() const { return inner_.ptr; }
    const AzGLint* end() const { return inner_.ptr + inner_.len; }
    AzGLint* begin() { return const_cast<AzGLint*>(inner_.ptr); }
    AzGLint* end() { return const_cast<AzGLint*>(inner_.ptr) + inner_.len; }
    size_t size() const { return inner_.len; }
    bool empty() const { return inner_.len == 0; }
    const AzGLint& operator[](size_t i) const { return inner_.ptr[i]; }
    AzGLint& operator[](size_t i) { return const_cast<AzGLint*>(inner_.ptr)[i]; }
    std::vector<AzGLint> toStdVector() const { return std::vector<AzGLint>(begin(), end()); }
    std::span<const AzGLint> toSpan() const { return std::span<const AzGLint>(begin(), size()); }
    std::span<AzGLint> toSpan() { return std::span<AzGLint>(begin(), size()); }
    operator std::span<const AzGLint>() const { return toSpan(); }
};

class StringVec {
private:
    AzStringVec inner_;

    StringVec(const StringVec&) = delete;
    StringVec& operator=(const StringVec&) = delete;

public:
    explicit StringVec(AzStringVec inner) noexcept : inner_(inner) {}

    StringVec(StringVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StringVec& operator=(StringVec&& other) noexcept {
        if (this != &other) {
            AzStringVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StringVec() { AzStringVec_delete(&inner_); }

    static StringVec create();
    static StringVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionString get(size_t index) const;
    static StringVec from_item(String item);
    static StringVec copy_from_ptr(const String& ptr, size_t len);
    OptionString c_get(size_t index) const;
    StringVecSlice as_c_slice() const;
    StringVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    StringVec clone() const;
    bool partialEq(const StringVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StringVec& b) const;
    uint8_t cmp(const StringVec& b) const;
    String toDbgString() const;

    const AzStringVec& inner() const { return inner_; }
    AzStringVec& inner() { return inner_; }
    const AzStringVec* ptr() const { return &inner_; }
    AzStringVec* ptr() { return &inner_; }
    AzStringVec release() { AzStringVec result = inner_; inner_ = {}; return result; }
    operator AzStringVec() && noexcept { AzStringVec result = inner_; inner_ = {}; return result; }

    // Iterator support
    const AzString* begin() const { return inner_.ptr; }
    const AzString* end() const { return inner_.ptr + inner_.len; }
    AzString* begin() { return const_cast<AzString*>(inner_.ptr); }
    AzString* end() { return const_cast<AzString*>(inner_.ptr) + inner_.len; }
    size_t size() const { return inner_.len; }
    bool empty() const { return inner_.len == 0; }
    const AzString& operator[](size_t i) const { return inner_.ptr[i]; }
    AzString& operator[](size_t i) { return const_cast<AzString*>(inner_.ptr)[i]; }
    std::vector<AzString> toStdVector() const { return std::vector<AzString>(begin(), end()); }
    std::span<const AzString> toSpan() const { return std::span<const AzString>(begin(), size()); }
    std::span<AzString> toSpan() { return std::span<AzString>(begin(), size()); }
    operator std::span<const AzString>() const { return toSpan(); }
};

class MimeTypeDataVec {
private:
    AzMimeTypeDataVec inner_;

    MimeTypeDataVec(const MimeTypeDataVec&) = delete;
    MimeTypeDataVec& operator=(const MimeTypeDataVec&) = delete;

public:
    explicit MimeTypeDataVec(AzMimeTypeDataVec inner) noexcept : inner_(inner) {}

    MimeTypeDataVec(MimeTypeDataVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MimeTypeDataVec& operator=(MimeTypeDataVec&& other) noexcept {
        if (this != &other) {
            AzMimeTypeDataVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MimeTypeDataVec() { AzMimeTypeDataVec_delete(&inner_); }

    static MimeTypeDataVec create();
    static MimeTypeDataVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionMimeTypeData get(size_t index) const;
    static MimeTypeDataVec from_item(MimeTypeData item);
    static MimeTypeDataVec copy_from_ptr(const MimeTypeData& ptr, size_t len);
    OptionMimeTypeData c_get(size_t index) const;
    MimeTypeDataVecSlice as_c_slice() const;
    MimeTypeDataVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    MimeTypeDataVec clone() const;
    bool partialEq(const MimeTypeDataVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const MimeTypeDataVec& b) const;
    uint8_t cmp(const MimeTypeDataVec& b) const;
    String toDbgString() const;

    const AzMimeTypeDataVec& inner() const { return inner_; }
    AzMimeTypeDataVec& inner() { return inner_; }
    const AzMimeTypeDataVec* ptr() const { return &inner_; }
    AzMimeTypeDataVec* ptr() { return &inner_; }
    AzMimeTypeDataVec release() { AzMimeTypeDataVec result = inner_; inner_ = {}; return result; }
    operator AzMimeTypeDataVec() && noexcept { AzMimeTypeDataVec result = inner_; inner_ = {}; return result; }
};

class StringPairVec {
private:
    AzStringPairVec inner_;

    StringPairVec(const StringPairVec&) = delete;
    StringPairVec& operator=(const StringPairVec&) = delete;

public:
    explicit StringPairVec(AzStringPairVec inner) noexcept : inner_(inner) {}

    StringPairVec(StringPairVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StringPairVec& operator=(StringPairVec&& other) noexcept {
        if (this != &other) {
            AzStringPairVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StringPairVec() { AzStringPairVec_delete(&inner_); }

    static StringPairVec create();
    static StringPairVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionStringPair get(size_t index) const;
    static StringPairVec from_item(StringPair item);
    static StringPairVec copy_from_ptr(const StringPair& ptr, size_t len);
    OptionStringPair c_get(size_t index) const;
    StringPairVecSlice as_c_slice() const;
    StringPairVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    StringPairVec clone() const;
    bool partialEq(const StringPairVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StringPairVec& b) const;
    uint8_t cmp(const StringPairVec& b) const;
    String toDbgString() const;

    const AzStringPairVec& inner() const { return inner_; }
    AzStringPairVec& inner() { return inner_; }
    const AzStringPairVec* ptr() const { return &inner_; }
    AzStringPairVec* ptr() { return &inner_; }
    AzStringPairVec release() { AzStringPairVec result = inner_; inner_ = {}; return result; }
    operator AzStringPairVec() && noexcept { AzStringPairVec result = inner_; inner_ = {}; return result; }
};

class NormalizedLinearColorStopVec {
private:
    AzNormalizedLinearColorStopVec inner_;

    NormalizedLinearColorStopVec(const NormalizedLinearColorStopVec&) = delete;
    NormalizedLinearColorStopVec& operator=(const NormalizedLinearColorStopVec&) = delete;

public:
    explicit NormalizedLinearColorStopVec(AzNormalizedLinearColorStopVec inner) noexcept : inner_(inner) {}

    NormalizedLinearColorStopVec(NormalizedLinearColorStopVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NormalizedLinearColorStopVec& operator=(NormalizedLinearColorStopVec&& other) noexcept {
        if (this != &other) {
            AzNormalizedLinearColorStopVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NormalizedLinearColorStopVec() { AzNormalizedLinearColorStopVec_delete(&inner_); }

    static NormalizedLinearColorStopVec create();
    static NormalizedLinearColorStopVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionNormalizedLinearColorStop get(size_t index) const;
    static NormalizedLinearColorStopVec from_item(NormalizedLinearColorStop item);
    static NormalizedLinearColorStopVec copy_from_ptr(const NormalizedLinearColorStop& ptr, size_t len);
    OptionNormalizedLinearColorStop c_get(size_t index) const;
    NormalizedLinearColorStopVecSlice as_c_slice() const;
    NormalizedLinearColorStopVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    NormalizedLinearColorStopVec clone() const;
    bool partialEq(const NormalizedLinearColorStopVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NormalizedLinearColorStopVec& b) const;
    uint8_t cmp(const NormalizedLinearColorStopVec& b) const;
    String toDbgString() const;

    const AzNormalizedLinearColorStopVec& inner() const { return inner_; }
    AzNormalizedLinearColorStopVec& inner() { return inner_; }
    const AzNormalizedLinearColorStopVec* ptr() const { return &inner_; }
    AzNormalizedLinearColorStopVec* ptr() { return &inner_; }
    AzNormalizedLinearColorStopVec release() { AzNormalizedLinearColorStopVec result = inner_; inner_ = {}; return result; }
    operator AzNormalizedLinearColorStopVec() && noexcept { AzNormalizedLinearColorStopVec result = inner_; inner_ = {}; return result; }
};

class NormalizedRadialColorStopVec {
private:
    AzNormalizedRadialColorStopVec inner_;

    NormalizedRadialColorStopVec(const NormalizedRadialColorStopVec&) = delete;
    NormalizedRadialColorStopVec& operator=(const NormalizedRadialColorStopVec&) = delete;

public:
    explicit NormalizedRadialColorStopVec(AzNormalizedRadialColorStopVec inner) noexcept : inner_(inner) {}

    NormalizedRadialColorStopVec(NormalizedRadialColorStopVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NormalizedRadialColorStopVec& operator=(NormalizedRadialColorStopVec&& other) noexcept {
        if (this != &other) {
            AzNormalizedRadialColorStopVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NormalizedRadialColorStopVec() { AzNormalizedRadialColorStopVec_delete(&inner_); }

    static NormalizedRadialColorStopVec create();
    static NormalizedRadialColorStopVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionNormalizedRadialColorStop get(size_t index) const;
    static NormalizedRadialColorStopVec from_item(NormalizedRadialColorStop item);
    static NormalizedRadialColorStopVec copy_from_ptr(const NormalizedRadialColorStop& ptr, size_t len);
    OptionNormalizedRadialColorStop c_get(size_t index) const;
    NormalizedRadialColorStopVecSlice as_c_slice() const;
    NormalizedRadialColorStopVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    NormalizedRadialColorStopVec clone() const;
    bool partialEq(const NormalizedRadialColorStopVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NormalizedRadialColorStopVec& b) const;
    uint8_t cmp(const NormalizedRadialColorStopVec& b) const;
    String toDbgString() const;

    const AzNormalizedRadialColorStopVec& inner() const { return inner_; }
    AzNormalizedRadialColorStopVec& inner() { return inner_; }
    const AzNormalizedRadialColorStopVec* ptr() const { return &inner_; }
    AzNormalizedRadialColorStopVec* ptr() { return &inner_; }
    AzNormalizedRadialColorStopVec release() { AzNormalizedRadialColorStopVec result = inner_; inner_ = {}; return result; }
    operator AzNormalizedRadialColorStopVec() && noexcept { AzNormalizedRadialColorStopVec result = inner_; inner_ = {}; return result; }
};

class NodeHierarchyItemVec {
private:
    AzNodeHierarchyItemVec inner_;

    NodeHierarchyItemVec(const NodeHierarchyItemVec&) = delete;
    NodeHierarchyItemVec& operator=(const NodeHierarchyItemVec&) = delete;

public:
    explicit NodeHierarchyItemVec(AzNodeHierarchyItemVec inner) noexcept : inner_(inner) {}

    NodeHierarchyItemVec(NodeHierarchyItemVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NodeHierarchyItemVec& operator=(NodeHierarchyItemVec&& other) noexcept {
        if (this != &other) {
            AzNodeHierarchyItemVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NodeHierarchyItemVec() { AzNodeHierarchyItemVec_delete(&inner_); }

    static NodeHierarchyItemVec create();
    static NodeHierarchyItemVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionNodeHierarchyItem get(size_t index) const;
    static NodeHierarchyItemVec from_item(NodeHierarchyItem item);
    static NodeHierarchyItemVec copy_from_ptr(const NodeHierarchyItem& ptr, size_t len);
    OptionNodeHierarchyItem c_get(size_t index) const;
    NodeHierarchyItemVecSlice as_c_slice() const;
    NodeHierarchyItemVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    NodeHierarchyItemVec clone() const;
    bool partialEq(const NodeHierarchyItemVec& b) const;
    uint8_t partialCmp(const NodeHierarchyItemVec& b) const;
    String toDbgString() const;

    const AzNodeHierarchyItemVec& inner() const { return inner_; }
    AzNodeHierarchyItemVec& inner() { return inner_; }
    const AzNodeHierarchyItemVec* ptr() const { return &inner_; }
    AzNodeHierarchyItemVec* ptr() { return &inner_; }
    AzNodeHierarchyItemVec release() { AzNodeHierarchyItemVec result = inner_; inner_ = {}; return result; }
    operator AzNodeHierarchyItemVec() && noexcept { AzNodeHierarchyItemVec result = inner_; inner_ = {}; return result; }
};

class TagIdToNodeIdMappingVec {
private:
    AzTagIdToNodeIdMappingVec inner_;

    TagIdToNodeIdMappingVec(const TagIdToNodeIdMappingVec&) = delete;
    TagIdToNodeIdMappingVec& operator=(const TagIdToNodeIdMappingVec&) = delete;

public:
    explicit TagIdToNodeIdMappingVec(AzTagIdToNodeIdMappingVec inner) noexcept : inner_(inner) {}

    TagIdToNodeIdMappingVec(TagIdToNodeIdMappingVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TagIdToNodeIdMappingVec& operator=(TagIdToNodeIdMappingVec&& other) noexcept {
        if (this != &other) {
            AzTagIdToNodeIdMappingVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TagIdToNodeIdMappingVec() { AzTagIdToNodeIdMappingVec_delete(&inner_); }

    static TagIdToNodeIdMappingVec create();
    static TagIdToNodeIdMappingVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionTagIdToNodeIdMapping get(size_t index) const;
    static TagIdToNodeIdMappingVec from_item(TagIdToNodeIdMapping item);
    static TagIdToNodeIdMappingVec copy_from_ptr(const TagIdToNodeIdMapping& ptr, size_t len);
    OptionTagIdToNodeIdMapping c_get(size_t index) const;
    TagIdToNodeIdMappingVecSlice as_c_slice() const;
    TagIdToNodeIdMappingVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    TagIdToNodeIdMappingVec clone() const;
    bool partialEq(const TagIdToNodeIdMappingVec& b) const;
    uint8_t partialCmp(const TagIdToNodeIdMappingVec& b) const;
    String toDbgString() const;

    const AzTagIdToNodeIdMappingVec& inner() const { return inner_; }
    AzTagIdToNodeIdMappingVec& inner() { return inner_; }
    const AzTagIdToNodeIdMappingVec* ptr() const { return &inner_; }
    AzTagIdToNodeIdMappingVec* ptr() { return &inner_; }
    AzTagIdToNodeIdMappingVec release() { AzTagIdToNodeIdMappingVec result = inner_; inner_ = {}; return result; }
    operator AzTagIdToNodeIdMappingVec() && noexcept { AzTagIdToNodeIdMappingVec result = inner_; inner_ = {}; return result; }
};

class ParentWithNodeDepthVec {
private:
    AzParentWithNodeDepthVec inner_;

    ParentWithNodeDepthVec(const ParentWithNodeDepthVec&) = delete;
    ParentWithNodeDepthVec& operator=(const ParentWithNodeDepthVec&) = delete;

public:
    explicit ParentWithNodeDepthVec(AzParentWithNodeDepthVec inner) noexcept : inner_(inner) {}

    ParentWithNodeDepthVec(ParentWithNodeDepthVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ParentWithNodeDepthVec& operator=(ParentWithNodeDepthVec&& other) noexcept {
        if (this != &other) {
            AzParentWithNodeDepthVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ParentWithNodeDepthVec() { AzParentWithNodeDepthVec_delete(&inner_); }

    static ParentWithNodeDepthVec create();
    static ParentWithNodeDepthVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionParentWithNodeDepth get(size_t index) const;
    static ParentWithNodeDepthVec from_item(ParentWithNodeDepth item);
    static ParentWithNodeDepthVec copy_from_ptr(const ParentWithNodeDepth& ptr, size_t len);
    OptionParentWithNodeDepth c_get(size_t index) const;
    ParentWithNodeDepthVecSlice as_c_slice() const;
    ParentWithNodeDepthVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ParentWithNodeDepthVec clone() const;
    bool partialEq(const ParentWithNodeDepthVec& b) const;
    uint8_t partialCmp(const ParentWithNodeDepthVec& b) const;
    String toDbgString() const;

    const AzParentWithNodeDepthVec& inner() const { return inner_; }
    AzParentWithNodeDepthVec& inner() { return inner_; }
    const AzParentWithNodeDepthVec* ptr() const { return &inner_; }
    AzParentWithNodeDepthVec* ptr() { return &inner_; }
    AzParentWithNodeDepthVec release() { AzParentWithNodeDepthVec result = inner_; inner_ = {}; return result; }
    operator AzParentWithNodeDepthVec() && noexcept { AzParentWithNodeDepthVec result = inner_; inner_ = {}; return result; }
};

class NodeDataVec {
private:
    AzNodeDataVec inner_;

    NodeDataVec(const NodeDataVec&) = delete;
    NodeDataVec& operator=(const NodeDataVec&) = delete;

public:
    explicit NodeDataVec(AzNodeDataVec inner) noexcept : inner_(inner) {}

    NodeDataVec(NodeDataVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NodeDataVec& operator=(NodeDataVec&& other) noexcept {
        if (this != &other) {
            AzNodeDataVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NodeDataVec() { AzNodeDataVec_delete(&inner_); }

    static NodeDataVec create();
    static NodeDataVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionNodeData get(size_t index) const;
    static NodeDataVec from_item(NodeData item);
    static NodeDataVec copy_from_ptr(const NodeData& ptr, size_t len);
    OptionNodeData c_get(size_t index) const;
    NodeDataVecSlice as_c_slice() const;
    NodeDataVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    NodeDataVec clone() const;
    bool partialEq(const NodeDataVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NodeDataVec& b) const;
    uint8_t cmp(const NodeDataVec& b) const;
    String toDbgString() const;

    const AzNodeDataVec& inner() const { return inner_; }
    AzNodeDataVec& inner() { return inner_; }
    const AzNodeDataVec* ptr() const { return &inner_; }
    AzNodeDataVec* ptr() { return &inner_; }
    AzNodeDataVec release() { AzNodeDataVec result = inner_; inner_ = {}; return result; }
    operator AzNodeDataVec() && noexcept { AzNodeDataVec result = inner_; inner_ = {}; return result; }
};

class AttributeTypeVec {
private:
    AzAttributeTypeVec inner_;

    AttributeTypeVec(const AttributeTypeVec&) = delete;
    AttributeTypeVec& operator=(const AttributeTypeVec&) = delete;

public:
    explicit AttributeTypeVec(AzAttributeTypeVec inner) noexcept : inner_(inner) {}

    AttributeTypeVec(AttributeTypeVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    AttributeTypeVec& operator=(AttributeTypeVec&& other) noexcept {
        if (this != &other) {
            AzAttributeTypeVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~AttributeTypeVec() { AzAttributeTypeVec_delete(&inner_); }

    static AttributeTypeVec create();
    static AttributeTypeVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionAttributeType get(size_t index) const;
    static AttributeTypeVec from_item(AzAttributeType item);
    static AttributeTypeVec copy_from_ptr(const AzAttributeType* ptr, size_t len);
    OptionAttributeType c_get(size_t index) const;
    AttributeTypeVecSlice as_c_slice() const;
    AttributeTypeVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    AttributeTypeVec clone() const;
    bool partialEq(const AttributeTypeVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const AttributeTypeVec& b) const;
    uint8_t cmp(const AttributeTypeVec& b) const;
    String toDbgString() const;

    const AzAttributeTypeVec& inner() const { return inner_; }
    AzAttributeTypeVec& inner() { return inner_; }
    const AzAttributeTypeVec* ptr() const { return &inner_; }
    AzAttributeTypeVec* ptr() { return &inner_; }
    AzAttributeTypeVec release() { AzAttributeTypeVec result = inner_; inner_ = {}; return result; }
    operator AzAttributeTypeVec() && noexcept { AzAttributeTypeVec result = inner_; inner_ = {}; return result; }
};

class CoreCallbackDataVec {
private:
    AzCoreCallbackDataVec inner_;

    CoreCallbackDataVec(const CoreCallbackDataVec&) = delete;
    CoreCallbackDataVec& operator=(const CoreCallbackDataVec&) = delete;

public:
    explicit CoreCallbackDataVec(AzCoreCallbackDataVec inner) noexcept : inner_(inner) {}

    CoreCallbackDataVec(CoreCallbackDataVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CoreCallbackDataVec& operator=(CoreCallbackDataVec&& other) noexcept {
        if (this != &other) {
            AzCoreCallbackDataVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CoreCallbackDataVec() { AzCoreCallbackDataVec_delete(&inner_); }

    static CoreCallbackDataVec create();
    static CoreCallbackDataVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionCoreCallbackData get(size_t index) const;
    static CoreCallbackDataVec from_item(CoreCallbackData item);
    static CoreCallbackDataVec copy_from_ptr(const CoreCallbackData& ptr, size_t len);
    OptionCoreCallbackData c_get(size_t index) const;
    CoreCallbackDataVecSlice as_c_slice() const;
    CoreCallbackDataVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    CoreCallbackDataVec clone() const;
    bool partialEq(const CoreCallbackDataVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CoreCallbackDataVec& b) const;
    uint8_t cmp(const CoreCallbackDataVec& b) const;
    String toDbgString() const;

    const AzCoreCallbackDataVec& inner() const { return inner_; }
    AzCoreCallbackDataVec& inner() { return inner_; }
    const AzCoreCallbackDataVec* ptr() const { return &inner_; }
    AzCoreCallbackDataVec* ptr() { return &inner_; }
    AzCoreCallbackDataVec release() { AzCoreCallbackDataVec result = inner_; inner_ = {}; return result; }
    operator AzCoreCallbackDataVec() && noexcept { AzCoreCallbackDataVec result = inner_; inner_ = {}; return result; }
};

class AccessibilityActionVec {
private:
    AzAccessibilityActionVec inner_;

    AccessibilityActionVec(const AccessibilityActionVec&) = delete;
    AccessibilityActionVec& operator=(const AccessibilityActionVec&) = delete;

public:
    explicit AccessibilityActionVec(AzAccessibilityActionVec inner) noexcept : inner_(inner) {}

    AccessibilityActionVec(AccessibilityActionVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    AccessibilityActionVec& operator=(AccessibilityActionVec&& other) noexcept {
        if (this != &other) {
            AzAccessibilityActionVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~AccessibilityActionVec() { AzAccessibilityActionVec_delete(&inner_); }

    static AccessibilityActionVec create();
    static AccessibilityActionVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionAccessibilityAction get(size_t index) const;
    static AccessibilityActionVec from_item(AzAccessibilityAction item);
    static AccessibilityActionVec copy_from_ptr(const AzAccessibilityAction* ptr, size_t len);
    OptionAccessibilityAction c_get(size_t index) const;
    AccessibilityActionVecSlice as_c_slice() const;
    AccessibilityActionVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    AccessibilityActionVec clone() const;
    bool partialEq(const AccessibilityActionVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const AccessibilityActionVec& b) const;
    uint8_t cmp(const AccessibilityActionVec& b) const;
    String toDbgString() const;

    const AzAccessibilityActionVec& inner() const { return inner_; }
    AzAccessibilityActionVec& inner() { return inner_; }
    const AzAccessibilityActionVec* ptr() const { return &inner_; }
    AzAccessibilityActionVec* ptr() { return &inner_; }
    AzAccessibilityActionVec release() { AzAccessibilityActionVec result = inner_; inner_ = {}; return result; }
    operator AzAccessibilityActionVec() && noexcept { AzAccessibilityActionVec result = inner_; inner_ = {}; return result; }
};

class GridTrackSizingVec {
private:
    AzGridTrackSizingVec inner_;

    GridTrackSizingVec(const GridTrackSizingVec&) = delete;
    GridTrackSizingVec& operator=(const GridTrackSizingVec&) = delete;

public:
    explicit GridTrackSizingVec(AzGridTrackSizingVec inner) noexcept : inner_(inner) {}

    GridTrackSizingVec(GridTrackSizingVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GridTrackSizingVec& operator=(GridTrackSizingVec&& other) noexcept {
        if (this != &other) {
            AzGridTrackSizingVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GridTrackSizingVec() { AzGridTrackSizingVec_delete(&inner_); }

    static GridTrackSizingVec create();
    static GridTrackSizingVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionGridTrackSizing get(size_t index) const;
    static GridTrackSizingVec from_item(AzGridTrackSizing item);
    static GridTrackSizingVec copy_from_ptr(const AzGridTrackSizing* ptr, size_t len);
    OptionGridTrackSizing c_get(size_t index) const;
    GridTrackSizingVecSlice as_c_slice() const;
    GridTrackSizingVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    GridTrackSizingVec clone() const;
    bool partialEq(const GridTrackSizingVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GridTrackSizingVec& b) const;
    uint8_t cmp(const GridTrackSizingVec& b) const;
    String toDbgString() const;

    const AzGridTrackSizingVec& inner() const { return inner_; }
    AzGridTrackSizingVec& inner() { return inner_; }
    const AzGridTrackSizingVec* ptr() const { return &inner_; }
    AzGridTrackSizingVec* ptr() { return &inner_; }
    AzGridTrackSizingVec release() { AzGridTrackSizingVec result = inner_; inner_ = {}; return result; }
    operator AzGridTrackSizingVec() && noexcept { AzGridTrackSizingVec result = inner_; inner_ = {}; return result; }
};

class VertexAttributeVec {
private:
    AzVertexAttributeVec inner_;

    VertexAttributeVec(const VertexAttributeVec&) = delete;
    VertexAttributeVec& operator=(const VertexAttributeVec&) = delete;

public:
    explicit VertexAttributeVec(AzVertexAttributeVec inner) noexcept : inner_(inner) {}

    VertexAttributeVec(VertexAttributeVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VertexAttributeVec& operator=(VertexAttributeVec&& other) noexcept {
        if (this != &other) {
            AzVertexAttributeVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VertexAttributeVec() { AzVertexAttributeVec_delete(&inner_); }

    static VertexAttributeVec create();
    static VertexAttributeVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionVertexAttribute get(size_t index) const;
    static VertexAttributeVec from_item(VertexAttribute item);
    static VertexAttributeVec copy_from_ptr(const VertexAttribute& ptr, size_t len);
    OptionVertexAttribute c_get(size_t index) const;
    VertexAttributeVecSlice as_c_slice() const;
    VertexAttributeVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    VertexAttributeVec clone() const;
    bool partialEq(const VertexAttributeVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const VertexAttributeVec& b) const;
    uint8_t cmp(const VertexAttributeVec& b) const;
    String toDbgString() const;

    const AzVertexAttributeVec& inner() const { return inner_; }
    AzVertexAttributeVec& inner() { return inner_; }
    const AzVertexAttributeVec* ptr() const { return &inner_; }
    AzVertexAttributeVec* ptr() { return &inner_; }
    AzVertexAttributeVec release() { AzVertexAttributeVec result = inner_; inner_ = {}; return result; }
    operator AzVertexAttributeVec() && noexcept { AzVertexAttributeVec result = inner_; inner_ = {}; return result; }
};

class DebugMessageVec {
private:
    AzDebugMessageVec inner_;

    DebugMessageVec(const DebugMessageVec&) = delete;
    DebugMessageVec& operator=(const DebugMessageVec&) = delete;

public:
    explicit DebugMessageVec(AzDebugMessageVec inner) noexcept : inner_(inner) {}

    DebugMessageVec(DebugMessageVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DebugMessageVec& operator=(DebugMessageVec&& other) noexcept {
        if (this != &other) {
            AzDebugMessageVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DebugMessageVec() { AzDebugMessageVec_delete(&inner_); }

    static DebugMessageVec create();
    static DebugMessageVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionDebugMessage get(size_t index) const;
    static DebugMessageVec from_item(DebugMessage item);
    static DebugMessageVec copy_from_ptr(const DebugMessage& ptr, size_t len);
    OptionDebugMessage c_get(size_t index) const;
    DebugMessageVecSlice as_c_slice() const;
    DebugMessageVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    DebugMessageVec clone() const;
    bool partialEq(const DebugMessageVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const DebugMessageVec& b) const;
    uint8_t cmp(const DebugMessageVec& b) const;
    String toDbgString() const;

    const AzDebugMessageVec& inner() const { return inner_; }
    AzDebugMessageVec& inner() { return inner_; }
    const AzDebugMessageVec* ptr() const { return &inner_; }
    AzDebugMessageVec* ptr() { return &inner_; }
    AzDebugMessageVec release() { AzDebugMessageVec result = inner_; inner_ = {}; return result; }
    operator AzDebugMessageVec() && noexcept { AzDebugMessageVec result = inner_; inner_ = {}; return result; }
};

class ShapePointVec {
private:
    AzShapePointVec inner_;

    ShapePointVec(const ShapePointVec&) = delete;
    ShapePointVec& operator=(const ShapePointVec&) = delete;

public:
    explicit ShapePointVec(AzShapePointVec inner) noexcept : inner_(inner) {}

    ShapePointVec(ShapePointVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ShapePointVec& operator=(ShapePointVec&& other) noexcept {
        if (this != &other) {
            AzShapePointVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ShapePointVec() { AzShapePointVec_delete(&inner_); }

    static ShapePointVec create();
    static ShapePointVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionShapePoint get(size_t index) const;
    static ShapePointVec from_item(ShapePoint item);
    static ShapePointVec copy_from_ptr(const ShapePoint& ptr, size_t len);
    OptionShapePoint c_get(size_t index) const;
    ShapePointVecSlice as_c_slice() const;
    ShapePointVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ShapePointVec clone() const;
    bool partialEq(const ShapePointVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ShapePointVec& b) const;
    uint8_t cmp(const ShapePointVec& b) const;
    String toDbgString() const;

    const AzShapePointVec& inner() const { return inner_; }
    AzShapePointVec& inner() { return inner_; }
    const AzShapePointVec* ptr() const { return &inner_; }
    AzShapePointVec* ptr() { return &inner_; }
    AzShapePointVec release() { AzShapePointVec result = inner_; inner_ = {}; return result; }
    operator AzShapePointVec() && noexcept { AzShapePointVec result = inner_; inner_ = {}; return result; }
};

class MonitorVec {
private:
    AzMonitorVec inner_;

    MonitorVec(const MonitorVec&) = delete;
    MonitorVec& operator=(const MonitorVec&) = delete;

public:
    explicit MonitorVec(AzMonitorVec inner) noexcept : inner_(inner) {}

    MonitorVec(MonitorVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MonitorVec& operator=(MonitorVec&& other) noexcept {
        if (this != &other) {
            AzMonitorVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MonitorVec() { AzMonitorVec_delete(&inner_); }

    static MonitorVec create();
    static MonitorVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionMonitor get(size_t index) const;
    static MonitorVec from_item(Monitor item);
    static MonitorVec copy_from_ptr(const Monitor& ptr, size_t len);
    OptionMonitor c_get(size_t index) const;
    MonitorVecSlice as_c_slice() const;
    MonitorVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    MonitorVec clone() const;
    bool partialEq(const MonitorVec& b) const;
    uint8_t partialCmp(const MonitorVec& b) const;
    String toDbgString() const;

    const AzMonitorVec& inner() const { return inner_; }
    AzMonitorVec& inner() { return inner_; }
    const AzMonitorVec* ptr() const { return &inner_; }
    AzMonitorVec* ptr() { return &inner_; }
    AzMonitorVec release() { AzMonitorVec result = inner_; inner_ = {}; return result; }
    operator AzMonitorVec() && noexcept { AzMonitorVec result = inner_; inner_ = {}; return result; }
};

class VideoModeVec {
private:
    AzVideoModeVec inner_;

    VideoModeVec(const VideoModeVec&) = delete;
    VideoModeVec& operator=(const VideoModeVec&) = delete;

public:
    explicit VideoModeVec(AzVideoModeVec inner) noexcept : inner_(inner) {}

    VideoModeVec(VideoModeVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VideoModeVec& operator=(VideoModeVec&& other) noexcept {
        if (this != &other) {
            AzVideoModeVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VideoModeVec() { AzVideoModeVec_delete(&inner_); }

    static VideoModeVec create();
    static VideoModeVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionVideoMode get(size_t index) const;
    static VideoModeVec from_item(VideoMode item);
    static VideoModeVec copy_from_ptr(const VideoMode& ptr, size_t len);
    OptionVideoMode c_get(size_t index) const;
    VideoModeVecSlice as_c_slice() const;
    VideoModeVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    VideoModeVec clone() const;
    bool partialEq(const VideoModeVec& b) const;
    uint8_t partialCmp(const VideoModeVec& b) const;
    String toDbgString() const;

    const AzVideoModeVec& inner() const { return inner_; }
    AzVideoModeVec& inner() { return inner_; }
    const AzVideoModeVec* ptr() const { return &inner_; }
    AzVideoModeVec* ptr() { return &inner_; }
    AzVideoModeVec release() { AzVideoModeVec result = inner_; inner_ = {}; return result; }
    operator AzVideoModeVec() && noexcept { AzVideoModeVec result = inner_; inner_ = {}; return result; }
};

class XWindowTypeVec {
private:
    AzXWindowTypeVec inner_;

    XWindowTypeVec(const XWindowTypeVec&) = delete;
    XWindowTypeVec& operator=(const XWindowTypeVec&) = delete;

public:
    explicit XWindowTypeVec(AzXWindowTypeVec inner) noexcept : inner_(inner) {}

    XWindowTypeVec(XWindowTypeVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    XWindowTypeVec& operator=(XWindowTypeVec&& other) noexcept {
        if (this != &other) {
            AzXWindowTypeVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~XWindowTypeVec() { AzXWindowTypeVec_delete(&inner_); }

    static XWindowTypeVec create();
    static XWindowTypeVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionXWindowType get(size_t index) const;
    static XWindowTypeVec from_item(AzXWindowType item);
    static XWindowTypeVec copy_from_ptr(const AzXWindowType* ptr, size_t len);
    OptionXWindowType c_get(size_t index) const;
    XWindowTypeVecSlice as_c_slice() const;
    XWindowTypeVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    XWindowTypeVec clone() const;
    bool partialEq(const XWindowTypeVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const XWindowTypeVec& b) const;
    uint8_t cmp(const XWindowTypeVec& b) const;
    String toDbgString() const;

    const AzXWindowTypeVec& inner() const { return inner_; }
    AzXWindowTypeVec& inner() { return inner_; }
    const AzXWindowTypeVec* ptr() const { return &inner_; }
    AzXWindowTypeVec* ptr() { return &inner_; }
    AzXWindowTypeVec release() { AzXWindowTypeVec result = inner_; inner_ = {}; return result; }
    operator AzXWindowTypeVec() && noexcept { AzXWindowTypeVec result = inner_; inner_ = {}; return result; }
};

class ScanCodeVec {
private:
    AzScanCodeVec inner_;

    ScanCodeVec(const ScanCodeVec&) = delete;
    ScanCodeVec& operator=(const ScanCodeVec&) = delete;

public:
    explicit ScanCodeVec(AzScanCodeVec inner) noexcept : inner_(inner) {}

    ScanCodeVec(ScanCodeVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ScanCodeVec& operator=(ScanCodeVec&& other) noexcept {
        if (this != &other) {
            AzScanCodeVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ScanCodeVec() { AzScanCodeVec_delete(&inner_); }

    static ScanCodeVec create();
    static ScanCodeVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionU32 get(size_t index) const;
    static ScanCodeVec from_item(AzScanCode item);
    static ScanCodeVec copy_from_ptr(const AzScanCode* ptr, size_t len);
    OptionU32 c_get(size_t index) const;
    ScanCodeVecSlice as_c_slice() const;
    ScanCodeVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ScanCodeVec clone() const;
    bool partialEq(const ScanCodeVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ScanCodeVec& b) const;
    uint8_t cmp(const ScanCodeVec& b) const;
    String toDbgString() const;

    const AzScanCodeVec& inner() const { return inner_; }
    AzScanCodeVec& inner() { return inner_; }
    const AzScanCodeVec* ptr() const { return &inner_; }
    AzScanCodeVec* ptr() { return &inner_; }
    AzScanCodeVec release() { AzScanCodeVec result = inner_; inner_ = {}; return result; }
    operator AzScanCodeVec() && noexcept { AzScanCodeVec result = inner_; inner_ = {}; return result; }
};

class ContentGroupVec {
private:
    AzContentGroupVec inner_;

    ContentGroupVec(const ContentGroupVec&) = delete;
    ContentGroupVec& operator=(const ContentGroupVec&) = delete;

public:
    explicit ContentGroupVec(AzContentGroupVec inner) noexcept : inner_(inner) {}

    ContentGroupVec(ContentGroupVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ContentGroupVec& operator=(ContentGroupVec&& other) noexcept {
        if (this != &other) {
            AzContentGroupVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ContentGroupVec() { AzContentGroupVec_delete(&inner_); }

    static ContentGroupVec create();
    static ContentGroupVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionContentGroup get(size_t index) const;
    static ContentGroupVec from_item(ContentGroup item);
    static ContentGroupVec copy_from_ptr(const ContentGroup& ptr, size_t len);
    OptionContentGroup c_get(size_t index) const;
    ContentGroupVecSlice as_c_slice() const;
    ContentGroupVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ContentGroupVec clone() const;
    bool partialEq(const ContentGroupVec& b) const;
    uint8_t partialCmp(const ContentGroupVec& b) const;
    String toDbgString() const;

    const AzContentGroupVec& inner() const { return inner_; }
    AzContentGroupVec& inner() { return inner_; }
    const AzContentGroupVec* ptr() const { return &inner_; }
    AzContentGroupVec* ptr() { return &inner_; }
    AzContentGroupVec release() { AzContentGroupVec result = inner_; inner_ = {}; return result; }
    operator AzContentGroupVec() && noexcept { AzContentGroupVec result = inner_; inner_ = {}; return result; }
};

class StyledNodeVec {
private:
    AzStyledNodeVec inner_;

    StyledNodeVec(const StyledNodeVec&) = delete;
    StyledNodeVec& operator=(const StyledNodeVec&) = delete;

public:
    explicit StyledNodeVec(AzStyledNodeVec inner) noexcept : inner_(inner) {}

    StyledNodeVec(StyledNodeVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyledNodeVec& operator=(StyledNodeVec&& other) noexcept {
        if (this != &other) {
            AzStyledNodeVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyledNodeVec() { AzStyledNodeVec_delete(&inner_); }

    static StyledNodeVec create();
    static StyledNodeVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionStyledNode get(size_t index) const;
    static StyledNodeVec from_item(StyledNode item);
    static StyledNodeVec copy_from_ptr(const StyledNode& ptr, size_t len);
    OptionStyledNode c_get(size_t index) const;
    StyledNodeVecSlice as_c_slice() const;
    StyledNodeVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    StyledNodeVec clone() const;
    bool partialEq(const StyledNodeVec& b) const;
    uint8_t partialCmp(const StyledNodeVec& b) const;
    String toDbgString() const;

    const AzStyledNodeVec& inner() const { return inner_; }
    AzStyledNodeVec& inner() { return inner_; }
    const AzStyledNodeVec* ptr() const { return &inner_; }
    AzStyledNodeVec* ptr() { return &inner_; }
    AzStyledNodeVec release() { AzStyledNodeVec result = inner_; inner_ = {}; return result; }
    operator AzStyledNodeVec() && noexcept { AzStyledNodeVec result = inner_; inner_ = {}; return result; }
};

class DomIdVec {
private:
    AzDomIdVec inner_;

    DomIdVec(const DomIdVec&) = delete;
    DomIdVec& operator=(const DomIdVec&) = delete;

public:
    explicit DomIdVec(AzDomIdVec inner) noexcept : inner_(inner) {}

    DomIdVec(DomIdVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DomIdVec& operator=(DomIdVec&& other) noexcept {
        if (this != &other) {
            AzDomIdVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DomIdVec() { AzDomIdVec_delete(&inner_); }

    static DomIdVec create();
    static DomIdVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionDomId get(size_t index) const;
    static DomIdVec from_item(DomId item);
    static DomIdVec copy_from_ptr(const DomId& ptr, size_t len);
    OptionDomId c_get(size_t index) const;
    DomIdVecSlice as_c_slice() const;
    DomIdVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    DomIdVec clone() const;
    bool partialEq(const DomIdVec& b) const;
    uint8_t partialCmp(const DomIdVec& b) const;
    String toDbgString() const;

    const AzDomIdVec& inner() const { return inner_; }
    AzDomIdVec& inner() { return inner_; }
    const AzDomIdVec* ptr() const { return &inner_; }
    AzDomIdVec* ptr() { return &inner_; }
    AzDomIdVec release() { AzDomIdVec result = inner_; inner_ = {}; return result; }
    operator AzDomIdVec() && noexcept { AzDomIdVec result = inner_; inner_ = {}; return result; }
};

class TimerIdVec {
private:
    AzTimerIdVec inner_;

    TimerIdVec(const TimerIdVec&) = delete;
    TimerIdVec& operator=(const TimerIdVec&) = delete;

public:
    explicit TimerIdVec(AzTimerIdVec inner) noexcept : inner_(inner) {}

    TimerIdVec(TimerIdVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TimerIdVec& operator=(TimerIdVec&& other) noexcept {
        if (this != &other) {
            AzTimerIdVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TimerIdVec() { AzTimerIdVec_delete(&inner_); }

    static TimerIdVec create();
    static TimerIdVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionTimerId get(size_t index) const;
    static TimerIdVec from_item(TimerId item);
    static TimerIdVec copy_from_ptr(const TimerId& ptr, size_t len);
    OptionTimerId c_get(size_t index) const;
    TimerIdVecSlice as_c_slice() const;
    TimerIdVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    TimerIdVec clone() const;
    bool partialEq(const TimerIdVec& b) const;
    uint8_t partialCmp(const TimerIdVec& b) const;
    String toDbgString() const;

    const AzTimerIdVec& inner() const { return inner_; }
    AzTimerIdVec& inner() { return inner_; }
    const AzTimerIdVec* ptr() const { return &inner_; }
    AzTimerIdVec* ptr() { return &inner_; }
    AzTimerIdVec release() { AzTimerIdVec result = inner_; inner_ = {}; return result; }
    operator AzTimerIdVec() && noexcept { AzTimerIdVec result = inner_; inner_ = {}; return result; }
};

class SelectionRangeVec {
private:
    AzSelectionRangeVec inner_;

    SelectionRangeVec(const SelectionRangeVec&) = delete;
    SelectionRangeVec& operator=(const SelectionRangeVec&) = delete;

public:
    explicit SelectionRangeVec(AzSelectionRangeVec inner) noexcept : inner_(inner) {}

    SelectionRangeVec(SelectionRangeVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SelectionRangeVec& operator=(SelectionRangeVec&& other) noexcept {
        if (this != &other) {
            AzSelectionRangeVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SelectionRangeVec() { AzSelectionRangeVec_delete(&inner_); }

    static SelectionRangeVec create();
    static SelectionRangeVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionSelectionRange get(size_t index) const;
    static SelectionRangeVec from_item(SelectionRange item);
    static SelectionRangeVec copy_from_ptr(const SelectionRange& ptr, size_t len);
    OptionSelectionRange c_get(size_t index) const;
    SelectionRangeVecSlice as_c_slice() const;
    SelectionRangeVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    SelectionRangeVec clone() const;
    bool partialEq(const SelectionRangeVec& b) const;
    uint8_t partialCmp(const SelectionRangeVec& b) const;
    String toDbgString() const;

    const AzSelectionRangeVec& inner() const { return inner_; }
    AzSelectionRangeVec& inner() { return inner_; }
    const AzSelectionRangeVec* ptr() const { return &inner_; }
    AzSelectionRangeVec* ptr() { return &inner_; }
    AzSelectionRangeVec release() { AzSelectionRangeVec result = inner_; inner_ = {}; return result; }
    operator AzSelectionRangeVec() && noexcept { AzSelectionRangeVec result = inner_; inner_ = {}; return result; }
};

class ThreadIdVec {
private:
    AzThreadIdVec inner_;

    ThreadIdVec(const ThreadIdVec&) = delete;
    ThreadIdVec& operator=(const ThreadIdVec&) = delete;

public:
    explicit ThreadIdVec(AzThreadIdVec inner) noexcept : inner_(inner) {}

    ThreadIdVec(ThreadIdVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ThreadIdVec& operator=(ThreadIdVec&& other) noexcept {
        if (this != &other) {
            AzThreadIdVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ThreadIdVec() { AzThreadIdVec_delete(&inner_); }

    static ThreadIdVec create();
    static ThreadIdVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionThreadId get(size_t index) const;
    static ThreadIdVec from_item(ThreadId item);
    static ThreadIdVec copy_from_ptr(const ThreadId& ptr, size_t len);
    OptionThreadId c_get(size_t index) const;
    ThreadIdVecSlice as_c_slice() const;
    ThreadIdVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ThreadIdVec clone() const;
    bool partialEq(const ThreadIdVec& b) const;
    uint8_t partialCmp(const ThreadIdVec& b) const;
    String toDbgString() const;

    const AzThreadIdVec& inner() const { return inner_; }
    AzThreadIdVec& inner() { return inner_; }
    const AzThreadIdVec* ptr() const { return &inner_; }
    AzThreadIdVec* ptr() { return &inner_; }
    AzThreadIdVec release() { AzThreadIdVec result = inner_; inner_ = {}; return result; }
    operator AzThreadIdVec() && noexcept { AzThreadIdVec result = inner_; inner_ = {}; return result; }
};

class StyledTextRunVec {
private:
    AzStyledTextRunVec inner_;

    StyledTextRunVec(const StyledTextRunVec&) = delete;
    StyledTextRunVec& operator=(const StyledTextRunVec&) = delete;

public:
    explicit StyledTextRunVec(AzStyledTextRunVec inner) noexcept : inner_(inner) {}

    StyledTextRunVec(StyledTextRunVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyledTextRunVec& operator=(StyledTextRunVec&& other) noexcept {
        if (this != &other) {
            AzStyledTextRunVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyledTextRunVec() { AzStyledTextRunVec_delete(&inner_); }

    static StyledTextRunVec create();
    static StyledTextRunVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionStyledTextRun get(size_t index) const;
    static StyledTextRunVec from_item(StyledTextRun item);
    static StyledTextRunVec copy_from_ptr(const StyledTextRun& ptr, size_t len);
    OptionStyledTextRun c_get(size_t index) const;
    StyledTextRunVecSlice as_c_slice() const;
    StyledTextRunVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    StyledTextRunVec clone() const;
    bool partialEq(const StyledTextRunVec& b) const;
    String toDbgString() const;

    const AzStyledTextRunVec& inner() const { return inner_; }
    AzStyledTextRunVec& inner() { return inner_; }
    const AzStyledTextRunVec* ptr() const { return &inner_; }
    AzStyledTextRunVec* ptr() { return &inner_; }
    AzStyledTextRunVec release() { AzStyledTextRunVec result = inner_; inner_ = {}; return result; }
    operator AzStyledTextRunVec() && noexcept { AzStyledTextRunVec result = inner_; inner_ = {}; return result; }
};

class SelectionVec {
private:
    AzSelectionVec inner_;

    SelectionVec(const SelectionVec&) = delete;
    SelectionVec& operator=(const SelectionVec&) = delete;

public:
    explicit SelectionVec(AzSelectionVec inner) noexcept : inner_(inner) {}

    SelectionVec(SelectionVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SelectionVec& operator=(SelectionVec&& other) noexcept {
        if (this != &other) {
            AzSelectionVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SelectionVec() { AzSelectionVec_delete(&inner_); }

    static SelectionVec create();
    static SelectionVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionSelection get(size_t index) const;
    static SelectionVec from_item(AzSelection item);
    static SelectionVec copy_from_ptr(const AzSelection* ptr, size_t len);
    OptionSelection c_get(size_t index) const;
    SelectionVecSlice as_c_slice() const;
    SelectionVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    SelectionVec clone() const;
    bool partialEq(const SelectionVec& b) const;
    uint8_t partialCmp(const SelectionVec& b) const;
    String toDbgString() const;

    const AzSelectionVec& inner() const { return inner_; }
    AzSelectionVec& inner() { return inner_; }
    const AzSelectionVec* ptr() const { return &inner_; }
    AzSelectionVec* ptr() { return &inner_; }
    AzSelectionVec release() { AzSelectionVec result = inner_; inner_ = {}; return result; }
    operator AzSelectionVec() && noexcept { AzSelectionVec result = inner_; inner_ = {}; return result; }
};

class HttpHeaderVec {
private:
    AzHttpHeaderVec inner_;

    HttpHeaderVec(const HttpHeaderVec&) = delete;
    HttpHeaderVec& operator=(const HttpHeaderVec&) = delete;

public:
    explicit HttpHeaderVec(AzHttpHeaderVec inner) noexcept : inner_(inner) {}

    HttpHeaderVec(HttpHeaderVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    HttpHeaderVec& operator=(HttpHeaderVec&& other) noexcept {
        if (this != &other) {
            AzHttpHeaderVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~HttpHeaderVec() { AzHttpHeaderVec_delete(&inner_); }

    static HttpHeaderVec create();
    static HttpHeaderVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionHttpHeader get(size_t index) const;
    static HttpHeaderVec from_item(HttpHeader item);
    static HttpHeaderVec copy_from_ptr(const HttpHeader& ptr, size_t len);
    OptionHttpHeader c_get(size_t index) const;
    HttpHeaderVecSlice as_c_slice() const;
    HttpHeaderVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    HttpHeaderVec clone() const;
    bool partialEq(const HttpHeaderVec& b) const;
    String toDbgString() const;

    const AzHttpHeaderVec& inner() const { return inner_; }
    AzHttpHeaderVec& inner() { return inner_; }
    const AzHttpHeaderVec* ptr() const { return &inner_; }
    AzHttpHeaderVec* ptr() { return &inner_; }
    AzHttpHeaderVec release() { AzHttpHeaderVec result = inner_; inner_ = {}; return result; }
    operator AzHttpHeaderVec() && noexcept { AzHttpHeaderVec result = inner_; inner_ = {}; return result; }
};

class FmtArgVec {
private:
    AzFmtArgVec inner_;

    FmtArgVec(const FmtArgVec&) = delete;
    FmtArgVec& operator=(const FmtArgVec&) = delete;

public:
    explicit FmtArgVec(AzFmtArgVec inner) noexcept : inner_(inner) {}

    FmtArgVec(FmtArgVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FmtArgVec& operator=(FmtArgVec&& other) noexcept {
        if (this != &other) {
            AzFmtArgVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FmtArgVec() { AzFmtArgVec_delete(&inner_); }

    static FmtArgVec create();
    static FmtArgVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionFmtArg get(size_t index) const;
    static FmtArgVec from_item(FmtArg item);
    static FmtArgVec copy_from_ptr(const FmtArg& ptr, size_t len);
    OptionFmtArg c_get(size_t index) const;
    FmtArgVecSlice as_c_slice() const;
    FmtArgVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    FmtArgVec clone() const;
    bool partialEq(const FmtArgVec& b) const;
    uint8_t partialCmp(const FmtArgVec& b) const;
    String toDbgString() const;

    const AzFmtArgVec& inner() const { return inner_; }
    AzFmtArgVec& inner() { return inner_; }
    const AzFmtArgVec* ptr() const { return &inner_; }
    AzFmtArgVec* ptr() { return &inner_; }
    AzFmtArgVec release() { AzFmtArgVec result = inner_; inner_ = {}; return result; }
    operator AzFmtArgVec() && noexcept { AzFmtArgVec result = inner_; inner_ = {}; return result; }
};

class JsonVec {
private:
    AzJsonVec inner_;

    JsonVec(const JsonVec&) = delete;
    JsonVec& operator=(const JsonVec&) = delete;

public:
    explicit JsonVec(AzJsonVec inner) noexcept : inner_(inner) {}

    JsonVec(JsonVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    JsonVec& operator=(JsonVec&& other) noexcept {
        if (this != &other) {
            AzJsonVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~JsonVec() { AzJsonVec_delete(&inner_); }

    [[nodiscard]] static JsonVec copy_from_array(const Json& ptr, size_t len);

    static JsonVec create();
    static JsonVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionJson get(size_t index) const;
    static JsonVec from_item(Json item);
    static JsonVec copy_from_ptr(const Json& ptr, size_t len);
    OptionJson c_get(size_t index) const;
    JsonVecSlice as_c_slice() const;
    JsonVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    JsonVec clone() const;
    bool partialEq(const JsonVec& b) const;
    String toDbgString() const;

    const AzJsonVec& inner() const { return inner_; }
    AzJsonVec& inner() { return inner_; }
    const AzJsonVec* ptr() const { return &inner_; }
    AzJsonVec* ptr() { return &inner_; }
    AzJsonVec release() { AzJsonVec result = inner_; inner_ = {}; return result; }
    operator AzJsonVec() && noexcept { AzJsonVec result = inner_; inner_ = {}; return result; }
};

class DirEntryVec {
private:
    AzDirEntryVec inner_;

    DirEntryVec(const DirEntryVec&) = delete;
    DirEntryVec& operator=(const DirEntryVec&) = delete;

public:
    explicit DirEntryVec(AzDirEntryVec inner) noexcept : inner_(inner) {}

    DirEntryVec(DirEntryVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DirEntryVec& operator=(DirEntryVec&& other) noexcept {
        if (this != &other) {
            AzDirEntryVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DirEntryVec() { AzDirEntryVec_delete(&inner_); }

    static DirEntryVec create();
    static DirEntryVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionDirEntry get(size_t index) const;
    static DirEntryVec from_item(DirEntry item);
    static DirEntryVec copy_from_ptr(const DirEntry& ptr, size_t len);
    OptionDirEntry c_get(size_t index) const;
    DirEntryVecSlice as_c_slice() const;
    DirEntryVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    DirEntryVec clone() const;
    String toDbgString() const;

    const AzDirEntryVec& inner() const { return inner_; }
    AzDirEntryVec& inner() { return inner_; }
    const AzDirEntryVec* ptr() const { return &inner_; }
    AzDirEntryVec* ptr() { return &inner_; }
    AzDirEntryVec release() { AzDirEntryVec result = inner_; inner_ = {}; return result; }
    operator AzDirEntryVec() && noexcept { AzDirEntryVec result = inner_; inner_ = {}; return result; }
};

class JsonKeyValueVec {
private:
    AzJsonKeyValueVec inner_;

    JsonKeyValueVec(const JsonKeyValueVec&) = delete;
    JsonKeyValueVec& operator=(const JsonKeyValueVec&) = delete;

public:
    explicit JsonKeyValueVec(AzJsonKeyValueVec inner) noexcept : inner_(inner) {}

    JsonKeyValueVec(JsonKeyValueVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    JsonKeyValueVec& operator=(JsonKeyValueVec&& other) noexcept {
        if (this != &other) {
            AzJsonKeyValueVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~JsonKeyValueVec() { AzJsonKeyValueVec_delete(&inner_); }

    [[nodiscard]] static JsonKeyValueVec copy_from_array(const JsonKeyValue& ptr, size_t len);

    static JsonKeyValueVec create();
    static JsonKeyValueVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionJsonKeyValue get(size_t index) const;
    static JsonKeyValueVec from_item(JsonKeyValue item);
    static JsonKeyValueVec copy_from_ptr(const JsonKeyValue& ptr, size_t len);
    OptionJsonKeyValue c_get(size_t index) const;
    JsonKeyValueVecSlice as_c_slice() const;
    JsonKeyValueVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    JsonKeyValueVec clone() const;
    String toDbgString() const;

    const AzJsonKeyValueVec& inner() const { return inner_; }
    AzJsonKeyValueVec& inner() { return inner_; }
    const AzJsonKeyValueVec* ptr() const { return &inner_; }
    AzJsonKeyValueVec* ptr() { return &inner_; }
    AzJsonKeyValueVec release() { AzJsonKeyValueVec result = inner_; inner_ = {}; return result; }
    operator AzJsonKeyValueVec() && noexcept { AzJsonKeyValueVec result = inner_; inner_ = {}; return result; }
};

class NamedFontVec {
private:
    AzNamedFontVec inner_;

    NamedFontVec(const NamedFontVec&) = delete;
    NamedFontVec& operator=(const NamedFontVec&) = delete;

public:
    explicit NamedFontVec(AzNamedFontVec inner) noexcept : inner_(inner) {}

    NamedFontVec(NamedFontVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NamedFontVec& operator=(NamedFontVec&& other) noexcept {
        if (this != &other) {
            AzNamedFontVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NamedFontVec() { AzNamedFontVec_delete(&inner_); }

    static NamedFontVec create();
    static NamedFontVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionNamedFont get(size_t index) const;
    static NamedFontVec from_item(NamedFont item);
    static NamedFontVec copy_from_ptr(const NamedFont& ptr, size_t len);
    OptionNamedFont c_get(size_t index) const;
    NamedFontVecSlice as_c_slice() const;
    NamedFontVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    NamedFontVec clone() const;
    bool partialEq(const NamedFontVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NamedFontVec& b) const;
    uint8_t cmp(const NamedFontVec& b) const;
    String toDbgString() const;

    const AzNamedFontVec& inner() const { return inner_; }
    AzNamedFontVec& inner() { return inner_; }
    const AzNamedFontVec* ptr() const { return &inner_; }
    AzNamedFontVec* ptr() { return &inner_; }
    AzNamedFontVec release() { AzNamedFontVec result = inner_; inner_ = {}; return result; }
    operator AzNamedFontVec() && noexcept { AzNamedFontVec result = inner_; inner_ = {}; return result; }
};

class ExternalResourceVec {
private:
    AzExternalResourceVec inner_;

    ExternalResourceVec(const ExternalResourceVec&) = delete;
    ExternalResourceVec& operator=(const ExternalResourceVec&) = delete;

public:
    explicit ExternalResourceVec(AzExternalResourceVec inner) noexcept : inner_(inner) {}

    ExternalResourceVec(ExternalResourceVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ExternalResourceVec& operator=(ExternalResourceVec&& other) noexcept {
        if (this != &other) {
            AzExternalResourceVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ExternalResourceVec() { AzExternalResourceVec_delete(&inner_); }

    static ExternalResourceVec create();
    static ExternalResourceVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionExternalResource get(size_t index) const;
    static ExternalResourceVec from_item(ExternalResource item);
    static ExternalResourceVec copy_from_ptr(const ExternalResource& ptr, size_t len);
    OptionExternalResource c_get(size_t index) const;
    ExternalResourceVecSlice as_c_slice() const;
    ExternalResourceVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ExternalResourceVec clone() const;
    bool partialEq(const ExternalResourceVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ExternalResourceVec& b) const;
    uint8_t cmp(const ExternalResourceVec& b) const;
    String toDbgString() const;

    const AzExternalResourceVec& inner() const { return inner_; }
    AzExternalResourceVec& inner() { return inner_; }
    const AzExternalResourceVec* ptr() const { return &inner_; }
    AzExternalResourceVec* ptr() { return &inner_; }
    AzExternalResourceVec release() { AzExternalResourceVec result = inner_; inner_ = {}; return result; }
    operator AzExternalResourceVec() && noexcept { AzExternalResourceVec result = inner_; inner_ = {}; return result; }
};

class NodeHierarchyItemIdVec {
private:
    AzNodeHierarchyItemIdVec inner_;

    NodeHierarchyItemIdVec(const NodeHierarchyItemIdVec&) = delete;
    NodeHierarchyItemIdVec& operator=(const NodeHierarchyItemIdVec&) = delete;

public:
    explicit NodeHierarchyItemIdVec(AzNodeHierarchyItemIdVec inner) noexcept : inner_(inner) {}

    NodeHierarchyItemIdVec(NodeHierarchyItemIdVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NodeHierarchyItemIdVec& operator=(NodeHierarchyItemIdVec&& other) noexcept {
        if (this != &other) {
            AzNodeHierarchyItemIdVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NodeHierarchyItemIdVec() { AzNodeHierarchyItemIdVec_delete(&inner_); }

    static NodeHierarchyItemIdVec create();
    static NodeHierarchyItemIdVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static NodeHierarchyItemIdVec from_item(NodeHierarchyItemId item);
    static NodeHierarchyItemIdVec copy_from_ptr(const NodeHierarchyItemId& ptr, size_t len);
    OptionNodeHierarchyItemId c_get(size_t index) const;
    NodeHierarchyItemIdVecSlice as_c_slice() const;
    NodeHierarchyItemIdVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    NodeHierarchyItemIdVec clone() const;
    bool partialEq(const NodeHierarchyItemIdVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NodeHierarchyItemIdVec& b) const;
    uint8_t cmp(const NodeHierarchyItemIdVec& b) const;
    String toDbgString() const;

    const AzNodeHierarchyItemIdVec& inner() const { return inner_; }
    AzNodeHierarchyItemIdVec& inner() { return inner_; }
    const AzNodeHierarchyItemIdVec* ptr() const { return &inner_; }
    AzNodeHierarchyItemIdVec* ptr() { return &inner_; }
    AzNodeHierarchyItemIdVec release() { AzNodeHierarchyItemIdVec result = inner_; inner_ = {}; return result; }
    operator AzNodeHierarchyItemIdVec() && noexcept { AzNodeHierarchyItemIdVec result = inner_; inner_ = {}; return result; }
};

class CalcAstItemVec {
private:
    AzCalcAstItemVec inner_;

    CalcAstItemVec(const CalcAstItemVec&) = delete;
    CalcAstItemVec& operator=(const CalcAstItemVec&) = delete;

public:
    explicit CalcAstItemVec(AzCalcAstItemVec inner) noexcept : inner_(inner) {}

    CalcAstItemVec(CalcAstItemVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CalcAstItemVec& operator=(CalcAstItemVec&& other) noexcept {
        if (this != &other) {
            AzCalcAstItemVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CalcAstItemVec() { AzCalcAstItemVec_delete(&inner_); }

    static CalcAstItemVec create();
    static CalcAstItemVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static CalcAstItemVec from_item(AzCalcAstItem item);
    static CalcAstItemVec copy_from_ptr(const AzCalcAstItem* ptr, size_t len);
    OptionCalcAstItem c_get(size_t index) const;
    CalcAstItemVecSlice as_c_slice() const;
    CalcAstItemVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    CalcAstItemVec clone() const;
    bool partialEq(const CalcAstItemVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CalcAstItemVec& b) const;
    uint8_t cmp(const CalcAstItemVec& b) const;
    String toDbgString() const;

    const AzCalcAstItemVec& inner() const { return inner_; }
    AzCalcAstItemVec& inner() { return inner_; }
    const AzCalcAstItemVec* ptr() const { return &inner_; }
    AzCalcAstItemVec* ptr() { return &inner_; }
    AzCalcAstItemVec release() { AzCalcAstItemVec result = inner_; inner_ = {}; return result; }
    operator AzCalcAstItemVec() && noexcept { AzCalcAstItemVec result = inner_; inner_ = {}; return result; }
};

class GridAreaDefinitionVec {
private:
    AzGridAreaDefinitionVec inner_;

    GridAreaDefinitionVec(const GridAreaDefinitionVec&) = delete;
    GridAreaDefinitionVec& operator=(const GridAreaDefinitionVec&) = delete;

public:
    explicit GridAreaDefinitionVec(AzGridAreaDefinitionVec inner) noexcept : inner_(inner) {}

    GridAreaDefinitionVec(GridAreaDefinitionVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GridAreaDefinitionVec& operator=(GridAreaDefinitionVec&& other) noexcept {
        if (this != &other) {
            AzGridAreaDefinitionVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GridAreaDefinitionVec() { AzGridAreaDefinitionVec_delete(&inner_); }

    static GridAreaDefinitionVec create();
    static GridAreaDefinitionVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static GridAreaDefinitionVec from_item(GridAreaDefinition item);
    static GridAreaDefinitionVec copy_from_ptr(const GridAreaDefinition& ptr, size_t len);
    OptionGridAreaDefinition c_get(size_t index) const;
    GridAreaDefinitionVecSlice as_c_slice() const;
    GridAreaDefinitionVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    GridAreaDefinitionVec clone() const;
    bool partialEq(const GridAreaDefinitionVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GridAreaDefinitionVec& b) const;
    uint8_t cmp(const GridAreaDefinitionVec& b) const;
    String toDbgString() const;

    const AzGridAreaDefinitionVec& inner() const { return inner_; }
    AzGridAreaDefinitionVec& inner() { return inner_; }
    const AzGridAreaDefinitionVec* ptr() const { return &inner_; }
    AzGridAreaDefinitionVec* ptr() { return &inner_; }
    AzGridAreaDefinitionVec release() { AzGridAreaDefinitionVec result = inner_; inner_ = {}; return result; }
    operator AzGridAreaDefinitionVec() && noexcept { AzGridAreaDefinitionVec result = inner_; inner_ = {}; return result; }
};

class ComponentDataFieldVec {
private:
    AzComponentDataFieldVec inner_;

    ComponentDataFieldVec(const ComponentDataFieldVec&) = delete;
    ComponentDataFieldVec& operator=(const ComponentDataFieldVec&) = delete;

public:
    explicit ComponentDataFieldVec(AzComponentDataFieldVec inner) noexcept : inner_(inner) {}

    ComponentDataFieldVec(ComponentDataFieldVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentDataFieldVec& operator=(ComponentDataFieldVec&& other) noexcept {
        if (this != &other) {
            AzComponentDataFieldVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentDataFieldVec() { AzComponentDataFieldVec_delete(&inner_); }

    static ComponentDataFieldVec create();
    static ComponentDataFieldVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static ComponentDataFieldVec from_item(ComponentDataField item);
    static ComponentDataFieldVec copy_from_ptr(const ComponentDataField& ptr, size_t len);
    OptionComponentDataField c_get(size_t index) const;
    ComponentDataFieldVecSlice as_c_slice() const;
    ComponentDataFieldVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ComponentDataFieldVec clone() const;
    bool partialEq(const ComponentDataFieldVec& b) const;
    String toDbgString() const;

    const AzComponentDataFieldVec& inner() const { return inner_; }
    AzComponentDataFieldVec& inner() { return inner_; }
    const AzComponentDataFieldVec* ptr() const { return &inner_; }
    AzComponentDataFieldVec* ptr() { return &inner_; }
    AzComponentDataFieldVec release() { AzComponentDataFieldVec result = inner_; inner_ = {}; return result; }
    operator AzComponentDataFieldVec() && noexcept { AzComponentDataFieldVec result = inner_; inner_ = {}; return result; }
};

class ComponentDefVec {
private:
    AzComponentDefVec inner_;

    ComponentDefVec(const ComponentDefVec&) = delete;
    ComponentDefVec& operator=(const ComponentDefVec&) = delete;

public:
    explicit ComponentDefVec(AzComponentDefVec inner) noexcept : inner_(inner) {}

    ComponentDefVec(ComponentDefVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentDefVec& operator=(ComponentDefVec&& other) noexcept {
        if (this != &other) {
            AzComponentDefVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentDefVec() { AzComponentDefVec_delete(&inner_); }

    static ComponentDefVec create();
    static ComponentDefVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static ComponentDefVec from_item(ComponentDef item);
    static ComponentDefVec copy_from_ptr(const ComponentDef& ptr, size_t len);
    OptionComponentDef c_get(size_t index) const;
    ComponentDefVecSlice as_c_slice() const;
    ComponentDefVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ComponentDefVec clone() const;
    String toDbgString() const;

    const AzComponentDefVec& inner() const { return inner_; }
    AzComponentDefVec& inner() { return inner_; }
    const AzComponentDefVec* ptr() const { return &inner_; }
    AzComponentDefVec* ptr() { return &inner_; }
    AzComponentDefVec release() { AzComponentDefVec result = inner_; inner_ = {}; return result; }
    operator AzComponentDefVec() && noexcept { AzComponentDefVec result = inner_; inner_ = {}; return result; }
};

class ComponentLibraryVec {
private:
    AzComponentLibraryVec inner_;

    ComponentLibraryVec(const ComponentLibraryVec&) = delete;
    ComponentLibraryVec& operator=(const ComponentLibraryVec&) = delete;

public:
    explicit ComponentLibraryVec(AzComponentLibraryVec inner) noexcept : inner_(inner) {}

    ComponentLibraryVec(ComponentLibraryVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentLibraryVec& operator=(ComponentLibraryVec&& other) noexcept {
        if (this != &other) {
            AzComponentLibraryVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentLibraryVec() { AzComponentLibraryVec_delete(&inner_); }

    static ComponentLibraryVec create();
    static ComponentLibraryVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static ComponentLibraryVec from_item(ComponentLibrary item);
    static ComponentLibraryVec copy_from_ptr(const ComponentLibrary& ptr, size_t len);
    OptionComponentLibrary c_get(size_t index) const;
    ComponentLibraryVecSlice as_c_slice() const;
    ComponentLibraryVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ComponentLibraryVec clone() const;
    String toDbgString() const;

    const AzComponentLibraryVec& inner() const { return inner_; }
    AzComponentLibraryVec& inner() { return inner_; }
    const AzComponentLibraryVec* ptr() const { return &inner_; }
    AzComponentLibraryVec* ptr() { return &inner_; }
    AzComponentLibraryVec release() { AzComponentLibraryVec result = inner_; inner_ = {}; return result; }
    operator AzComponentLibraryVec() && noexcept { AzComponentLibraryVec result = inner_; inner_ = {}; return result; }
};

class ComponentDataModelVec {
private:
    AzComponentDataModelVec inner_;

    ComponentDataModelVec(const ComponentDataModelVec&) = delete;
    ComponentDataModelVec& operator=(const ComponentDataModelVec&) = delete;

public:
    explicit ComponentDataModelVec(AzComponentDataModelVec inner) noexcept : inner_(inner) {}

    ComponentDataModelVec(ComponentDataModelVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentDataModelVec& operator=(ComponentDataModelVec&& other) noexcept {
        if (this != &other) {
            AzComponentDataModelVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentDataModelVec() { AzComponentDataModelVec_delete(&inner_); }

    static ComponentDataModelVec create();
    static ComponentDataModelVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static ComponentDataModelVec from_item(ComponentDataModel item);
    static ComponentDataModelVec copy_from_ptr(const ComponentDataModel& ptr, size_t len);
    OptionComponentDataModel c_get(size_t index) const;
    ComponentDataModelVecSlice as_c_slice() const;
    ComponentDataModelVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ComponentDataModelVec clone() const;
    String toDbgString() const;

    const AzComponentDataModelVec& inner() const { return inner_; }
    AzComponentDataModelVec& inner() { return inner_; }
    const AzComponentDataModelVec* ptr() const { return &inner_; }
    AzComponentDataModelVec* ptr() { return &inner_; }
    AzComponentDataModelVec release() { AzComponentDataModelVec result = inner_; inner_ = {}; return result; }
    operator AzComponentDataModelVec() && noexcept { AzComponentDataModelVec result = inner_; inner_ = {}; return result; }
};

class ComponentEnumModelVec {
private:
    AzComponentEnumModelVec inner_;

    ComponentEnumModelVec(const ComponentEnumModelVec&) = delete;
    ComponentEnumModelVec& operator=(const ComponentEnumModelVec&) = delete;

public:
    explicit ComponentEnumModelVec(AzComponentEnumModelVec inner) noexcept : inner_(inner) {}

    ComponentEnumModelVec(ComponentEnumModelVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentEnumModelVec& operator=(ComponentEnumModelVec&& other) noexcept {
        if (this != &other) {
            AzComponentEnumModelVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentEnumModelVec() { AzComponentEnumModelVec_delete(&inner_); }

    static ComponentEnumModelVec create();
    static ComponentEnumModelVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static ComponentEnumModelVec from_item(ComponentEnumModel item);
    static ComponentEnumModelVec copy_from_ptr(const ComponentEnumModel& ptr, size_t len);
    OptionComponentEnumModel c_get(size_t index) const;
    ComponentEnumModelVecSlice as_c_slice() const;
    ComponentEnumModelVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ComponentEnumModelVec clone() const;
    bool partialEq(const ComponentEnumModelVec& b) const;
    String toDbgString() const;

    const AzComponentEnumModelVec& inner() const { return inner_; }
    AzComponentEnumModelVec& inner() { return inner_; }
    const AzComponentEnumModelVec* ptr() const { return &inner_; }
    AzComponentEnumModelVec* ptr() { return &inner_; }
    AzComponentEnumModelVec release() { AzComponentEnumModelVec result = inner_; inner_ = {}; return result; }
    operator AzComponentEnumModelVec() && noexcept { AzComponentEnumModelVec result = inner_; inner_ = {}; return result; }
};

class ComponentEnumVariantVec {
private:
    AzComponentEnumVariantVec inner_;

    ComponentEnumVariantVec(const ComponentEnumVariantVec&) = delete;
    ComponentEnumVariantVec& operator=(const ComponentEnumVariantVec&) = delete;

public:
    explicit ComponentEnumVariantVec(AzComponentEnumVariantVec inner) noexcept : inner_(inner) {}

    ComponentEnumVariantVec(ComponentEnumVariantVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentEnumVariantVec& operator=(ComponentEnumVariantVec&& other) noexcept {
        if (this != &other) {
            AzComponentEnumVariantVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentEnumVariantVec() { AzComponentEnumVariantVec_delete(&inner_); }

    static ComponentEnumVariantVec create();
    static ComponentEnumVariantVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static ComponentEnumVariantVec from_item(ComponentEnumVariant item);
    static ComponentEnumVariantVec copy_from_ptr(const ComponentEnumVariant& ptr, size_t len);
    OptionComponentEnumVariant c_get(size_t index) const;
    ComponentEnumVariantVecSlice as_c_slice() const;
    ComponentEnumVariantVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ComponentEnumVariantVec clone() const;
    bool partialEq(const ComponentEnumVariantVec& b) const;
    String toDbgString() const;

    const AzComponentEnumVariantVec& inner() const { return inner_; }
    AzComponentEnumVariantVec& inner() { return inner_; }
    const AzComponentEnumVariantVec* ptr() const { return &inner_; }
    AzComponentEnumVariantVec* ptr() { return &inner_; }
    AzComponentEnumVariantVec release() { AzComponentEnumVariantVec result = inner_; inner_ = {}; return result; }
    operator AzComponentEnumVariantVec() && noexcept { AzComponentEnumVariantVec result = inner_; inner_ = {}; return result; }
};

class ComponentCallbackArgVec {
private:
    AzComponentCallbackArgVec inner_;

    ComponentCallbackArgVec(const ComponentCallbackArgVec&) = delete;
    ComponentCallbackArgVec& operator=(const ComponentCallbackArgVec&) = delete;

public:
    explicit ComponentCallbackArgVec(AzComponentCallbackArgVec inner) noexcept : inner_(inner) {}

    ComponentCallbackArgVec(ComponentCallbackArgVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentCallbackArgVec& operator=(ComponentCallbackArgVec&& other) noexcept {
        if (this != &other) {
            AzComponentCallbackArgVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentCallbackArgVec() { AzComponentCallbackArgVec_delete(&inner_); }

    static ComponentCallbackArgVec create();
    static ComponentCallbackArgVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static ComponentCallbackArgVec from_item(ComponentCallbackArg item);
    static ComponentCallbackArgVec copy_from_ptr(const ComponentCallbackArg& ptr, size_t len);
    OptionComponentCallbackArg c_get(size_t index) const;
    ComponentCallbackArgVecSlice as_c_slice() const;
    ComponentCallbackArgVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ComponentCallbackArgVec clone() const;
    bool partialEq(const ComponentCallbackArgVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ComponentCallbackArgVec& b) const;
    uint8_t cmp(const ComponentCallbackArgVec& b) const;
    String toDbgString() const;

    const AzComponentCallbackArgVec& inner() const { return inner_; }
    AzComponentCallbackArgVec& inner() { return inner_; }
    const AzComponentCallbackArgVec* ptr() const { return &inner_; }
    AzComponentCallbackArgVec* ptr() { return &inner_; }
    AzComponentCallbackArgVec release() { AzComponentCallbackArgVec result = inner_; inner_ = {}; return result; }
    operator AzComponentCallbackArgVec() && noexcept { AzComponentCallbackArgVec result = inner_; inner_ = {}; return result; }
};

class ComponentFieldOverrideVec {
private:
    AzComponentFieldOverrideVec inner_;

    ComponentFieldOverrideVec(const ComponentFieldOverrideVec&) = delete;
    ComponentFieldOverrideVec& operator=(const ComponentFieldOverrideVec&) = delete;

public:
    explicit ComponentFieldOverrideVec(AzComponentFieldOverrideVec inner) noexcept : inner_(inner) {}

    ComponentFieldOverrideVec(ComponentFieldOverrideVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentFieldOverrideVec& operator=(ComponentFieldOverrideVec&& other) noexcept {
        if (this != &other) {
            AzComponentFieldOverrideVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentFieldOverrideVec() { AzComponentFieldOverrideVec_delete(&inner_); }

    static ComponentFieldOverrideVec create();
    static ComponentFieldOverrideVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static ComponentFieldOverrideVec from_item(ComponentFieldOverride item);
    static ComponentFieldOverrideVec copy_from_ptr(const ComponentFieldOverride& ptr, size_t len);
    OptionComponentFieldOverride c_get(size_t index) const;
    ComponentFieldOverrideVecSlice as_c_slice() const;
    ComponentFieldOverrideVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    ComponentFieldOverrideVec clone() const;
    bool partialEq(const ComponentFieldOverrideVec& b) const;
    String toDbgString() const;

    const AzComponentFieldOverrideVec& inner() const { return inner_; }
    AzComponentFieldOverrideVec& inner() { return inner_; }
    const AzComponentFieldOverrideVec* ptr() const { return &inner_; }
    AzComponentFieldOverrideVec* ptr() { return &inner_; }
    AzComponentFieldOverrideVec release() { AzComponentFieldOverrideVec result = inner_; inner_ = {}; return result; }
    operator AzComponentFieldOverrideVec() && noexcept { AzComponentFieldOverrideVec result = inner_; inner_ = {}; return result; }
};

class SvgPathElementVec {
private:
    AzSvgPathElementVec inner_;

    SvgPathElementVec(const SvgPathElementVec&) = delete;
    SvgPathElementVec& operator=(const SvgPathElementVec&) = delete;

public:
    explicit SvgPathElementVec(AzSvgPathElementVec inner) noexcept : inner_(inner) {}

    SvgPathElementVec(SvgPathElementVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SvgPathElementVec& operator=(SvgPathElementVec&& other) noexcept {
        if (this != &other) {
            AzSvgPathElementVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SvgPathElementVec() { AzSvgPathElementVec_delete(&inner_); }

    static SvgPathElementVec create();
    static SvgPathElementVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static SvgPathElementVec from_item(AzSvgPathElement item);
    static SvgPathElementVec copy_from_ptr(const AzSvgPathElement* ptr, size_t len);
    OptionSvgPathElement c_get(size_t index) const;
    SvgPathElementVecSlice as_c_slice() const;
    SvgPathElementVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    SvgPathElementVec clone() const;
    bool partialEq(const SvgPathElementVec& b) const;
    uint8_t partialCmp(const SvgPathElementVec& b) const;
    String toDbgString() const;

    const AzSvgPathElementVec& inner() const { return inner_; }
    AzSvgPathElementVec& inner() { return inner_; }
    const AzSvgPathElementVec* ptr() const { return &inner_; }
    AzSvgPathElementVec* ptr() { return &inner_; }
    AzSvgPathElementVec release() { AzSvgPathElementVec result = inner_; inner_ = {}; return result; }
    operator AzSvgPathElementVec() && noexcept { AzSvgPathElementVec result = inner_; inner_ = {}; return result; }
};

class SvgPathVec {
private:
    AzSvgPathVec inner_;

    SvgPathVec(const SvgPathVec&) = delete;
    SvgPathVec& operator=(const SvgPathVec&) = delete;

public:
    explicit SvgPathVec(AzSvgPathVec inner) noexcept : inner_(inner) {}

    SvgPathVec(SvgPathVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SvgPathVec& operator=(SvgPathVec&& other) noexcept {
        if (this != &other) {
            AzSvgPathVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SvgPathVec() { AzSvgPathVec_delete(&inner_); }

    static SvgPathVec create();
    static SvgPathVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static SvgPathVec from_item(SvgPath item);
    static SvgPathVec copy_from_ptr(const SvgPath& ptr, size_t len);
    OptionSvgPath c_get(size_t index) const;
    SvgPathVecSlice as_c_slice() const;
    SvgPathVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    SvgPathVec clone() const;
    bool partialEq(const SvgPathVec& b) const;
    uint8_t partialCmp(const SvgPathVec& b) const;
    String toDbgString() const;

    const AzSvgPathVec& inner() const { return inner_; }
    AzSvgPathVec& inner() { return inner_; }
    const AzSvgPathVec* ptr() const { return &inner_; }
    AzSvgPathVec* ptr() { return &inner_; }
    AzSvgPathVec release() { AzSvgPathVec result = inner_; inner_ = {}; return result; }
    operator AzSvgPathVec() && noexcept { AzSvgPathVec result = inner_; inner_ = {}; return result; }
};

class RibbonSectionVec {
private:
    AzRibbonSectionVec inner_;

    RibbonSectionVec(const RibbonSectionVec&) = delete;
    RibbonSectionVec& operator=(const RibbonSectionVec&) = delete;

public:
    explicit RibbonSectionVec(AzRibbonSectionVec inner) noexcept : inner_(inner) {}

    RibbonSectionVec(RibbonSectionVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RibbonSectionVec& operator=(RibbonSectionVec&& other) noexcept {
        if (this != &other) {
            AzRibbonSectionVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RibbonSectionVec() { AzRibbonSectionVec_delete(&inner_); }

    static RibbonSectionVec create();
    static RibbonSectionVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static RibbonSectionVec from_item(RibbonSection item);
    static RibbonSectionVec copy_from_ptr(const RibbonSection& ptr, size_t len);
    OptionRibbonSection c_get(size_t index) const;
    RibbonSectionVecSlice as_c_slice() const;
    RibbonSectionVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    RibbonSectionVec clone() const;
    String toDbgString() const;

    const AzRibbonSectionVec& inner() const { return inner_; }
    AzRibbonSectionVec& inner() { return inner_; }
    const AzRibbonSectionVec* ptr() const { return &inner_; }
    AzRibbonSectionVec* ptr() { return &inner_; }
    AzRibbonSectionVec release() { AzRibbonSectionVec result = inner_; inner_ = {}; return result; }
    operator AzRibbonSectionVec() && noexcept { AzRibbonSectionVec result = inner_; inner_ = {}; return result; }
};

class RibbonTabVec {
private:
    AzRibbonTabVec inner_;

    RibbonTabVec(const RibbonTabVec&) = delete;
    RibbonTabVec& operator=(const RibbonTabVec&) = delete;

public:
    explicit RibbonTabVec(AzRibbonTabVec inner) noexcept : inner_(inner) {}

    RibbonTabVec(RibbonTabVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RibbonTabVec& operator=(RibbonTabVec&& other) noexcept {
        if (this != &other) {
            AzRibbonTabVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RibbonTabVec() { AzRibbonTabVec_delete(&inner_); }

    static RibbonTabVec create();
    static RibbonTabVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static RibbonTabVec from_item(RibbonTab item);
    static RibbonTabVec copy_from_ptr(const RibbonTab& ptr, size_t len);
    OptionRibbonTab c_get(size_t index) const;
    RibbonTabVecSlice as_c_slice() const;
    RibbonTabVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    RibbonTabVec clone() const;
    String toDbgString() const;

    const AzRibbonTabVec& inner() const { return inner_; }
    AzRibbonTabVec& inner() { return inner_; }
    const AzRibbonTabVec* ptr() const { return &inner_; }
    AzRibbonTabVec* ptr() { return &inner_; }
    AzRibbonTabVec release() { AzRibbonTabVec result = inner_; inner_ = {}; return result; }
    operator AzRibbonTabVec() && noexcept { AzRibbonTabVec result = inner_; inner_ = {}; return result; }
};

class TreeViewNodeVec {
private:
    AzTreeViewNodeVec inner_;

    TreeViewNodeVec(const TreeViewNodeVec&) = delete;
    TreeViewNodeVec& operator=(const TreeViewNodeVec&) = delete;

public:
    explicit TreeViewNodeVec(AzTreeViewNodeVec inner) noexcept : inner_(inner) {}

    TreeViewNodeVec(TreeViewNodeVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TreeViewNodeVec& operator=(TreeViewNodeVec&& other) noexcept {
        if (this != &other) {
            AzTreeViewNodeVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TreeViewNodeVec() { AzTreeViewNodeVec_delete(&inner_); }

    static TreeViewNodeVec create();
    static TreeViewNodeVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static TreeViewNodeVec from_item(TreeViewNode item);
    static TreeViewNodeVec copy_from_ptr(const TreeViewNode& ptr, size_t len);
    OptionTreeViewNode c_get(size_t index) const;
    TreeViewNodeVecSlice as_c_slice() const;
    TreeViewNodeVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    TreeViewNodeVec clone() const;
    bool partialEq(const TreeViewNodeVec& b) const;
    String toDbgString() const;

    const AzTreeViewNodeVec& inner() const { return inner_; }
    AzTreeViewNodeVec& inner() { return inner_; }
    const AzTreeViewNodeVec* ptr() const { return &inner_; }
    AzTreeViewNodeVec* ptr() { return &inner_; }
    AzTreeViewNodeVec release() { AzTreeViewNodeVec result = inner_; inner_ = {}; return result; }
    operator AzTreeViewNodeVec() && noexcept { AzTreeViewNodeVec result = inner_; inner_ = {}; return result; }
};

class RouteVec {
private:
    AzRouteVec inner_;

    RouteVec(const RouteVec&) = delete;
    RouteVec& operator=(const RouteVec&) = delete;

public:
    explicit RouteVec(AzRouteVec inner) noexcept : inner_(inner) {}

    RouteVec(RouteVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RouteVec& operator=(RouteVec&& other) noexcept {
        if (this != &other) {
            AzRouteVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RouteVec() { AzRouteVec_delete(&inner_); }

    static RouteVec create();
    static RouteVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static RouteVec from_item(Route item);
    static RouteVec copy_from_ptr(const Route& ptr, size_t len);
    OptionRoute c_get(size_t index) const;
    RouteVecSlice as_c_slice() const;
    RouteVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    RouteVec clone() const;
    bool partialEq(const RouteVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const RouteVec& b) const;
    uint8_t cmp(const RouteVec& b) const;
    String toDbgString() const;

    const AzRouteVec& inner() const { return inner_; }
    AzRouteVec& inner() { return inner_; }
    const AzRouteVec* ptr() const { return &inner_; }
    AzRouteVec* ptr() { return &inner_; }
    AzRouteVec release() { AzRouteVec result = inner_; inner_ = {}; return result; }
    operator AzRouteVec() && noexcept { AzRouteVec result = inner_; inner_ = {}; return result; }
};

class TouchPointVec {
private:
    AzTouchPointVec inner_;

    TouchPointVec(const TouchPointVec&) = delete;
    TouchPointVec& operator=(const TouchPointVec&) = delete;

public:
    explicit TouchPointVec(AzTouchPointVec inner) noexcept : inner_(inner) {}

    TouchPointVec(TouchPointVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TouchPointVec& operator=(TouchPointVec&& other) noexcept {
        if (this != &other) {
            AzTouchPointVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TouchPointVec() { AzTouchPointVec_delete(&inner_); }

    static TouchPointVec create();
    static TouchPointVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static TouchPointVec from_item(TouchPoint item);
    static TouchPointVec copy_from_ptr(const TouchPoint& ptr, size_t len);
    OptionTouchPoint c_get(size_t index) const;
    TouchPointVecSlice as_c_slice() const;
    TouchPointVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    TouchPointVec clone() const;
    bool partialEq(const TouchPointVec& b) const;
    String toDbgString() const;

    const AzTouchPointVec& inner() const { return inner_; }
    AzTouchPointVec& inner() { return inner_; }
    const AzTouchPointVec* ptr() const { return &inner_; }
    AzTouchPointVec* ptr() { return &inner_; }
    AzTouchPointVec release() { AzTouchPointVec result = inner_; inner_ = {}; return result; }
    operator AzTouchPointVec() && noexcept { AzTouchPointVec result = inner_; inner_ = {}; return result; }
};

class LayoutRectVec {
private:
    AzLayoutRectVec inner_;

    LayoutRectVec(const LayoutRectVec&) = delete;
    LayoutRectVec& operator=(const LayoutRectVec&) = delete;

public:
    explicit LayoutRectVec(AzLayoutRectVec inner) noexcept : inner_(inner) {}

    LayoutRectVec(LayoutRectVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    LayoutRectVec& operator=(LayoutRectVec&& other) noexcept {
        if (this != &other) {
            AzLayoutRectVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~LayoutRectVec() { AzLayoutRectVec_delete(&inner_); }

    [[nodiscard]] static LayoutRectVec create();
    [[nodiscard]] static LayoutRectVec with_capacity(size_t cap);
    [[nodiscard]] static LayoutRectVec from_item(LayoutRect item);
    [[nodiscard]] static LayoutRectVec copy_from_ptr(const LayoutRect& ptr, size_t len);

    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionLayoutRect get(size_t index) const;
    OptionLayoutRect c_get(size_t index) const;
    LayoutRectVecSlice as_c_slice() const;
    LayoutRectVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    LayoutRectVec clone() const;
    bool partialEq(const LayoutRectVec& b) const;
    uint8_t partialCmp(const LayoutRectVec& b) const;
    String toDbgString() const;

    const AzLayoutRectVec& inner() const { return inner_; }
    AzLayoutRectVec& inner() { return inner_; }
    const AzLayoutRectVec* ptr() const { return &inner_; }
    AzLayoutRectVec* ptr() { return &inner_; }
    AzLayoutRectVec release() { AzLayoutRectVec result = inner_; inner_ = {}; return result; }
    operator AzLayoutRectVec() && noexcept { AzLayoutRectVec result = inner_; inner_ = {}; return result; }
};

class DbValueVec {
private:
    AzDbValueVec inner_;

    DbValueVec(const DbValueVec&) = delete;
    DbValueVec& operator=(const DbValueVec&) = delete;

public:
    explicit DbValueVec(AzDbValueVec inner) noexcept : inner_(inner) {}

    DbValueVec(DbValueVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DbValueVec& operator=(DbValueVec&& other) noexcept {
        if (this != &other) {
            AzDbValueVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DbValueVec() { AzDbValueVec_delete(&inner_); }

    static DbValueVec create();
    static DbValueVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    static DbValueVec from_item(AzDbValue item);
    static DbValueVec copy_from_ptr(const AzDbValue* ptr, size_t len);
    OptionDbValue c_get(size_t index) const;
    DbValueVecSlice as_c_slice() const;
    DbValueVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    DbValueVec clone() const;
    bool partialEq(const DbValueVec& b) const;
    String toDbgString() const;

    const AzDbValueVec& inner() const { return inner_; }
    AzDbValueVec& inner() { return inner_; }
    const AzDbValueVec* ptr() const { return &inner_; }
    AzDbValueVec* ptr() { return &inner_; }
    AzDbValueVec release() { AzDbValueVec result = inner_; inner_ = {}; return result; }
    operator AzDbValueVec() && noexcept { AzDbValueVec result = inner_; inner_ = {}; return result; }
};

class LoadedFontVec {
private:
    AzLoadedFontVec inner_;

    LoadedFontVec(const LoadedFontVec&) = delete;
    LoadedFontVec& operator=(const LoadedFontVec&) = delete;

public:
    explicit LoadedFontVec(AzLoadedFontVec inner) noexcept : inner_(inner) {}

    LoadedFontVec(LoadedFontVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    LoadedFontVec& operator=(LoadedFontVec&& other) noexcept {
        if (this != &other) {
            AzLoadedFontVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~LoadedFontVec() { AzLoadedFontVec_delete(&inner_); }

    static LoadedFontVec create();
    static LoadedFontVec with_capacity(size_t cap);
    size_t len() const;
    size_t capacity() const;
    bool is_empty() const;
    OptionLoadedFont c_get(size_t index) const;
    static LoadedFontVec from_item(LoadedFont item);
    static LoadedFontVec copy_from_ptr(const LoadedFont& ptr, size_t len);
    LoadedFontVecSlice as_c_slice() const;
    LoadedFontVecSlice as_c_slice_range(size_t start, size_t end) const;
    void delete_();
    LoadedFontVec clone() const;
    bool partialEq(const LoadedFontVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LoadedFontVec& b) const;
    uint8_t cmp(const LoadedFontVec& b) const;
    String toDbgString() const;

    const AzLoadedFontVec& inner() const { return inner_; }
    AzLoadedFontVec& inner() { return inner_; }
    const AzLoadedFontVec* ptr() const { return &inner_; }
    AzLoadedFontVec* ptr() { return &inner_; }
    AzLoadedFontVec release() { AzLoadedFontVec result = inner_; inner_ = {}; return result; }
    operator AzLoadedFontVec() && noexcept { AzLoadedFontVec result = inner_; inner_ = {}; return result; }
};

class SvgRenderOptions {
private:
    AzSvgRenderOptions inner_;

public:
    SvgRenderOptions(AzSvgRenderOptions inner) noexcept : inner_(inner) {}
    SvgRenderOptions(const SvgRenderOptions& other) noexcept : inner_(other.inner_) {}
    SvgRenderOptions& operator=(const SvgRenderOptions& other) noexcept { inner_ = other.inner_; return *this; }
    ~SvgRenderOptions() {}

    [[nodiscard]] static SvgRenderOptions default_();

    bool partialEq(const SvgRenderOptions& b) const;
    uint8_t partialCmp(const SvgRenderOptions& b) const;
    String toDbgString() const;

    const AzSvgRenderOptions& inner() const { return inner_; }
    AzSvgRenderOptions& inner() { return inner_; }
    const AzSvgRenderOptions* ptr() const { return &inner_; }
    AzSvgRenderOptions* ptr() { return &inner_; }
    AzSvgRenderOptions release() { AzSvgRenderOptions result = inner_; inner_ = {}; return result; }
    operator AzSvgRenderOptions() && noexcept { AzSvgRenderOptions result = inner_; inner_ = {}; return result; }
};

class IconStyleOptions {
private:
    AzIconStyleOptions inner_;

    IconStyleOptions(const IconStyleOptions&) = delete;
    IconStyleOptions& operator=(const IconStyleOptions&) = delete;

public:
    explicit IconStyleOptions(AzIconStyleOptions inner) noexcept : inner_(inner) {}

    IconStyleOptions(IconStyleOptions&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    IconStyleOptions& operator=(IconStyleOptions&& other) noexcept {
        if (this != &other) {
            AzIconStyleOptions_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~IconStyleOptions() { AzIconStyleOptions_delete(&inner_); }

    [[nodiscard]] static IconStyleOptions default_();

    void delete_();
    IconStyleOptions clone() const;
    bool partialEq(const IconStyleOptions& b) const;
    String toDbgString() const;

    const AzIconStyleOptions& inner() const { return inner_; }
    AzIconStyleOptions& inner() { return inner_; }
    const AzIconStyleOptions* ptr() const { return &inner_; }
    AzIconStyleOptions* ptr() { return &inner_; }
    AzIconStyleOptions release() { AzIconStyleOptions result = inner_; inner_ = {}; return result; }
    operator AzIconStyleOptions() && noexcept { AzIconStyleOptions result = inner_; inner_ = {}; return result; }
};

class TaskBarIcon {
private:
    AzTaskBarIcon inner_;

    TaskBarIcon(const TaskBarIcon&) = delete;
    TaskBarIcon& operator=(const TaskBarIcon&) = delete;

public:
    explicit TaskBarIcon(AzTaskBarIcon inner) noexcept : inner_(inner) {}

    TaskBarIcon(TaskBarIcon&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TaskBarIcon& operator=(TaskBarIcon&& other) noexcept {
        if (this != &other) {
            AzTaskBarIcon_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TaskBarIcon() { AzTaskBarIcon_delete(&inner_); }

    void delete_();
    TaskBarIcon clone() const;
    bool partialEq(const TaskBarIcon& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TaskBarIcon& b) const;
    uint8_t cmp(const TaskBarIcon& b) const;
    String toDbgString() const;

    const AzTaskBarIcon& inner() const { return inner_; }
    AzTaskBarIcon& inner() { return inner_; }
    const AzTaskBarIcon* ptr() const { return &inner_; }
    AzTaskBarIcon* ptr() { return &inner_; }
    AzTaskBarIcon release() { AzTaskBarIcon result = inner_; inner_ = {}; return result; }
    operator AzTaskBarIcon() && noexcept { AzTaskBarIcon result = inner_; inner_ = {}; return result; }
};

class SmallWindowIconBytes {
private:
    AzSmallWindowIconBytes inner_;

    SmallWindowIconBytes(const SmallWindowIconBytes&) = delete;
    SmallWindowIconBytes& operator=(const SmallWindowIconBytes&) = delete;

public:
    explicit SmallWindowIconBytes(AzSmallWindowIconBytes inner) noexcept : inner_(inner) {}

    SmallWindowIconBytes(SmallWindowIconBytes&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SmallWindowIconBytes& operator=(SmallWindowIconBytes&& other) noexcept {
        if (this != &other) {
            AzSmallWindowIconBytes_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SmallWindowIconBytes() { AzSmallWindowIconBytes_delete(&inner_); }

    void delete_();
    SmallWindowIconBytes clone() const;
    String toDbgString() const;

    const AzSmallWindowIconBytes& inner() const { return inner_; }
    AzSmallWindowIconBytes& inner() { return inner_; }
    const AzSmallWindowIconBytes* ptr() const { return &inner_; }
    AzSmallWindowIconBytes* ptr() { return &inner_; }
    AzSmallWindowIconBytes release() { AzSmallWindowIconBytes result = inner_; inner_ = {}; return result; }
    operator AzSmallWindowIconBytes() && noexcept { AzSmallWindowIconBytes result = inner_; inner_ = {}; return result; }
};

class LargeWindowIconBytes {
private:
    AzLargeWindowIconBytes inner_;

    LargeWindowIconBytes(const LargeWindowIconBytes&) = delete;
    LargeWindowIconBytes& operator=(const LargeWindowIconBytes&) = delete;

public:
    explicit LargeWindowIconBytes(AzLargeWindowIconBytes inner) noexcept : inner_(inner) {}

    LargeWindowIconBytes(LargeWindowIconBytes&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    LargeWindowIconBytes& operator=(LargeWindowIconBytes&& other) noexcept {
        if (this != &other) {
            AzLargeWindowIconBytes_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~LargeWindowIconBytes() { AzLargeWindowIconBytes_delete(&inner_); }

    void delete_();
    LargeWindowIconBytes clone() const;
    String toDbgString() const;

    const AzLargeWindowIconBytes& inner() const { return inner_; }
    AzLargeWindowIconBytes& inner() { return inner_; }
    const AzLargeWindowIconBytes* ptr() const { return &inner_; }
    AzLargeWindowIconBytes* ptr() { return &inner_; }
    AzLargeWindowIconBytes release() { AzLargeWindowIconBytes result = inner_; inner_ = {}; return result; }
    operator AzLargeWindowIconBytes() && noexcept { AzLargeWindowIconBytes result = inner_; inner_ = {}; return result; }
};

class VirtualViewCallbackInfo {
private:
    AzVirtualViewCallbackInfo inner_;

    VirtualViewCallbackInfo(const VirtualViewCallbackInfo&) = delete;
    VirtualViewCallbackInfo& operator=(const VirtualViewCallbackInfo&) = delete;

public:
    explicit VirtualViewCallbackInfo(AzVirtualViewCallbackInfo inner) noexcept : inner_(inner) {}

    VirtualViewCallbackInfo(VirtualViewCallbackInfo&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VirtualViewCallbackInfo& operator=(VirtualViewCallbackInfo&& other) noexcept {
        if (this != &other) {
            AzVirtualViewCallbackInfo_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VirtualViewCallbackInfo() { AzVirtualViewCallbackInfo_delete(&inner_); }

    OptionRefAny get_ctx() const;
    HidpiAdjustedBounds get_bounds() const;
    void delete_();
    VirtualViewCallbackInfo clone() const;
    String toDbgString() const;

    const AzVirtualViewCallbackInfo& inner() const { return inner_; }
    AzVirtualViewCallbackInfo& inner() { return inner_; }
    const AzVirtualViewCallbackInfo* ptr() const { return &inner_; }
    AzVirtualViewCallbackInfo* ptr() { return &inner_; }
    AzVirtualViewCallbackInfo release() { AzVirtualViewCallbackInfo result = inner_; inner_ = {}; return result; }
    operator AzVirtualViewCallbackInfo() && noexcept { AzVirtualViewCallbackInfo result = inner_; inner_ = {}; return result; }
};

class LayoutCallback {
private:
    AzLayoutCallback inner_;

    LayoutCallback(const LayoutCallback&) = delete;
    LayoutCallback& operator=(const LayoutCallback&) = delete;

public:
    explicit LayoutCallback(AzLayoutCallback inner) noexcept : inner_(inner) {}

    LayoutCallback(LayoutCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    LayoutCallback& operator=(LayoutCallback&& other) noexcept {
        if (this != &other) {
            AzLayoutCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~LayoutCallback() { AzLayoutCallback_delete(&inner_); }

    [[nodiscard]] static LayoutCallback create(AzLayoutCallbackType cb);
    [[nodiscard]] static LayoutCallback default_();

    void delete_();
    LayoutCallback clone() const;
    bool partialEq(const LayoutCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LayoutCallback& b) const;
    uint8_t cmp(const LayoutCallback& b) const;
    String toDbgString() const;

    const AzLayoutCallback& inner() const { return inner_; }
    AzLayoutCallback& inner() { return inner_; }
    const AzLayoutCallback* ptr() const { return &inner_; }
    AzLayoutCallback* ptr() { return &inner_; }
    AzLayoutCallback release() { AzLayoutCallback result = inner_; inner_ = {}; return result; }
    operator AzLayoutCallback() && noexcept { AzLayoutCallback result = inner_; inner_ = {}; return result; }
};

class LayoutCallbackInfo {
private:
    AzLayoutCallbackInfo inner_;

    LayoutCallbackInfo(const LayoutCallbackInfo&) = delete;
    LayoutCallbackInfo& operator=(const LayoutCallbackInfo&) = delete;

public:
    explicit LayoutCallbackInfo(AzLayoutCallbackInfo inner) noexcept : inner_(inner) {}

    LayoutCallbackInfo(LayoutCallbackInfo&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    LayoutCallbackInfo& operator=(LayoutCallbackInfo&& other) noexcept {
        if (this != &other) {
            AzLayoutCallbackInfo_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~LayoutCallbackInfo() { AzLayoutCallbackInfo_delete(&inner_); }

    AzRelayoutReason relayout_reason() const;
    OptionRefAny get_ctx() const;
    OptionGlContextPtr get_gl_context() const;
    bool window_width_less_than(float px) const;
    bool window_width_greater_than(float px) const;
    bool window_width_between(float min_px, float max_px) const;
    bool window_height_less_than(float px) const;
    bool window_height_greater_than(float px) const;
    bool window_height_between(float min_px, float max_px) const;
    float get_window_width() const;
    float get_window_height() const;
    float get_dpi_factor() const;
    void delete_();
    LayoutCallbackInfo clone() const;
    String toDbgString() const;

    const AzLayoutCallbackInfo& inner() const { return inner_; }
    AzLayoutCallbackInfo& inner() { return inner_; }
    const AzLayoutCallbackInfo* ptr() const { return &inner_; }
    AzLayoutCallbackInfo* ptr() { return &inner_; }
    AzLayoutCallbackInfo release() { AzLayoutCallbackInfo result = inner_; inner_ = {}; return result; }
    operator AzLayoutCallbackInfo() && noexcept { AzLayoutCallbackInfo result = inner_; inner_ = {}; return result; }
};

class TimerCallback {
private:
    AzTimerCallback inner_;

    TimerCallback(const TimerCallback&) = delete;
    TimerCallback& operator=(const TimerCallback&) = delete;

public:
    explicit TimerCallback(AzTimerCallback inner) noexcept : inner_(inner) {}

    TimerCallback(TimerCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TimerCallback& operator=(TimerCallback&& other) noexcept {
        if (this != &other) {
            AzTimerCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TimerCallback() { AzTimerCallback_delete(&inner_); }

    void delete_();
    TimerCallback clone() const;
    bool partialEq(const TimerCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TimerCallback& b) const;
    uint8_t cmp(const TimerCallback& b) const;
    String toDbgString() const;

    const AzTimerCallback& inner() const { return inner_; }
    AzTimerCallback& inner() { return inner_; }
    const AzTimerCallback* ptr() const { return &inner_; }
    AzTimerCallback* ptr() { return &inner_; }
    AzTimerCallback release() { AzTimerCallback result = inner_; inner_ = {}; return result; }
    operator AzTimerCallback() && noexcept { AzTimerCallback result = inner_; inner_ = {}; return result; }
};

class WriteBackCallback {
private:
    AzWriteBackCallback inner_;

    WriteBackCallback(const WriteBackCallback&) = delete;
    WriteBackCallback& operator=(const WriteBackCallback&) = delete;

public:
    explicit WriteBackCallback(AzWriteBackCallback inner) noexcept : inner_(inner) {}

    WriteBackCallback(WriteBackCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    WriteBackCallback& operator=(WriteBackCallback&& other) noexcept {
        if (this != &other) {
            AzWriteBackCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~WriteBackCallback() { AzWriteBackCallback_delete(&inner_); }

    void delete_();
    WriteBackCallback clone() const;
    bool partialEq(const WriteBackCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const WriteBackCallback& b) const;
    uint8_t cmp(const WriteBackCallback& b) const;
    String toDbgString() const;

    const AzWriteBackCallback& inner() const { return inner_; }
    AzWriteBackCallback& inner() { return inner_; }
    const AzWriteBackCallback* ptr() const { return &inner_; }
    AzWriteBackCallback* ptr() { return &inner_; }
    AzWriteBackCallback release() { AzWriteBackCallback result = inner_; inner_ = {}; return result; }
    operator AzWriteBackCallback() && noexcept { AzWriteBackCallback result = inner_; inner_ = {}; return result; }
};

class ThreadCallback {
private:
    AzThreadCallback inner_;

    ThreadCallback(const ThreadCallback&) = delete;
    ThreadCallback& operator=(const ThreadCallback&) = delete;

public:
    explicit ThreadCallback(AzThreadCallback inner) noexcept : inner_(inner) {}

    ThreadCallback(ThreadCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ThreadCallback& operator=(ThreadCallback&& other) noexcept {
        if (this != &other) {
            AzThreadCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ThreadCallback() { AzThreadCallback_delete(&inner_); }

    void delete_();
    ThreadCallback clone() const;
    bool partialEq(const ThreadCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ThreadCallback& b) const;
    uint8_t cmp(const ThreadCallback& b) const;
    String toDbgString() const;

    const AzThreadCallback& inner() const { return inner_; }
    AzThreadCallback& inner() { return inner_; }
    const AzThreadCallback* ptr() const { return &inner_; }
    AzThreadCallback* ptr() { return &inner_; }
    AzThreadCallback release() { AzThreadCallback result = inner_; inner_ = {}; return result; }
    operator AzThreadCallback() && noexcept { AzThreadCallback result = inner_; inner_ = {}; return result; }
};

class RenderImageCallbackInfo {
private:
    AzRenderImageCallbackInfo inner_;

    RenderImageCallbackInfo(const RenderImageCallbackInfo&) = delete;
    RenderImageCallbackInfo& operator=(const RenderImageCallbackInfo&) = delete;

public:
    explicit RenderImageCallbackInfo(AzRenderImageCallbackInfo inner) noexcept : inner_(inner) {}

    RenderImageCallbackInfo(RenderImageCallbackInfo&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RenderImageCallbackInfo& operator=(RenderImageCallbackInfo&& other) noexcept {
        if (this != &other) {
            AzRenderImageCallbackInfo_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RenderImageCallbackInfo() { AzRenderImageCallbackInfo_delete(&inner_); }

    HidpiAdjustedBounds get_bounds() const;
    DomNodeId get_callback_node_id() const;
    OptionGlContextPtr get_gl_context() const;
    OptionRefAny get_ctx() const;
    void delete_();
    RenderImageCallbackInfo clone() const;
    String toDbgString() const;

    const AzRenderImageCallbackInfo& inner() const { return inner_; }
    AzRenderImageCallbackInfo& inner() { return inner_; }
    const AzRenderImageCallbackInfo* ptr() const { return &inner_; }
    AzRenderImageCallbackInfo* ptr() { return &inner_; }
    AzRenderImageCallbackInfo release() { AzRenderImageCallbackInfo result = inner_; inner_ = {}; return result; }
    operator AzRenderImageCallbackInfo() && noexcept { AzRenderImageCallbackInfo result = inner_; inner_ = {}; return result; }
};

class ListViewOnColumnClickCallback {
private:
    AzListViewOnColumnClickCallback inner_;

    ListViewOnColumnClickCallback(const ListViewOnColumnClickCallback&) = delete;
    ListViewOnColumnClickCallback& operator=(const ListViewOnColumnClickCallback&) = delete;

public:
    explicit ListViewOnColumnClickCallback(AzListViewOnColumnClickCallback inner) noexcept : inner_(inner) {}

    ListViewOnColumnClickCallback(ListViewOnColumnClickCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ListViewOnColumnClickCallback& operator=(ListViewOnColumnClickCallback&& other) noexcept {
        if (this != &other) {
            AzListViewOnColumnClickCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ListViewOnColumnClickCallback() { AzListViewOnColumnClickCallback_delete(&inner_); }

    void delete_();
    ListViewOnColumnClickCallback clone() const;
    bool partialEq(const ListViewOnColumnClickCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ListViewOnColumnClickCallback& b) const;
    uint8_t cmp(const ListViewOnColumnClickCallback& b) const;
    String toDbgString() const;

    const AzListViewOnColumnClickCallback& inner() const { return inner_; }
    AzListViewOnColumnClickCallback& inner() { return inner_; }
    const AzListViewOnColumnClickCallback* ptr() const { return &inner_; }
    AzListViewOnColumnClickCallback* ptr() { return &inner_; }
    AzListViewOnColumnClickCallback release() { AzListViewOnColumnClickCallback result = inner_; inner_ = {}; return result; }
    operator AzListViewOnColumnClickCallback() && noexcept { AzListViewOnColumnClickCallback result = inner_; inner_ = {}; return result; }
};

class CoreCallback {
private:
    AzCoreCallback inner_;

    CoreCallback(const CoreCallback&) = delete;
    CoreCallback& operator=(const CoreCallback&) = delete;

public:
    explicit CoreCallback(AzCoreCallback inner) noexcept : inner_(inner) {}

    CoreCallback(CoreCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CoreCallback& operator=(CoreCallback&& other) noexcept {
        if (this != &other) {
            AzCoreCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CoreCallback() { AzCoreCallback_delete(&inner_); }

    void delete_();
    CoreCallback clone() const;
    bool partialEq(const CoreCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CoreCallback& b) const;
    uint8_t cmp(const CoreCallback& b) const;
    String toDbgString() const;

    const AzCoreCallback& inner() const { return inner_; }
    AzCoreCallback& inner() { return inner_; }
    const AzCoreCallback* ptr() const { return &inner_; }
    AzCoreCallback* ptr() { return &inner_; }
    AzCoreCallback release() { AzCoreCallback result = inner_; inner_ = {}; return result; }
    operator AzCoreCallback() && noexcept { AzCoreCallback result = inner_; inner_ = {}; return result; }
};

class ListViewOnRowClickCallback {
private:
    AzListViewOnRowClickCallback inner_;

    ListViewOnRowClickCallback(const ListViewOnRowClickCallback&) = delete;
    ListViewOnRowClickCallback& operator=(const ListViewOnRowClickCallback&) = delete;

public:
    explicit ListViewOnRowClickCallback(AzListViewOnRowClickCallback inner) noexcept : inner_(inner) {}

    ListViewOnRowClickCallback(ListViewOnRowClickCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ListViewOnRowClickCallback& operator=(ListViewOnRowClickCallback&& other) noexcept {
        if (this != &other) {
            AzListViewOnRowClickCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ListViewOnRowClickCallback() { AzListViewOnRowClickCallback_delete(&inner_); }

    void delete_();
    ListViewOnRowClickCallback clone() const;
    bool partialEq(const ListViewOnRowClickCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ListViewOnRowClickCallback& b) const;
    uint8_t cmp(const ListViewOnRowClickCallback& b) const;
    String toDbgString() const;

    const AzListViewOnRowClickCallback& inner() const { return inner_; }
    AzListViewOnRowClickCallback& inner() { return inner_; }
    const AzListViewOnRowClickCallback* ptr() const { return &inner_; }
    AzListViewOnRowClickCallback* ptr() { return &inner_; }
    AzListViewOnRowClickCallback release() { AzListViewOnRowClickCallback result = inner_; inner_ = {}; return result; }
    operator AzListViewOnRowClickCallback() && noexcept { AzListViewOnRowClickCallback result = inner_; inner_ = {}; return result; }
};

class CheckBoxOnToggleCallback {
private:
    AzCheckBoxOnToggleCallback inner_;

    CheckBoxOnToggleCallback(const CheckBoxOnToggleCallback&) = delete;
    CheckBoxOnToggleCallback& operator=(const CheckBoxOnToggleCallback&) = delete;

public:
    explicit CheckBoxOnToggleCallback(AzCheckBoxOnToggleCallback inner) noexcept : inner_(inner) {}

    CheckBoxOnToggleCallback(CheckBoxOnToggleCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CheckBoxOnToggleCallback& operator=(CheckBoxOnToggleCallback&& other) noexcept {
        if (this != &other) {
            AzCheckBoxOnToggleCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CheckBoxOnToggleCallback() { AzCheckBoxOnToggleCallback_delete(&inner_); }

    void delete_();
    CheckBoxOnToggleCallback clone() const;
    bool partialEq(const CheckBoxOnToggleCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CheckBoxOnToggleCallback& b) const;
    uint8_t cmp(const CheckBoxOnToggleCallback& b) const;
    String toDbgString() const;

    const AzCheckBoxOnToggleCallback& inner() const { return inner_; }
    AzCheckBoxOnToggleCallback& inner() { return inner_; }
    const AzCheckBoxOnToggleCallback* ptr() const { return &inner_; }
    AzCheckBoxOnToggleCallback* ptr() { return &inner_; }
    AzCheckBoxOnToggleCallback release() { AzCheckBoxOnToggleCallback result = inner_; inner_ = {}; return result; }
    operator AzCheckBoxOnToggleCallback() && noexcept { AzCheckBoxOnToggleCallback result = inner_; inner_ = {}; return result; }
};

class DropDownOnChoiceChangeCallback {
private:
    AzDropDownOnChoiceChangeCallback inner_;

    DropDownOnChoiceChangeCallback(const DropDownOnChoiceChangeCallback&) = delete;
    DropDownOnChoiceChangeCallback& operator=(const DropDownOnChoiceChangeCallback&) = delete;

public:
    explicit DropDownOnChoiceChangeCallback(AzDropDownOnChoiceChangeCallback inner) noexcept : inner_(inner) {}

    DropDownOnChoiceChangeCallback(DropDownOnChoiceChangeCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DropDownOnChoiceChangeCallback& operator=(DropDownOnChoiceChangeCallback&& other) noexcept {
        if (this != &other) {
            AzDropDownOnChoiceChangeCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DropDownOnChoiceChangeCallback() { AzDropDownOnChoiceChangeCallback_delete(&inner_); }

    void delete_();
    DropDownOnChoiceChangeCallback clone() const;
    bool partialEq(const DropDownOnChoiceChangeCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const DropDownOnChoiceChangeCallback& b) const;
    uint8_t cmp(const DropDownOnChoiceChangeCallback& b) const;
    String toDbgString() const;

    const AzDropDownOnChoiceChangeCallback& inner() const { return inner_; }
    AzDropDownOnChoiceChangeCallback& inner() { return inner_; }
    const AzDropDownOnChoiceChangeCallback* ptr() const { return &inner_; }
    AzDropDownOnChoiceChangeCallback* ptr() { return &inner_; }
    AzDropDownOnChoiceChangeCallback release() { AzDropDownOnChoiceChangeCallback result = inner_; inner_ = {}; return result; }
    operator AzDropDownOnChoiceChangeCallback() && noexcept { AzDropDownOnChoiceChangeCallback result = inner_; inner_ = {}; return result; }
};

class TabOnClickCallback {
private:
    AzTabOnClickCallback inner_;

    TabOnClickCallback(const TabOnClickCallback&) = delete;
    TabOnClickCallback& operator=(const TabOnClickCallback&) = delete;

public:
    explicit TabOnClickCallback(AzTabOnClickCallback inner) noexcept : inner_(inner) {}

    TabOnClickCallback(TabOnClickCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TabOnClickCallback& operator=(TabOnClickCallback&& other) noexcept {
        if (this != &other) {
            AzTabOnClickCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TabOnClickCallback() { AzTabOnClickCallback_delete(&inner_); }

    void delete_();
    TabOnClickCallback clone() const;
    bool partialEq(const TabOnClickCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TabOnClickCallback& b) const;
    uint8_t cmp(const TabOnClickCallback& b) const;
    String toDbgString() const;

    const AzTabOnClickCallback& inner() const { return inner_; }
    AzTabOnClickCallback& inner() { return inner_; }
    const AzTabOnClickCallback* ptr() const { return &inner_; }
    AzTabOnClickCallback* ptr() { return &inner_; }
    AzTabOnClickCallback release() { AzTabOnClickCallback result = inner_; inner_ = {}; return result; }
    operator AzTabOnClickCallback() && noexcept { AzTabOnClickCallback result = inner_; inner_ = {}; return result; }
};

class ListViewOnLazyLoadScrollCallback {
private:
    AzListViewOnLazyLoadScrollCallback inner_;

    ListViewOnLazyLoadScrollCallback(const ListViewOnLazyLoadScrollCallback&) = delete;
    ListViewOnLazyLoadScrollCallback& operator=(const ListViewOnLazyLoadScrollCallback&) = delete;

public:
    explicit ListViewOnLazyLoadScrollCallback(AzListViewOnLazyLoadScrollCallback inner) noexcept : inner_(inner) {}

    ListViewOnLazyLoadScrollCallback(ListViewOnLazyLoadScrollCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ListViewOnLazyLoadScrollCallback& operator=(ListViewOnLazyLoadScrollCallback&& other) noexcept {
        if (this != &other) {
            AzListViewOnLazyLoadScrollCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ListViewOnLazyLoadScrollCallback() { AzListViewOnLazyLoadScrollCallback_delete(&inner_); }

    void delete_();
    ListViewOnLazyLoadScrollCallback clone() const;
    bool partialEq(const ListViewOnLazyLoadScrollCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ListViewOnLazyLoadScrollCallback& b) const;
    uint8_t cmp(const ListViewOnLazyLoadScrollCallback& b) const;
    String toDbgString() const;

    const AzListViewOnLazyLoadScrollCallback& inner() const { return inner_; }
    AzListViewOnLazyLoadScrollCallback& inner() { return inner_; }
    const AzListViewOnLazyLoadScrollCallback* ptr() const { return &inner_; }
    AzListViewOnLazyLoadScrollCallback* ptr() { return &inner_; }
    AzListViewOnLazyLoadScrollCallback release() { AzListViewOnLazyLoadScrollCallback result = inner_; inner_ = {}; return result; }
    operator AzListViewOnLazyLoadScrollCallback() && noexcept { AzListViewOnLazyLoadScrollCallback result = inner_; inner_ = {}; return result; }
};

class ButtonOnClickCallback {
private:
    AzButtonOnClickCallback inner_;

    ButtonOnClickCallback(const ButtonOnClickCallback&) = delete;
    ButtonOnClickCallback& operator=(const ButtonOnClickCallback&) = delete;

public:
    explicit ButtonOnClickCallback(AzButtonOnClickCallback inner) noexcept : inner_(inner) {}

    ButtonOnClickCallback(ButtonOnClickCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ButtonOnClickCallback& operator=(ButtonOnClickCallback&& other) noexcept {
        if (this != &other) {
            AzButtonOnClickCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ButtonOnClickCallback() { AzButtonOnClickCallback_delete(&inner_); }

    void delete_();
    ButtonOnClickCallback clone() const;
    bool partialEq(const ButtonOnClickCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ButtonOnClickCallback& b) const;
    uint8_t cmp(const ButtonOnClickCallback& b) const;
    String toDbgString() const;

    const AzButtonOnClickCallback& inner() const { return inner_; }
    AzButtonOnClickCallback& inner() { return inner_; }
    const AzButtonOnClickCallback* ptr() const { return &inner_; }
    AzButtonOnClickCallback* ptr() { return &inner_; }
    AzButtonOnClickCallback release() { AzButtonOnClickCallback result = inner_; inner_ = {}; return result; }
    operator AzButtonOnClickCallback() && noexcept { AzButtonOnClickCallback result = inner_; inner_ = {}; return result; }
};

class XmlAttributeMap {
private:
    AzXmlAttributeMap inner_;

    XmlAttributeMap(const XmlAttributeMap&) = delete;
    XmlAttributeMap& operator=(const XmlAttributeMap&) = delete;

public:
    explicit XmlAttributeMap(AzXmlAttributeMap inner) noexcept : inner_(inner) {}

    XmlAttributeMap(XmlAttributeMap&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    XmlAttributeMap& operator=(XmlAttributeMap&& other) noexcept {
        if (this != &other) {
            AzXmlAttributeMap_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~XmlAttributeMap() { AzXmlAttributeMap_delete(&inner_); }

    [[nodiscard]] static XmlAttributeMap default_();

    void delete_();
    XmlAttributeMap clone() const;
    bool partialEq(const XmlAttributeMap& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const XmlAttributeMap& b) const;
    uint8_t cmp(const XmlAttributeMap& b) const;
    String toDbgString() const;

    const AzXmlAttributeMap& inner() const { return inner_; }
    AzXmlAttributeMap& inner() { return inner_; }
    const AzXmlAttributeMap* ptr() const { return &inner_; }
    AzXmlAttributeMap* ptr() { return &inner_; }
    AzXmlAttributeMap release() { AzXmlAttributeMap result = inner_; inner_ = {}; return result; }
    operator AzXmlAttributeMap() && noexcept { AzXmlAttributeMap result = inner_; inner_ = {}; return result; }
};

class Callback {
private:
    AzCallback inner_;

    Callback(const Callback&) = delete;
    Callback& operator=(const Callback&) = delete;

public:
    explicit Callback(AzCallback inner) noexcept : inner_(inner) {}

    Callback(Callback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Callback& operator=(Callback&& other) noexcept {
        if (this != &other) {
            AzCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Callback() { AzCallback_delete(&inner_); }

    [[nodiscard]] static Callback create(AzCallbackType cb);

    CoreCallback to_core() const;
    void delete_();
    Callback clone() const;
    bool partialEq(const Callback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const Callback& b) const;
    uint8_t cmp(const Callback& b) const;
    String toDbgString() const;

    const AzCallback& inner() const { return inner_; }
    AzCallback& inner() { return inner_; }
    const AzCallback* ptr() const { return &inner_; }
    AzCallback* ptr() { return &inner_; }
    AzCallback release() { AzCallback result = inner_; inner_ = {}; return result; }
    operator AzCallback() && noexcept { AzCallback result = inner_; inner_ = {}; return result; }
};

class KeyboardState {
private:
    AzKeyboardState inner_;

    KeyboardState(const KeyboardState&) = delete;
    KeyboardState& operator=(const KeyboardState&) = delete;

public:
    explicit KeyboardState(AzKeyboardState inner) noexcept : inner_(inner) {}

    KeyboardState(KeyboardState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    KeyboardState& operator=(KeyboardState&& other) noexcept {
        if (this != &other) {
            AzKeyboardState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~KeyboardState() { AzKeyboardState_delete(&inner_); }

    [[nodiscard]] static KeyboardState default_();

    void delete_();
    KeyboardState clone() const;
    bool partialEq(const KeyboardState& b) const;
    String toDbgString() const;

    const AzKeyboardState& inner() const { return inner_; }
    AzKeyboardState& inner() { return inner_; }
    const AzKeyboardState* ptr() const { return &inner_; }
    AzKeyboardState* ptr() { return &inner_; }
    AzKeyboardState release() { AzKeyboardState result = inner_; inner_ = {}; return result; }
    operator AzKeyboardState() && noexcept { AzKeyboardState result = inner_; inner_ = {}; return result; }
};

class TouchState {
private:
    AzTouchState inner_;

    TouchState(const TouchState&) = delete;
    TouchState& operator=(const TouchState&) = delete;

public:
    explicit TouchState(AzTouchState inner) noexcept : inner_(inner) {}

    TouchState(TouchState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TouchState& operator=(TouchState&& other) noexcept {
        if (this != &other) {
            AzTouchState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TouchState() { AzTouchState_delete(&inner_); }

    [[nodiscard]] static TouchState default_();

    void delete_();
    TouchState clone() const;
    bool partialEq(const TouchState& b) const;
    String toDbgString() const;

    const AzTouchState& inner() const { return inner_; }
    AzTouchState& inner() { return inner_; }
    const AzTouchState* ptr() const { return &inner_; }
    AzTouchState* ptr() { return &inner_; }
    AzTouchState release() { AzTouchState result = inner_; inner_ = {}; return result; }
    operator AzTouchState() && noexcept { AzTouchState result = inner_; inner_ = {}; return result; }
};

class CoreRenderImageCallback {
private:
    AzCoreRenderImageCallback inner_;

    CoreRenderImageCallback(const CoreRenderImageCallback&) = delete;
    CoreRenderImageCallback& operator=(const CoreRenderImageCallback&) = delete;

public:
    explicit CoreRenderImageCallback(AzCoreRenderImageCallback inner) noexcept : inner_(inner) {}

    CoreRenderImageCallback(CoreRenderImageCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CoreRenderImageCallback& operator=(CoreRenderImageCallback&& other) noexcept {
        if (this != &other) {
            AzCoreRenderImageCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CoreRenderImageCallback() { AzCoreRenderImageCallback_delete(&inner_); }

    void delete_();
    CoreRenderImageCallback clone() const;
    bool partialEq(const CoreRenderImageCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CoreRenderImageCallback& b) const;
    uint8_t cmp(const CoreRenderImageCallback& b) const;
    String toDbgString() const;

    const AzCoreRenderImageCallback& inner() const { return inner_; }
    AzCoreRenderImageCallback& inner() { return inner_; }
    const AzCoreRenderImageCallback* ptr() const { return &inner_; }
    AzCoreRenderImageCallback* ptr() { return &inner_; }
    AzCoreRenderImageCallback release() { AzCoreRenderImageCallback result = inner_; inner_ = {}; return result; }
    operator AzCoreRenderImageCallback() && noexcept { AzCoreRenderImageCallback result = inner_; inner_ = {}; return result; }
};

class VirtualKeyCodeCombo {
private:
    AzVirtualKeyCodeCombo inner_;

    VirtualKeyCodeCombo(const VirtualKeyCodeCombo&) = delete;
    VirtualKeyCodeCombo& operator=(const VirtualKeyCodeCombo&) = delete;

public:
    explicit VirtualKeyCodeCombo(AzVirtualKeyCodeCombo inner) noexcept : inner_(inner) {}

    VirtualKeyCodeCombo(VirtualKeyCodeCombo&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VirtualKeyCodeCombo& operator=(VirtualKeyCodeCombo&& other) noexcept {
        if (this != &other) {
            AzVirtualKeyCodeCombo_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VirtualKeyCodeCombo() { AzVirtualKeyCodeCombo_delete(&inner_); }

    void delete_();
    VirtualKeyCodeCombo clone() const;
    bool partialEq(const VirtualKeyCodeCombo& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const VirtualKeyCodeCombo& b) const;
    uint8_t cmp(const VirtualKeyCodeCombo& b) const;
    String toDbgString() const;

    const AzVirtualKeyCodeCombo& inner() const { return inner_; }
    AzVirtualKeyCodeCombo& inner() { return inner_; }
    const AzVirtualKeyCodeCombo* ptr() const { return &inner_; }
    AzVirtualKeyCodeCombo* ptr() { return &inner_; }
    AzVirtualKeyCodeCombo release() { AzVirtualKeyCodeCombo result = inner_; inner_ = {}; return result; }
    operator AzVirtualKeyCodeCombo() && noexcept { AzVirtualKeyCodeCombo result = inner_; inner_ = {}; return result; }
};

class TextInputOnVirtualKeyDownCallback {
private:
    AzTextInputOnVirtualKeyDownCallback inner_;

    TextInputOnVirtualKeyDownCallback(const TextInputOnVirtualKeyDownCallback&) = delete;
    TextInputOnVirtualKeyDownCallback& operator=(const TextInputOnVirtualKeyDownCallback&) = delete;

public:
    explicit TextInputOnVirtualKeyDownCallback(AzTextInputOnVirtualKeyDownCallback inner) noexcept : inner_(inner) {}

    TextInputOnVirtualKeyDownCallback(TextInputOnVirtualKeyDownCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextInputOnVirtualKeyDownCallback& operator=(TextInputOnVirtualKeyDownCallback&& other) noexcept {
        if (this != &other) {
            AzTextInputOnVirtualKeyDownCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextInputOnVirtualKeyDownCallback() { AzTextInputOnVirtualKeyDownCallback_delete(&inner_); }

    void delete_();
    TextInputOnVirtualKeyDownCallback clone() const;
    bool partialEq(const TextInputOnVirtualKeyDownCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TextInputOnVirtualKeyDownCallback& b) const;
    uint8_t cmp(const TextInputOnVirtualKeyDownCallback& b) const;
    String toDbgString() const;

    const AzTextInputOnVirtualKeyDownCallback& inner() const { return inner_; }
    AzTextInputOnVirtualKeyDownCallback& inner() { return inner_; }
    const AzTextInputOnVirtualKeyDownCallback* ptr() const { return &inner_; }
    AzTextInputOnVirtualKeyDownCallback* ptr() { return &inner_; }
    AzTextInputOnVirtualKeyDownCallback release() { AzTextInputOnVirtualKeyDownCallback result = inner_; inner_ = {}; return result; }
    operator AzTextInputOnVirtualKeyDownCallback() && noexcept { AzTextInputOnVirtualKeyDownCallback result = inner_; inner_ = {}; return result; }
};

class SelectionState {
private:
    AzSelectionState inner_;

    SelectionState(const SelectionState&) = delete;
    SelectionState& operator=(const SelectionState&) = delete;

public:
    explicit SelectionState(AzSelectionState inner) noexcept : inner_(inner) {}

    SelectionState(SelectionState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SelectionState& operator=(SelectionState&& other) noexcept {
        if (this != &other) {
            AzSelectionState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SelectionState() { AzSelectionState_delete(&inner_); }

    void delete_();
    SelectionState clone() const;
    bool partialEq(const SelectionState& b) const;
    String toDbgString() const;

    const AzSelectionState& inner() const { return inner_; }
    AzSelectionState& inner() { return inner_; }
    const AzSelectionState* ptr() const { return &inner_; }
    AzSelectionState* ptr() { return &inner_; }
    AzSelectionState release() { AzSelectionState result = inner_; inner_ = {}; return result; }
    operator AzSelectionState() && noexcept { AzSelectionState result = inner_; inner_ = {}; return result; }
};

class TextOpExtendSelection {
private:
    AzTextOpExtendSelection inner_;

    TextOpExtendSelection(const TextOpExtendSelection&) = delete;
    TextOpExtendSelection& operator=(const TextOpExtendSelection&) = delete;

public:
    explicit TextOpExtendSelection(AzTextOpExtendSelection inner) noexcept : inner_(inner) {}

    TextOpExtendSelection(TextOpExtendSelection&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextOpExtendSelection& operator=(TextOpExtendSelection&& other) noexcept {
        if (this != &other) {
            AzTextOpExtendSelection_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextOpExtendSelection() { AzTextOpExtendSelection_delete(&inner_); }

    void delete_();
    TextOpExtendSelection clone() const;
    String toDbgString() const;

    const AzTextOpExtendSelection& inner() const { return inner_; }
    AzTextOpExtendSelection& inner() { return inner_; }
    const AzTextOpExtendSelection* ptr() const { return &inner_; }
    AzTextOpExtendSelection* ptr() { return &inner_; }
    AzTextOpExtendSelection release() { AzTextOpExtendSelection result = inner_; inner_ = {}; return result; }
    operator AzTextOpExtendSelection() && noexcept { AzTextOpExtendSelection result = inner_; inner_ = {}; return result; }
};

class RenderImageCallback {
private:
    AzRenderImageCallback inner_;

    RenderImageCallback(const RenderImageCallback&) = delete;
    RenderImageCallback& operator=(const RenderImageCallback&) = delete;

public:
    explicit RenderImageCallback(AzRenderImageCallback inner) noexcept : inner_(inner) {}

    RenderImageCallback(RenderImageCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RenderImageCallback& operator=(RenderImageCallback&& other) noexcept {
        if (this != &other) {
            AzRenderImageCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RenderImageCallback() { AzRenderImageCallback_delete(&inner_); }

    [[nodiscard]] static RenderImageCallback create(AzRenderImageCallbackType cb);

    CoreRenderImageCallback to_core() const;
    void delete_();
    RenderImageCallback clone() const;
    bool partialEq(const RenderImageCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const RenderImageCallback& b) const;
    uint8_t cmp(const RenderImageCallback& b) const;
    String toDbgString() const;

    const AzRenderImageCallback& inner() const { return inner_; }
    AzRenderImageCallback& inner() { return inner_; }
    const AzRenderImageCallback* ptr() const { return &inner_; }
    AzRenderImageCallback* ptr() { return &inner_; }
    AzRenderImageCallback release() { AzRenderImageCallback result = inner_; inner_ = {}; return result; }
    operator AzRenderImageCallback() && noexcept { AzRenderImageCallback result = inner_; inner_ = {}; return result; }
};

class TextOpClearSelection {
private:
    AzTextOpClearSelection inner_;

    TextOpClearSelection(const TextOpClearSelection&) = delete;
    TextOpClearSelection& operator=(const TextOpClearSelection&) = delete;

public:
    explicit TextOpClearSelection(AzTextOpClearSelection inner) noexcept : inner_(inner) {}

    TextOpClearSelection(TextOpClearSelection&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextOpClearSelection& operator=(TextOpClearSelection&& other) noexcept {
        if (this != &other) {
            AzTextOpClearSelection_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextOpClearSelection() { AzTextOpClearSelection_delete(&inner_); }

    void delete_();
    TextOpClearSelection clone() const;
    String toDbgString() const;

    const AzTextOpClearSelection& inner() const { return inner_; }
    AzTextOpClearSelection& inner() { return inner_; }
    const AzTextOpClearSelection* ptr() const { return &inner_; }
    AzTextOpClearSelection* ptr() { return &inner_; }
    AzTextOpClearSelection release() { AzTextOpClearSelection result = inner_; inner_ = {}; return result; }
    operator AzTextOpClearSelection() && noexcept { AzTextOpClearSelection result = inner_; inner_ = {}; return result; }
};

class DatasetMergeCallback {
private:
    AzDatasetMergeCallback inner_;

    DatasetMergeCallback(const DatasetMergeCallback&) = delete;
    DatasetMergeCallback& operator=(const DatasetMergeCallback&) = delete;

public:
    explicit DatasetMergeCallback(AzDatasetMergeCallback inner) noexcept : inner_(inner) {}

    DatasetMergeCallback(DatasetMergeCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DatasetMergeCallback& operator=(DatasetMergeCallback&& other) noexcept {
        if (this != &other) {
            AzDatasetMergeCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DatasetMergeCallback() { AzDatasetMergeCallback_delete(&inner_); }

    [[nodiscard]] static DatasetMergeCallback from(AzDatasetMergeCallbackType cb);

    void delete_();
    DatasetMergeCallback clone() const;
    bool partialEq(const DatasetMergeCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const DatasetMergeCallback& b) const;
    uint8_t cmp(const DatasetMergeCallback& b) const;
    String toDbgString() const;

    const AzDatasetMergeCallback& inner() const { return inner_; }
    AzDatasetMergeCallback& inner() { return inner_; }
    const AzDatasetMergeCallback* ptr() const { return &inner_; }
    AzDatasetMergeCallback* ptr() { return &inner_; }
    AzDatasetMergeCallback release() { AzDatasetMergeCallback result = inner_; inner_ = {}; return result; }
    operator AzDatasetMergeCallback() && noexcept { AzDatasetMergeCallback result = inner_; inner_ = {}; return result; }
};

class FocusVisuals {
private:
    AzFocusVisuals inner_;

public:
    FocusVisuals(AzFocusVisuals inner) noexcept : inner_(inner) {}
    FocusVisuals(const FocusVisuals& other) noexcept : inner_(other.inner_) {}
    FocusVisuals& operator=(const FocusVisuals& other) noexcept { inner_ = other.inner_; return *this; }
    ~FocusVisuals() {}

    [[nodiscard]] static FocusVisuals default_();

    bool partialEq(const FocusVisuals& b) const;
    String toDbgString() const;

    const AzFocusVisuals& inner() const { return inner_; }
    AzFocusVisuals& inner() { return inner_; }
    const AzFocusVisuals* ptr() const { return &inner_; }
    AzFocusVisuals* ptr() { return &inner_; }
    AzFocusVisuals release() { AzFocusVisuals result = inner_; inner_ = {}; return result; }
    operator AzFocusVisuals() && noexcept { AzFocusVisuals result = inner_; inner_ = {}; return result; }
};

class DragData {
private:
    AzDragData inner_;

    DragData(const DragData&) = delete;
    DragData& operator=(const DragData&) = delete;

public:
    explicit DragData(AzDragData inner) noexcept : inner_(inner) {}

    DragData(DragData&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DragData& operator=(DragData&& other) noexcept {
        if (this != &other) {
            AzDragData_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DragData() { AzDragData_delete(&inner_); }

    [[nodiscard]] static DragData new_();
    [[nodiscard]] static DragData default_();

    void set_data(String mime_type, U8Vec data);
    void delete_();
    DragData clone() const;
    bool partialEq(const DragData& b) const;
    String toDbgString() const;

    const AzDragData& inner() const { return inner_; }
    AzDragData& inner() { return inner_; }
    const AzDragData* ptr() const { return &inner_; }
    AzDragData* ptr() { return &inner_; }
    AzDragData release() { AzDragData result = inner_; inner_ = {}; return result; }
    operator AzDragData() && noexcept { AzDragData result = inner_; inner_ = {}; return result; }
};

class VirtualViewCallback {
private:
    AzVirtualViewCallback inner_;

    VirtualViewCallback(const VirtualViewCallback&) = delete;
    VirtualViewCallback& operator=(const VirtualViewCallback&) = delete;

public:
    explicit VirtualViewCallback(AzVirtualViewCallback inner) noexcept : inner_(inner) {}

    VirtualViewCallback(VirtualViewCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VirtualViewCallback& operator=(VirtualViewCallback&& other) noexcept {
        if (this != &other) {
            AzVirtualViewCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VirtualViewCallback() { AzVirtualViewCallback_delete(&inner_); }

    void delete_();
    VirtualViewCallback clone() const;
    bool partialEq(const VirtualViewCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const VirtualViewCallback& b) const;
    uint8_t cmp(const VirtualViewCallback& b) const;
    String toDbgString() const;

    const AzVirtualViewCallback& inner() const { return inner_; }
    AzVirtualViewCallback& inner() { return inner_; }
    const AzVirtualViewCallback* ptr() const { return &inner_; }
    AzVirtualViewCallback* ptr() { return &inner_; }
    AzVirtualViewCallback release() { AzVirtualViewCallback result = inner_; inner_ = {}; return result; }
    operator AzVirtualViewCallback() && noexcept { AzVirtualViewCallback result = inner_; inner_ = {}; return result; }
};

class RibbonOnTabClickCallback {
private:
    AzRibbonOnTabClickCallback inner_;

    RibbonOnTabClickCallback(const RibbonOnTabClickCallback&) = delete;
    RibbonOnTabClickCallback& operator=(const RibbonOnTabClickCallback&) = delete;

public:
    explicit RibbonOnTabClickCallback(AzRibbonOnTabClickCallback inner) noexcept : inner_(inner) {}

    RibbonOnTabClickCallback(RibbonOnTabClickCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RibbonOnTabClickCallback& operator=(RibbonOnTabClickCallback&& other) noexcept {
        if (this != &other) {
            AzRibbonOnTabClickCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RibbonOnTabClickCallback() { AzRibbonOnTabClickCallback_delete(&inner_); }

    void delete_();
    RibbonOnTabClickCallback clone() const;
    bool partialEq(const RibbonOnTabClickCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const RibbonOnTabClickCallback& b) const;
    uint8_t cmp(const RibbonOnTabClickCallback& b) const;
    String toDbgString() const;

    const AzRibbonOnTabClickCallback& inner() const { return inner_; }
    AzRibbonOnTabClickCallback& inner() { return inner_; }
    const AzRibbonOnTabClickCallback* ptr() const { return &inner_; }
    AzRibbonOnTabClickCallback* ptr() { return &inner_; }
    AzRibbonOnTabClickCallback release() { AzRibbonOnTabClickCallback result = inner_; inner_ = {}; return result; }
    operator AzRibbonOnTabClickCallback() && noexcept { AzRibbonOnTabClickCallback result = inner_; inner_ = {}; return result; }
};

class TreeViewOnNodeClickCallback {
private:
    AzTreeViewOnNodeClickCallback inner_;

    TreeViewOnNodeClickCallback(const TreeViewOnNodeClickCallback&) = delete;
    TreeViewOnNodeClickCallback& operator=(const TreeViewOnNodeClickCallback&) = delete;

public:
    explicit TreeViewOnNodeClickCallback(AzTreeViewOnNodeClickCallback inner) noexcept : inner_(inner) {}

    TreeViewOnNodeClickCallback(TreeViewOnNodeClickCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TreeViewOnNodeClickCallback& operator=(TreeViewOnNodeClickCallback&& other) noexcept {
        if (this != &other) {
            AzTreeViewOnNodeClickCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TreeViewOnNodeClickCallback() { AzTreeViewOnNodeClickCallback_delete(&inner_); }

    void delete_();
    TreeViewOnNodeClickCallback clone() const;
    bool partialEq(const TreeViewOnNodeClickCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TreeViewOnNodeClickCallback& b) const;
    uint8_t cmp(const TreeViewOnNodeClickCallback& b) const;
    String toDbgString() const;

    const AzTreeViewOnNodeClickCallback& inner() const { return inner_; }
    AzTreeViewOnNodeClickCallback& inner() { return inner_; }
    const AzTreeViewOnNodeClickCallback* ptr() const { return &inner_; }
    AzTreeViewOnNodeClickCallback* ptr() { return &inner_; }
    AzTreeViewOnNodeClickCallback release() { AzTreeViewOnNodeClickCallback result = inner_; inner_ = {}; return result; }
    operator AzTreeViewOnNodeClickCallback() && noexcept { AzTreeViewOnNodeClickCallback result = inner_; inner_ = {}; return result; }
};

class OnVideoFrameCallback {
private:
    AzOnVideoFrameCallback inner_;

    OnVideoFrameCallback(const OnVideoFrameCallback&) = delete;
    OnVideoFrameCallback& operator=(const OnVideoFrameCallback&) = delete;

public:
    explicit OnVideoFrameCallback(AzOnVideoFrameCallback inner) noexcept : inner_(inner) {}

    OnVideoFrameCallback(OnVideoFrameCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OnVideoFrameCallback& operator=(OnVideoFrameCallback&& other) noexcept {
        if (this != &other) {
            AzOnVideoFrameCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OnVideoFrameCallback() { AzOnVideoFrameCallback_delete(&inner_); }

    void delete_();
    OnVideoFrameCallback clone() const;
    bool partialEq(const OnVideoFrameCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OnVideoFrameCallback& b) const;
    uint8_t cmp(const OnVideoFrameCallback& b) const;
    String toDbgString() const;

    const AzOnVideoFrameCallback& inner() const { return inner_; }
    AzOnVideoFrameCallback& inner() { return inner_; }
    const AzOnVideoFrameCallback* ptr() const { return &inner_; }
    AzOnVideoFrameCallback* ptr() { return &inner_; }
    AzOnVideoFrameCallback release() { AzOnVideoFrameCallback result = inner_; inner_ = {}; return result; }
    operator AzOnVideoFrameCallback() && noexcept { AzOnVideoFrameCallback result = inner_; inner_ = {}; return result; }
};

class MapPinTapCallback {
private:
    AzMapPinTapCallback inner_;

    MapPinTapCallback(const MapPinTapCallback&) = delete;
    MapPinTapCallback& operator=(const MapPinTapCallback&) = delete;

public:
    explicit MapPinTapCallback(AzMapPinTapCallback inner) noexcept : inner_(inner) {}

    MapPinTapCallback(MapPinTapCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MapPinTapCallback& operator=(MapPinTapCallback&& other) noexcept {
        if (this != &other) {
            AzMapPinTapCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MapPinTapCallback() { AzMapPinTapCallback_delete(&inner_); }

    void delete_();
    MapPinTapCallback clone() const;
    bool partialEq(const MapPinTapCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const MapPinTapCallback& b) const;
    uint8_t cmp(const MapPinTapCallback& b) const;
    String toDbgString() const;

    const AzMapPinTapCallback& inner() const { return inner_; }
    AzMapPinTapCallback& inner() { return inner_; }
    const AzMapPinTapCallback* ptr() const { return &inner_; }
    AzMapPinTapCallback* ptr() { return &inner_; }
    AzMapPinTapCallback release() { AzMapPinTapCallback result = inner_; inner_ = {}; return result; }
    operator AzMapPinTapCallback() && noexcept { AzMapPinTapCallback result = inner_; inner_ = {}; return result; }
};

class OnAudioFrameCallback {
private:
    AzOnAudioFrameCallback inner_;

    OnAudioFrameCallback(const OnAudioFrameCallback&) = delete;
    OnAudioFrameCallback& operator=(const OnAudioFrameCallback&) = delete;

public:
    explicit OnAudioFrameCallback(AzOnAudioFrameCallback inner) noexcept : inner_(inner) {}

    OnAudioFrameCallback(OnAudioFrameCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OnAudioFrameCallback& operator=(OnAudioFrameCallback&& other) noexcept {
        if (this != &other) {
            AzOnAudioFrameCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OnAudioFrameCallback() { AzOnAudioFrameCallback_delete(&inner_); }

    void delete_();
    OnAudioFrameCallback clone() const;
    bool partialEq(const OnAudioFrameCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OnAudioFrameCallback& b) const;
    uint8_t cmp(const OnAudioFrameCallback& b) const;
    String toDbgString() const;

    const AzOnAudioFrameCallback& inner() const { return inner_; }
    AzOnAudioFrameCallback& inner() { return inner_; }
    const AzOnAudioFrameCallback* ptr() const { return &inner_; }
    AzOnAudioFrameCallback* ptr() { return &inner_; }
    AzOnAudioFrameCallback release() { AzOnAudioFrameCallback result = inner_; inner_ = {}; return result; }
    operator AzOnAudioFrameCallback() && noexcept { AzOnAudioFrameCallback result = inner_; inner_ = {}; return result; }
};

class Menu {
private:
    AzMenu inner_;

    Menu(const Menu&) = delete;
    Menu& operator=(const Menu&) = delete;

public:
    explicit Menu(AzMenu inner) noexcept : inner_(inner) {}

    Menu(Menu&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Menu& operator=(Menu&& other) noexcept {
        if (this != &other) {
            AzMenu_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Menu() { AzMenu_delete(&inner_); }

    [[nodiscard]] static Menu create(MenuItemVec items);
    [[nodiscard]] static Menu default_();

    void set_popup_position(AzMenuPopupPosition position);
    Menu with_popup_position(AzMenuPopupPosition position) const;
    void delete_();
    Menu clone() const;
    bool partialEq(const Menu& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const Menu& b) const;
    uint8_t cmp(const Menu& b) const;
    String toDbgString() const;

    const AzMenu& inner() const { return inner_; }
    AzMenu& inner() { return inner_; }
    const AzMenu* ptr() const { return &inner_; }
    AzMenu* ptr() { return &inner_; }
    AzMenu release() { AzMenu result = inner_; inner_ = {}; return result; }
    operator AzMenu() && noexcept { AzMenu result = inner_; inner_ = {}; return result; }
};

class Css {
private:
    AzCss inner_;

    Css(const Css&) = delete;
    Css& operator=(const Css&) = delete;

public:
    explicit Css(AzCss inner) noexcept : inner_(inner) {}

    Css(Css&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Css& operator=(Css&& other) noexcept {
        if (this != &other) {
            AzCss_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Css() { AzCss_delete(&inner_); }

    [[nodiscard]] static Css empty();
    [[nodiscard]] static Css from_string(String s);
    [[nodiscard]] static Css default_();

    bool is_empty() const;
    void sort_by_specificity();
    void delete_();
    Css clone() const;
    bool partialEq(const Css& b) const;
    uint8_t partialCmp(const Css& b) const;
    uint8_t cmp(const Css& b) const;
    String toDbgString() const;

    const AzCss& inner() const { return inner_; }
    AzCss& inner() { return inner_; }
    const AzCss* ptr() const { return &inner_; }
    AzCss* ptr() { return &inner_; }
    AzCss release() { AzCss result = inner_; inner_ = {}; return result; }
    operator AzCss() && noexcept { AzCss result = inner_; inner_ = {}; return result; }
};

class StyleBoxShadow {
private:
    AzStyleBoxShadow inner_;

public:
    StyleBoxShadow(AzStyleBoxShadow inner) noexcept : inner_(inner) {}
    StyleBoxShadow(const StyleBoxShadow& other) noexcept : inner_(other.inner_) {}
    StyleBoxShadow& operator=(const StyleBoxShadow& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBoxShadow() {}

    [[nodiscard]] static StyleBoxShadow default_();

    bool partialEq(const StyleBoxShadow& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBoxShadow& b) const;
    uint8_t cmp(const StyleBoxShadow& b) const;
    String toDbgString() const;

    const AzStyleBoxShadow& inner() const { return inner_; }
    AzStyleBoxShadow& inner() { return inner_; }
    const AzStyleBoxShadow* ptr() const { return &inner_; }
    AzStyleBoxShadow* ptr() { return &inner_; }
    AzStyleBoxShadow release() { AzStyleBoxShadow result = inner_; inner_ = {}; return result; }
    operator AzStyleBoxShadow() && noexcept { AzStyleBoxShadow result = inner_; inner_ = {}; return result; }
};

class LinearGradient {
private:
    AzLinearGradient inner_;

    LinearGradient(const LinearGradient&) = delete;
    LinearGradient& operator=(const LinearGradient&) = delete;

public:
    explicit LinearGradient(AzLinearGradient inner) noexcept : inner_(inner) {}

    LinearGradient(LinearGradient&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    LinearGradient& operator=(LinearGradient&& other) noexcept {
        if (this != &other) {
            AzLinearGradient_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~LinearGradient() { AzLinearGradient_delete(&inner_); }

    [[nodiscard]] static LinearGradient default_();

    void delete_();
    LinearGradient clone() const;
    bool partialEq(const LinearGradient& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LinearGradient& b) const;
    uint8_t cmp(const LinearGradient& b) const;
    String toDbgString() const;

    const AzLinearGradient& inner() const { return inner_; }
    AzLinearGradient& inner() { return inner_; }
    const AzLinearGradient* ptr() const { return &inner_; }
    AzLinearGradient* ptr() { return &inner_; }
    AzLinearGradient release() { AzLinearGradient result = inner_; inner_ = {}; return result; }
    operator AzLinearGradient() && noexcept { AzLinearGradient result = inner_; inner_ = {}; return result; }
};

class StyleBackgroundPosition {
private:
    AzStyleBackgroundPosition inner_;

public:
    StyleBackgroundPosition(AzStyleBackgroundPosition inner) noexcept : inner_(inner) {}
    StyleBackgroundPosition(const StyleBackgroundPosition& other) noexcept : inner_(other.inner_) {}
    StyleBackgroundPosition& operator=(const StyleBackgroundPosition& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleBackgroundPosition() {}

    [[nodiscard]] static StyleBackgroundPosition default_();

    bool partialEq(const StyleBackgroundPosition& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleBackgroundPosition& b) const;
    uint8_t cmp(const StyleBackgroundPosition& b) const;
    String toDbgString() const;

    const AzStyleBackgroundPosition& inner() const { return inner_; }
    AzStyleBackgroundPosition& inner() { return inner_; }
    const AzStyleBackgroundPosition* ptr() const { return &inner_; }
    AzStyleBackgroundPosition* ptr() { return &inner_; }
    AzStyleBackgroundPosition release() { AzStyleBackgroundPosition result = inner_; inner_ = {}; return result; }
    operator AzStyleBackgroundPosition() && noexcept { AzStyleBackgroundPosition result = inner_; inner_ = {}; return result; }
};

class GridTemplate {
private:
    AzGridTemplate inner_;

    GridTemplate(const GridTemplate&) = delete;
    GridTemplate& operator=(const GridTemplate&) = delete;

public:
    explicit GridTemplate(AzGridTemplate inner) noexcept : inner_(inner) {}

    GridTemplate(GridTemplate&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GridTemplate& operator=(GridTemplate&& other) noexcept {
        if (this != &other) {
            AzGridTemplate_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GridTemplate() { AzGridTemplate_delete(&inner_); }

    [[nodiscard]] static GridTemplate default_();

    void delete_();
    GridTemplate clone() const;
    bool partialEq(const GridTemplate& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GridTemplate& b) const;
    uint8_t cmp(const GridTemplate& b) const;
    String toDbgString() const;

    const AzGridTemplate& inner() const { return inner_; }
    AzGridTemplate& inner() { return inner_; }
    const AzGridTemplate* ptr() const { return &inner_; }
    AzGridTemplate* ptr() { return &inner_; }
    AzGridTemplate release() { AzGridTemplate result = inner_; inner_ = {}; return result; }
    operator AzGridTemplate() && noexcept { AzGridTemplate result = inner_; inner_ = {}; return result; }
};

class GridAutoTracks {
private:
    AzGridAutoTracks inner_;

    GridAutoTracks(const GridAutoTracks&) = delete;
    GridAutoTracks& operator=(const GridAutoTracks&) = delete;

public:
    explicit GridAutoTracks(AzGridAutoTracks inner) noexcept : inner_(inner) {}

    GridAutoTracks(GridAutoTracks&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GridAutoTracks& operator=(GridAutoTracks&& other) noexcept {
        if (this != &other) {
            AzGridAutoTracks_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GridAutoTracks() { AzGridAutoTracks_delete(&inner_); }

    [[nodiscard]] static GridAutoTracks default_();

    void delete_();
    GridAutoTracks clone() const;
    bool partialEq(const GridAutoTracks& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GridAutoTracks& b) const;
    uint8_t cmp(const GridAutoTracks& b) const;
    String toDbgString() const;

    const AzGridAutoTracks& inner() const { return inner_; }
    AzGridAutoTracks& inner() { return inner_; }
    const AzGridAutoTracks* ptr() const { return &inner_; }
    AzGridAutoTracks* ptr() { return &inner_; }
    AzGridAutoTracks release() { AzGridAutoTracks result = inner_; inner_ = {}; return result; }
    operator AzGridAutoTracks() && noexcept { AzGridAutoTracks result = inner_; inner_ = {}; return result; }
};

class StyledDom {
private:
    AzStyledDom inner_;

    StyledDom(const StyledDom&) = delete;
    StyledDom& operator=(const StyledDom&) = delete;

public:
    explicit StyledDom(AzStyledDom inner) noexcept : inner_(inner) {}

    StyledDom(StyledDom&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyledDom& operator=(StyledDom&& other) noexcept {
        if (this != &other) {
            AzStyledDom_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyledDom() { AzStyledDom_delete(&inner_); }

    [[nodiscard]] static StyledDom default_();

    void append_child(StyledDom other);
    StyledDom with_child(StyledDom other) const;
    size_t node_count() const;
    void set_menu_bar(Menu menu_bar);
    StyledDom with_menu_bar(Menu menu_bar) const;
    void set_context_menu(Menu context_menu);
    StyledDom with_context_menu(Menu context_menu) const;
    ContentGroup get_rects_in_rendering_order() const;
    StyledDom swap_with_default();
    void delete_();
    StyledDom clone() const;
    bool partialEq(const StyledDom& b) const;
    String toDbgString() const;

    const AzStyledDom& inner() const { return inner_; }
    AzStyledDom& inner() { return inner_; }
    const AzStyledDom* ptr() const { return &inner_; }
    AzStyledDom* ptr() { return &inner_; }
    AzStyledDom release() { AzStyledDom result = inner_; inner_ = {}; return result; }
    operator AzStyledDom() && noexcept { AzStyledDom result = inner_; inner_ = {}; return result; }
};

class VertexLayout {
private:
    AzVertexLayout inner_;

    VertexLayout(const VertexLayout&) = delete;
    VertexLayout& operator=(const VertexLayout&) = delete;

public:
    explicit VertexLayout(AzVertexLayout inner) noexcept : inner_(inner) {}

    VertexLayout(VertexLayout&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VertexLayout& operator=(VertexLayout&& other) noexcept {
        if (this != &other) {
            AzVertexLayout_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VertexLayout() { AzVertexLayout_delete(&inner_); }

    void delete_();
    VertexLayout clone() const;
    bool partialEq(const VertexLayout& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const VertexLayout& b) const;
    uint8_t cmp(const VertexLayout& b) const;
    String toDbgString() const;

    const AzVertexLayout& inner() const { return inner_; }
    AzVertexLayout& inner() { return inner_; }
    const AzVertexLayout* ptr() const { return &inner_; }
    AzVertexLayout* ptr() { return &inner_; }
    AzVertexLayout release() { AzVertexLayout result = inner_; inner_ = {}; return result; }
    operator AzVertexLayout() && noexcept { AzVertexLayout result = inner_; inner_ = {}; return result; }
};

class ContentGroup {
private:
    AzContentGroup inner_;

    ContentGroup(const ContentGroup&) = delete;
    ContentGroup& operator=(const ContentGroup&) = delete;

public:
    explicit ContentGroup(AzContentGroup inner) noexcept : inner_(inner) {}

    ContentGroup(ContentGroup&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ContentGroup& operator=(ContentGroup&& other) noexcept {
        if (this != &other) {
            AzContentGroup_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ContentGroup() { AzContentGroup_delete(&inner_); }

    void delete_();
    ContentGroup clone() const;
    bool partialEq(const ContentGroup& b) const;
    uint8_t partialCmp(const ContentGroup& b) const;
    String toDbgString() const;

    const AzContentGroup& inner() const { return inner_; }
    AzContentGroup& inner() { return inner_; }
    const AzContentGroup* ptr() const { return &inner_; }
    AzContentGroup* ptr() { return &inner_; }
    AzContentGroup release() { AzContentGroup result = inner_; inner_ = {}; return result; }
    operator AzContentGroup() && noexcept { AzContentGroup result = inner_; inner_ = {}; return result; }
};

class SafeAreaInsets {
private:
    AzSafeAreaInsets inner_;

public:
    SafeAreaInsets(AzSafeAreaInsets inner) noexcept : inner_(inner) {}
    SafeAreaInsets(const SafeAreaInsets& other) noexcept : inner_(other.inner_) {}
    SafeAreaInsets& operator=(const SafeAreaInsets& other) noexcept { inner_ = other.inner_; return *this; }
    ~SafeAreaInsets() {}

    [[nodiscard]] static SafeAreaInsets default_();

    bool partialEq(const SafeAreaInsets& b) const;
    String toDbgString() const;

    const AzSafeAreaInsets& inner() const { return inner_; }
    AzSafeAreaInsets& inner() { return inner_; }
    const AzSafeAreaInsets* ptr() const { return &inner_; }
    AzSafeAreaInsets* ptr() { return &inner_; }
    AzSafeAreaInsets release() { AzSafeAreaInsets result = inner_; inner_ = {}; return result; }
    operator AzSafeAreaInsets() && noexcept { AzSafeAreaInsets result = inner_; inner_ = {}; return result; }
};

class GridTemplateAreas {
private:
    AzGridTemplateAreas inner_;

    GridTemplateAreas(const GridTemplateAreas&) = delete;
    GridTemplateAreas& operator=(const GridTemplateAreas&) = delete;

public:
    explicit GridTemplateAreas(AzGridTemplateAreas inner) noexcept : inner_(inner) {}

    GridTemplateAreas(GridTemplateAreas&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GridTemplateAreas& operator=(GridTemplateAreas&& other) noexcept {
        if (this != &other) {
            AzGridTemplateAreas_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GridTemplateAreas() { AzGridTemplateAreas_delete(&inner_); }

    [[nodiscard]] static GridTemplateAreas default_();

    void delete_();
    GridTemplateAreas clone() const;
    bool partialEq(const GridTemplateAreas& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GridTemplateAreas& b) const;
    uint8_t cmp(const GridTemplateAreas& b) const;
    String toDbgString() const;

    const AzGridTemplateAreas& inner() const { return inner_; }
    AzGridTemplateAreas& inner() { return inner_; }
    const AzGridTemplateAreas* ptr() const { return &inner_; }
    AzGridTemplateAreas* ptr() { return &inner_; }
    AzGridTemplateAreas release() { AzGridTemplateAreas result = inner_; inner_ = {}; return result; }
    operator AzGridTemplateAreas() && noexcept { AzGridTemplateAreas result = inner_; inner_ = {}; return result; }
};

class StyleObjectPosition {
private:
    AzStyleObjectPosition inner_;

public:
    StyleObjectPosition(AzStyleObjectPosition inner) noexcept : inner_(inner) {}
    StyleObjectPosition(const StyleObjectPosition& other) noexcept : inner_(other.inner_) {}
    StyleObjectPosition& operator=(const StyleObjectPosition& other) noexcept { inner_ = other.inner_; return *this; }
    ~StyleObjectPosition() {}

    [[nodiscard]] static StyleObjectPosition default_();

    bool partialEq(const StyleObjectPosition& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleObjectPosition& b) const;
    uint8_t cmp(const StyleObjectPosition& b) const;
    String toDbgString() const;

    const AzStyleObjectPosition& inner() const { return inner_; }
    AzStyleObjectPosition& inner() { return inner_; }
    const AzStyleObjectPosition* ptr() const { return &inner_; }
    AzStyleObjectPosition* ptr() { return &inner_; }
    AzStyleObjectPosition release() { AzStyleObjectPosition result = inner_; inner_ = {}; return result; }
    operator AzStyleObjectPosition() && noexcept { AzStyleObjectPosition result = inner_; inner_ = {}; return result; }
};

class FileInputOnPathChangeCallback {
private:
    AzFileInputOnPathChangeCallback inner_;

    FileInputOnPathChangeCallback(const FileInputOnPathChangeCallback&) = delete;
    FileInputOnPathChangeCallback& operator=(const FileInputOnPathChangeCallback&) = delete;

public:
    explicit FileInputOnPathChangeCallback(AzFileInputOnPathChangeCallback inner) noexcept : inner_(inner) {}

    FileInputOnPathChangeCallback(FileInputOnPathChangeCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FileInputOnPathChangeCallback& operator=(FileInputOnPathChangeCallback&& other) noexcept {
        if (this != &other) {
            AzFileInputOnPathChangeCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FileInputOnPathChangeCallback() { AzFileInputOnPathChangeCallback_delete(&inner_); }

    void delete_();
    FileInputOnPathChangeCallback clone() const;
    bool partialEq(const FileInputOnPathChangeCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const FileInputOnPathChangeCallback& b) const;
    uint8_t cmp(const FileInputOnPathChangeCallback& b) const;
    String toDbgString() const;

    const AzFileInputOnPathChangeCallback& inner() const { return inner_; }
    AzFileInputOnPathChangeCallback& inner() { return inner_; }
    const AzFileInputOnPathChangeCallback* ptr() const { return &inner_; }
    AzFileInputOnPathChangeCallback* ptr() { return &inner_; }
    AzFileInputOnPathChangeCallback release() { AzFileInputOnPathChangeCallback result = inner_; inner_ = {}; return result; }
    operator AzFileInputOnPathChangeCallback() && noexcept { AzFileInputOnPathChangeCallback result = inner_; inner_ = {}; return result; }
};

class ColorInputOnValueChangeCallback {
private:
    AzColorInputOnValueChangeCallback inner_;

    ColorInputOnValueChangeCallback(const ColorInputOnValueChangeCallback&) = delete;
    ColorInputOnValueChangeCallback& operator=(const ColorInputOnValueChangeCallback&) = delete;

public:
    explicit ColorInputOnValueChangeCallback(AzColorInputOnValueChangeCallback inner) noexcept : inner_(inner) {}

    ColorInputOnValueChangeCallback(ColorInputOnValueChangeCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ColorInputOnValueChangeCallback& operator=(ColorInputOnValueChangeCallback&& other) noexcept {
        if (this != &other) {
            AzColorInputOnValueChangeCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ColorInputOnValueChangeCallback() { AzColorInputOnValueChangeCallback_delete(&inner_); }

    void delete_();
    ColorInputOnValueChangeCallback clone() const;
    bool partialEq(const ColorInputOnValueChangeCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ColorInputOnValueChangeCallback& b) const;
    uint8_t cmp(const ColorInputOnValueChangeCallback& b) const;
    String toDbgString() const;

    const AzColorInputOnValueChangeCallback& inner() const { return inner_; }
    AzColorInputOnValueChangeCallback& inner() { return inner_; }
    const AzColorInputOnValueChangeCallback* ptr() const { return &inner_; }
    AzColorInputOnValueChangeCallback* ptr() { return &inner_; }
    AzColorInputOnValueChangeCallback release() { AzColorInputOnValueChangeCallback result = inner_; inner_ = {}; return result; }
    operator AzColorInputOnValueChangeCallback() && noexcept { AzColorInputOnValueChangeCallback result = inner_; inner_ = {}; return result; }
};

class TextInputOnTextInputCallback {
private:
    AzTextInputOnTextInputCallback inner_;

    TextInputOnTextInputCallback(const TextInputOnTextInputCallback&) = delete;
    TextInputOnTextInputCallback& operator=(const TextInputOnTextInputCallback&) = delete;

public:
    explicit TextInputOnTextInputCallback(AzTextInputOnTextInputCallback inner) noexcept : inner_(inner) {}

    TextInputOnTextInputCallback(TextInputOnTextInputCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextInputOnTextInputCallback& operator=(TextInputOnTextInputCallback&& other) noexcept {
        if (this != &other) {
            AzTextInputOnTextInputCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextInputOnTextInputCallback() { AzTextInputOnTextInputCallback_delete(&inner_); }

    void delete_();
    TextInputOnTextInputCallback clone() const;
    bool partialEq(const TextInputOnTextInputCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TextInputOnTextInputCallback& b) const;
    uint8_t cmp(const TextInputOnTextInputCallback& b) const;
    String toDbgString() const;

    const AzTextInputOnTextInputCallback& inner() const { return inner_; }
    AzTextInputOnTextInputCallback& inner() { return inner_; }
    const AzTextInputOnTextInputCallback* ptr() const { return &inner_; }
    AzTextInputOnTextInputCallback* ptr() { return &inner_; }
    AzTextInputOnTextInputCallback release() { AzTextInputOnTextInputCallback result = inner_; inner_ = {}; return result; }
    operator AzTextInputOnTextInputCallback() && noexcept { AzTextInputOnTextInputCallback result = inner_; inner_ = {}; return result; }
};

class TextInputOnFocusLostCallback {
private:
    AzTextInputOnFocusLostCallback inner_;

    TextInputOnFocusLostCallback(const TextInputOnFocusLostCallback&) = delete;
    TextInputOnFocusLostCallback& operator=(const TextInputOnFocusLostCallback&) = delete;

public:
    explicit TextInputOnFocusLostCallback(AzTextInputOnFocusLostCallback inner) noexcept : inner_(inner) {}

    TextInputOnFocusLostCallback(TextInputOnFocusLostCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextInputOnFocusLostCallback& operator=(TextInputOnFocusLostCallback&& other) noexcept {
        if (this != &other) {
            AzTextInputOnFocusLostCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextInputOnFocusLostCallback() { AzTextInputOnFocusLostCallback_delete(&inner_); }

    void delete_();
    TextInputOnFocusLostCallback clone() const;
    bool partialEq(const TextInputOnFocusLostCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TextInputOnFocusLostCallback& b) const;
    uint8_t cmp(const TextInputOnFocusLostCallback& b) const;
    String toDbgString() const;

    const AzTextInputOnFocusLostCallback& inner() const { return inner_; }
    AzTextInputOnFocusLostCallback& inner() { return inner_; }
    const AzTextInputOnFocusLostCallback* ptr() const { return &inner_; }
    AzTextInputOnFocusLostCallback* ptr() { return &inner_; }
    AzTextInputOnFocusLostCallback release() { AzTextInputOnFocusLostCallback result = inner_; inner_ = {}; return result; }
    operator AzTextInputOnFocusLostCallback() && noexcept { AzTextInputOnFocusLostCallback result = inner_; inner_ = {}; return result; }
};

class NumberInputOnValueChangeCallback {
private:
    AzNumberInputOnValueChangeCallback inner_;

    NumberInputOnValueChangeCallback(const NumberInputOnValueChangeCallback&) = delete;
    NumberInputOnValueChangeCallback& operator=(const NumberInputOnValueChangeCallback&) = delete;

public:
    explicit NumberInputOnValueChangeCallback(AzNumberInputOnValueChangeCallback inner) noexcept : inner_(inner) {}

    NumberInputOnValueChangeCallback(NumberInputOnValueChangeCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NumberInputOnValueChangeCallback& operator=(NumberInputOnValueChangeCallback&& other) noexcept {
        if (this != &other) {
            AzNumberInputOnValueChangeCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NumberInputOnValueChangeCallback() { AzNumberInputOnValueChangeCallback_delete(&inner_); }

    void delete_();
    NumberInputOnValueChangeCallback clone() const;
    bool partialEq(const NumberInputOnValueChangeCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NumberInputOnValueChangeCallback& b) const;
    uint8_t cmp(const NumberInputOnValueChangeCallback& b) const;
    String toDbgString() const;

    const AzNumberInputOnValueChangeCallback& inner() const { return inner_; }
    AzNumberInputOnValueChangeCallback& inner() { return inner_; }
    const AzNumberInputOnValueChangeCallback* ptr() const { return &inner_; }
    AzNumberInputOnValueChangeCallback* ptr() { return &inner_; }
    AzNumberInputOnValueChangeCallback release() { AzNumberInputOnValueChangeCallback result = inner_; inner_ = {}; return result; }
    operator AzNumberInputOnValueChangeCallback() && noexcept { AzNumberInputOnValueChangeCallback result = inner_; inner_ = {}; return result; }
};

class NumberInputOnFocusLostCallback {
private:
    AzNumberInputOnFocusLostCallback inner_;

    NumberInputOnFocusLostCallback(const NumberInputOnFocusLostCallback&) = delete;
    NumberInputOnFocusLostCallback& operator=(const NumberInputOnFocusLostCallback&) = delete;

public:
    explicit NumberInputOnFocusLostCallback(AzNumberInputOnFocusLostCallback inner) noexcept : inner_(inner) {}

    NumberInputOnFocusLostCallback(NumberInputOnFocusLostCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NumberInputOnFocusLostCallback& operator=(NumberInputOnFocusLostCallback&& other) noexcept {
        if (this != &other) {
            AzNumberInputOnFocusLostCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NumberInputOnFocusLostCallback() { AzNumberInputOnFocusLostCallback_delete(&inner_); }

    void delete_();
    NumberInputOnFocusLostCallback clone() const;
    bool partialEq(const NumberInputOnFocusLostCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NumberInputOnFocusLostCallback& b) const;
    uint8_t cmp(const NumberInputOnFocusLostCallback& b) const;
    String toDbgString() const;

    const AzNumberInputOnFocusLostCallback& inner() const { return inner_; }
    AzNumberInputOnFocusLostCallback& inner() { return inner_; }
    const AzNumberInputOnFocusLostCallback* ptr() const { return &inner_; }
    AzNumberInputOnFocusLostCallback* ptr() { return &inner_; }
    AzNumberInputOnFocusLostCallback release() { AzNumberInputOnFocusLostCallback result = inner_; inner_ = {}; return result; }
    operator AzNumberInputOnFocusLostCallback() && noexcept { AzNumberInputOnFocusLostCallback result = inner_; inner_ = {}; return result; }
};

class ProgressBar {
private:
    AzProgressBar inner_;

    ProgressBar(const ProgressBar&) = delete;
    ProgressBar& operator=(const ProgressBar&) = delete;

public:
    explicit ProgressBar(AzProgressBar inner) noexcept : inner_(inner) {}

    ProgressBar(ProgressBar&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ProgressBar& operator=(ProgressBar&& other) noexcept {
        if (this != &other) {
            AzProgressBar_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ProgressBar() { AzProgressBar_delete(&inner_); }

    [[nodiscard]] static ProgressBar create(float percent_done);

    void set_height(PixelValue height);
    ProgressBar with_height(PixelValue height) const;
    void set_container_background(StyleBackgroundContentVec background);
    ProgressBar with_container_style(StyleBackgroundContentVec background) const;
    void set_bar_background(StyleBackgroundContentVec background);
    ProgressBar with_bar_background(StyleBackgroundContentVec background) const;
    Dom dom() const;
    void delete_();
    ProgressBar clone() const;
    String toDbgString() const;

    const AzProgressBar& inner() const { return inner_; }
    AzProgressBar& inner() { return inner_; }
    const AzProgressBar* ptr() const { return &inner_; }
    AzProgressBar* ptr() { return &inner_; }
    AzProgressBar release() { AzProgressBar result = inner_; inner_ = {}; return result; }
    operator AzProgressBar() && noexcept { AzProgressBar result = inner_; inner_ = {}; return result; }
};

class ListViewState {
private:
    AzListViewState inner_;

    ListViewState(const ListViewState&) = delete;
    ListViewState& operator=(const ListViewState&) = delete;

public:
    explicit ListViewState(AzListViewState inner) noexcept : inner_(inner) {}

    ListViewState(ListViewState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ListViewState& operator=(ListViewState&& other) noexcept {
        if (this != &other) {
            AzListViewState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ListViewState() { AzListViewState_delete(&inner_); }

    void delete_();
    ListViewState clone() const;
    String toDbgString() const;

    const AzListViewState& inner() const { return inner_; }
    AzListViewState& inner() { return inner_; }
    const AzListViewState* ptr() const { return &inner_; }
    AzListViewState* ptr() { return &inner_; }
    AzListViewState release() { AzListViewState result = inner_; inner_ = {}; return result; }
    operator AzListViewState() && noexcept { AzListViewState result = inner_; inner_ = {}; return result; }
};

class VideoFrame {
private:
    AzVideoFrame inner_;

    VideoFrame(const VideoFrame&) = delete;
    VideoFrame& operator=(const VideoFrame&) = delete;

public:
    explicit VideoFrame(AzVideoFrame inner) noexcept : inner_(inner) {}

    VideoFrame(VideoFrame&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VideoFrame& operator=(VideoFrame&& other) noexcept {
        if (this != &other) {
            AzVideoFrame_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VideoFrame() { AzVideoFrame_delete(&inner_); }

    void delete_();
    VideoFrame clone() const;
    bool partialEq(const VideoFrame& b) const;
    String toDbgString() const;

    const AzVideoFrame& inner() const { return inner_; }
    AzVideoFrame& inner() { return inner_; }
    const AzVideoFrame* ptr() const { return &inner_; }
    AzVideoFrame* ptr() { return &inner_; }
    AzVideoFrame release() { AzVideoFrame result = inner_; inner_ = {}; return result; }
    operator AzVideoFrame() && noexcept { AzVideoFrame result = inner_; inner_ = {}; return result; }
};

class MapViewportChangedCallback {
private:
    AzMapViewportChangedCallback inner_;

    MapViewportChangedCallback(const MapViewportChangedCallback&) = delete;
    MapViewportChangedCallback& operator=(const MapViewportChangedCallback&) = delete;

public:
    explicit MapViewportChangedCallback(AzMapViewportChangedCallback inner) noexcept : inner_(inner) {}

    MapViewportChangedCallback(MapViewportChangedCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MapViewportChangedCallback& operator=(MapViewportChangedCallback&& other) noexcept {
        if (this != &other) {
            AzMapViewportChangedCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MapViewportChangedCallback() { AzMapViewportChangedCallback_delete(&inner_); }

    void delete_();
    MapViewportChangedCallback clone() const;
    bool partialEq(const MapViewportChangedCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const MapViewportChangedCallback& b) const;
    uint8_t cmp(const MapViewportChangedCallback& b) const;
    String toDbgString() const;

    const AzMapViewportChangedCallback& inner() const { return inner_; }
    AzMapViewportChangedCallback& inner() { return inner_; }
    const AzMapViewportChangedCallback* ptr() const { return &inner_; }
    AzMapViewportChangedCallback* ptr() { return &inner_; }
    AzMapViewportChangedCallback release() { AzMapViewportChangedCallback result = inner_; inner_ = {}; return result; }
    operator AzMapViewportChangedCallback() && noexcept { AzMapViewportChangedCallback result = inner_; inner_ = {}; return result; }
};

class AudioFrame {
private:
    AzAudioFrame inner_;

    AudioFrame(const AudioFrame&) = delete;
    AudioFrame& operator=(const AudioFrame&) = delete;

public:
    explicit AudioFrame(AzAudioFrame inner) noexcept : inner_(inner) {}

    AudioFrame(AudioFrame&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    AudioFrame& operator=(AudioFrame&& other) noexcept {
        if (this != &other) {
            AzAudioFrame_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~AudioFrame() { AzAudioFrame_delete(&inner_); }

    size_t frame_count() const;
    void delete_();
    AudioFrame clone() const;
    bool partialEq(const AudioFrame& b) const;
    String toDbgString() const;

    const AzAudioFrame& inner() const { return inner_; }
    AzAudioFrame& inner() { return inner_; }
    const AzAudioFrame* ptr() const { return &inner_; }
    AzAudioFrame* ptr() { return &inner_; }
    AzAudioFrame release() { AzAudioFrame result = inner_; inner_ = {}; return result; }
    operator AzAudioFrame() && noexcept { AzAudioFrame result = inner_; inner_ = {}; return result; }
};

class GetProgramBinaryReturn {
private:
    AzGetProgramBinaryReturn inner_;

    GetProgramBinaryReturn(const GetProgramBinaryReturn&) = delete;
    GetProgramBinaryReturn& operator=(const GetProgramBinaryReturn&) = delete;

public:
    explicit GetProgramBinaryReturn(AzGetProgramBinaryReturn inner) noexcept : inner_(inner) {}

    GetProgramBinaryReturn(GetProgramBinaryReturn&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GetProgramBinaryReturn& operator=(GetProgramBinaryReturn&& other) noexcept {
        if (this != &other) {
            AzGetProgramBinaryReturn_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GetProgramBinaryReturn() { AzGetProgramBinaryReturn_delete(&inner_); }

    void delete_();
    GetProgramBinaryReturn clone() const;
    bool partialEq(const GetProgramBinaryReturn& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GetProgramBinaryReturn& b) const;
    uint8_t cmp(const GetProgramBinaryReturn& b) const;
    String toDbgString() const;

    const AzGetProgramBinaryReturn& inner() const { return inner_; }
    AzGetProgramBinaryReturn& inner() { return inner_; }
    const AzGetProgramBinaryReturn* ptr() const { return &inner_; }
    AzGetProgramBinaryReturn* ptr() { return &inner_; }
    AzGetProgramBinaryReturn release() { AzGetProgramBinaryReturn result = inner_; inner_ = {}; return result; }
    operator AzGetProgramBinaryReturn() && noexcept { AzGetProgramBinaryReturn result = inner_; inner_ = {}; return result; }
};

class LoadedFontSource {
private:
    AzLoadedFontSource inner_;

    LoadedFontSource(const LoadedFontSource&) = delete;
    LoadedFontSource& operator=(const LoadedFontSource&) = delete;

public:
    explicit LoadedFontSource(AzLoadedFontSource inner) noexcept : inner_(inner) {}

    LoadedFontSource(LoadedFontSource&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    LoadedFontSource& operator=(LoadedFontSource&& other) noexcept {
        if (this != &other) {
            AzLoadedFontSource_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~LoadedFontSource() { AzLoadedFontSource_delete(&inner_); }

    void delete_();
    LoadedFontSource clone() const;
    bool partialEq(const LoadedFontSource& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzLoadedFontSource& inner() const { return inner_; }
    AzLoadedFontSource& inner() { return inner_; }
    const AzLoadedFontSource* ptr() const { return &inner_; }
    AzLoadedFontSource* ptr() { return &inner_; }
    AzLoadedFontSource release() { AzLoadedFontSource result = inner_; inner_ = {}; return result; }
    operator AzLoadedFontSource() && noexcept { AzLoadedFontSource result = inner_; inner_ = {}; return result; }
};

class TessellatedSvgNode {
private:
    AzTessellatedSvgNode inner_;

    TessellatedSvgNode(const TessellatedSvgNode&) = delete;
    TessellatedSvgNode& operator=(const TessellatedSvgNode&) = delete;

public:
    explicit TessellatedSvgNode(AzTessellatedSvgNode inner) noexcept : inner_(inner) {}

    TessellatedSvgNode(TessellatedSvgNode&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TessellatedSvgNode& operator=(TessellatedSvgNode&& other) noexcept {
        if (this != &other) {
            AzTessellatedSvgNode_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TessellatedSvgNode() { AzTessellatedSvgNode_delete(&inner_); }

    [[nodiscard]] static TessellatedSvgNode empty();
    [[nodiscard]] static TessellatedSvgNode from_nodes(TessellatedSvgNodeVecRef nodes);
    [[nodiscard]] static TessellatedSvgNode default_();

    void delete_();
    TessellatedSvgNode clone() const;
    bool partialEq(const TessellatedSvgNode& b) const;
    uint8_t partialCmp(const TessellatedSvgNode& b) const;
    String toDbgString() const;

    const AzTessellatedSvgNode& inner() const { return inner_; }
    AzTessellatedSvgNode& inner() { return inner_; }
    const AzTessellatedSvgNode* ptr() const { return &inner_; }
    AzTessellatedSvgNode* ptr() { return &inner_; }
    AzTessellatedSvgNode release() { AzTessellatedSvgNode result = inner_; inner_ = {}; return result; }
    operator AzTessellatedSvgNode() && noexcept { AzTessellatedSvgNode result = inner_; inner_ = {}; return result; }
};

class CssPath {
private:
    AzCssPath inner_;

    CssPath(const CssPath&) = delete;
    CssPath& operator=(const CssPath&) = delete;

public:
    explicit CssPath(AzCssPath inner) noexcept : inner_(inner) {}

    CssPath(CssPath&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssPath& operator=(CssPath&& other) noexcept {
        if (this != &other) {
            AzCssPath_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssPath() { AzCssPath_delete(&inner_); }

    [[nodiscard]] static CssPath default_();

    void delete_();
    CssPath clone() const;
    bool partialEq(const CssPath& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CssPath& b) const;
    uint8_t cmp(const CssPath& b) const;
    String toDbgString() const;

    const AzCssPath& inner() const { return inner_; }
    AzCssPath& inner() { return inner_; }
    const AzCssPath* ptr() const { return &inner_; }
    AzCssPath* ptr() { return &inner_; }
    AzCssPath release() { AzCssPath result = inner_; inner_ = {}; return result; }
    operator AzCssPath() && noexcept { AzCssPath result = inner_; inner_ = {}; return result; }
};

class ShapePolygon {
private:
    AzShapePolygon inner_;

    ShapePolygon(const ShapePolygon&) = delete;
    ShapePolygon& operator=(const ShapePolygon&) = delete;

public:
    explicit ShapePolygon(AzShapePolygon inner) noexcept : inner_(inner) {}

    ShapePolygon(ShapePolygon&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ShapePolygon& operator=(ShapePolygon&& other) noexcept {
        if (this != &other) {
            AzShapePolygon_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ShapePolygon() { AzShapePolygon_delete(&inner_); }

    void delete_();
    ShapePolygon clone() const;
    bool partialEq(const ShapePolygon& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ShapePolygon& b) const;
    uint8_t cmp(const ShapePolygon& b) const;
    String toDbgString() const;

    const AzShapePolygon& inner() const { return inner_; }
    AzShapePolygon& inner() { return inner_; }
    const AzShapePolygon* ptr() const { return &inner_; }
    AzShapePolygon* ptr() { return &inner_; }
    AzShapePolygon release() { AzShapePolygon result = inner_; inner_ = {}; return result; }
    operator AzShapePolygon() && noexcept { AzShapePolygon result = inner_; inner_ = {}; return result; }
};

class SvgPath {
private:
    AzSvgPath inner_;

    SvgPath(const SvgPath&) = delete;
    SvgPath& operator=(const SvgPath&) = delete;

public:
    explicit SvgPath(AzSvgPath inner) noexcept : inner_(inner) {}

    SvgPath(SvgPath&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SvgPath& operator=(SvgPath&& other) noexcept {
        if (this != &other) {
            AzSvgPath_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SvgPath() { AzSvgPath_delete(&inner_); }

    [[nodiscard]] static SvgPath create(SvgPathElementVec items);

    OptionSvgPoint get_start() const;
    OptionSvgPoint get_end() const;
    void close();
    bool is_closed() const;
    void reverse();
    bool join_with(SvgPath path);
    SvgRect get_bounds() const;
    void delete_();
    SvgPath clone() const;
    bool partialEq(const SvgPath& b) const;
    uint8_t partialCmp(const SvgPath& b) const;
    String toDbgString() const;

    const AzSvgPath& inner() const { return inner_; }
    AzSvgPath& inner() { return inner_; }
    const AzSvgPath* ptr() const { return &inner_; }
    AzSvgPath* ptr() { return &inner_; }
    AzSvgPath release() { AzSvgPath result = inner_; inner_ = {}; return result; }
    operator AzSvgPath() && noexcept { AzSvgPath result = inner_; inner_ = {}; return result; }
};

class SvgMultiPolygon {
private:
    AzSvgMultiPolygon inner_;

    SvgMultiPolygon(const SvgMultiPolygon&) = delete;
    SvgMultiPolygon& operator=(const SvgMultiPolygon&) = delete;

public:
    explicit SvgMultiPolygon(AzSvgMultiPolygon inner) noexcept : inner_(inner) {}

    SvgMultiPolygon(SvgMultiPolygon&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SvgMultiPolygon& operator=(SvgMultiPolygon&& other) noexcept {
        if (this != &other) {
            AzSvgMultiPolygon_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SvgMultiPolygon() { AzSvgMultiPolygon_delete(&inner_); }

    [[nodiscard]] static SvgMultiPolygon create(SvgPathVec rings);

    SvgRect get_bounds() const;
    TessellatedSvgNode tessellate_fill(SvgFillStyle fill_style) const;
    TessellatedSvgNode tessellate_stroke(SvgStrokeStyle stroke_style) const;
    void delete_();
    SvgMultiPolygon clone() const;
    bool partialEq(const SvgMultiPolygon& b) const;
    uint8_t partialCmp(const SvgMultiPolygon& b) const;
    String toDbgString() const;

    const AzSvgMultiPolygon& inner() const { return inner_; }
    AzSvgMultiPolygon& inner() { return inner_; }
    const AzSvgMultiPolygon* ptr() const { return &inner_; }
    AzSvgMultiPolygon* ptr() { return &inner_; }
    AzSvgMultiPolygon release() { AzSvgMultiPolygon result = inner_; inner_ = {}; return result; }
    operator AzSvgMultiPolygon() && noexcept { AzSvgMultiPolygon result = inner_; inner_ = {}; return result; }
};

class ParsedSvg {
private:
    AzParsedSvg inner_;

    ParsedSvg(const ParsedSvg&) = delete;
    ParsedSvg& operator=(const ParsedSvg&) = delete;

public:
    explicit ParsedSvg(AzParsedSvg inner) noexcept : inner_(inner) {}

    ParsedSvg(ParsedSvg&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ParsedSvg& operator=(ParsedSvg&& other) noexcept {
        if (this != &other) {
            AzParsedSvg_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ParsedSvg() { AzParsedSvg_delete(&inner_); }
    [[nodiscard]] static ResultParsedSvgSvgParseError from_string(String svg_string, SvgParseOptions parse_options);
    [[nodiscard]] static ResultParsedSvgSvgParseError from_bytes(U8VecRef svg_bytes, SvgParseOptions parse_options);

    OptionRawImage render(SvgRenderOptions options) const;
    void delete_();
    ParsedSvg clone() const;
    String toDbgString() const;

    const AzParsedSvg& inner() const { return inner_; }
    AzParsedSvg& inner() { return inner_; }
    const AzParsedSvg* ptr() const { return &inner_; }
    AzParsedSvg* ptr() { return &inner_; }
    AzParsedSvg release() { AzParsedSvg result = inner_; inner_ = {}; return result; }
    operator AzParsedSvg() && noexcept { AzParsedSvg result = inner_; inner_ = {}; return result; }
};

class String {
private:
    AzString inner_;

    String(const String&) = delete;
    String& operator=(const String&) = delete;

public:
    explicit String(AzString inner) noexcept : inner_(inner) {}

    String(String&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    String& operator=(String&& other) noexcept {
        if (this != &other) {
            AzString_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~String() { AzString_delete(&inner_); }

    [[nodiscard]] static String copy_from_bytes(const uint8_t* ptr, size_t start, size_t len);
    [[nodiscard]] static String from_c_str(const int8_t* ptr);
    [[nodiscard]] static String default_();

    U8Vec to_c_str() const;
    static String from_utf16_le(const uint8_t* ptr, size_t len);
    static String from_utf16_be(const uint8_t* ptr, size_t len);
    static String from_utf8_lossy(const uint8_t* ptr, size_t len);
    static String from_utf8(const uint8_t* ptr, size_t len);
    void delete_();
    String clone() const;
    bool partialEq(const String& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const String& b) const;
    uint8_t cmp(const String& b) const;
    String toDbgString() const;

    const AzString& inner() const { return inner_; }
    AzString& inner() { return inner_; }
    const AzString* ptr() const { return &inner_; }
    AzString* ptr() { return &inner_; }
    AzString release() { AzString result = inner_; inner_ = {}; return result; }
    operator AzString() && noexcept { AzString result = inner_; inner_ = {}; return result; }

    // String methods
    String(const char* s) : inner_(AzString_copyFromBytes(reinterpret_cast<const uint8_t*>(s), 0, std::strlen(s))) {}
    String(const std::string& s) : inner_(AzString_copyFromBytes(reinterpret_cast<const uint8_t*>(s.c_str()), 0, s.size())) {}
    String(std::string_view sv) : inner_(AzString_copyFromBytes(reinterpret_cast<const uint8_t*>(sv.data()), 0, sv.size())) {}
    const char* c_str() const { return reinterpret_cast<const char*>(inner_.vec.ptr); }
    size_t length() const { return inner_.vec.len; }
    std::string toStdString() const { return std::string(c_str(), length()); }
    operator std::string() const { return toStdString(); }
    std::string_view toStringView() const { return std::string_view(c_str(), length()); }
    operator std::string_view() const { return toStringView(); }
};

class InvalidCharMultipleError {
private:
    AzInvalidCharMultipleError inner_;

    InvalidCharMultipleError(const InvalidCharMultipleError&) = delete;
    InvalidCharMultipleError& operator=(const InvalidCharMultipleError&) = delete;

public:
    explicit InvalidCharMultipleError(AzInvalidCharMultipleError inner) noexcept : inner_(inner) {}

    InvalidCharMultipleError(InvalidCharMultipleError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    InvalidCharMultipleError& operator=(InvalidCharMultipleError&& other) noexcept {
        if (this != &other) {
            AzInvalidCharMultipleError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~InvalidCharMultipleError() { AzInvalidCharMultipleError_delete(&inner_); }

    void delete_();
    InvalidCharMultipleError clone() const;
    bool partialEq(const InvalidCharMultipleError& b) const;
    uint8_t partialCmp(const InvalidCharMultipleError& b) const;
    String toDbgString() const;

    const AzInvalidCharMultipleError& inner() const { return inner_; }
    AzInvalidCharMultipleError& inner() { return inner_; }
    const AzInvalidCharMultipleError* ptr() const { return &inner_; }
    AzInvalidCharMultipleError* ptr() { return &inner_; }
    AzInvalidCharMultipleError release() { AzInvalidCharMultipleError result = inner_; inner_ = {}; return result; }
    operator AzInvalidCharMultipleError() && noexcept { AzInvalidCharMultipleError result = inner_; inner_ = {}; return result; }
};

class FluentZipLoadResult {
private:
    AzFluentZipLoadResult inner_;

    FluentZipLoadResult(const FluentZipLoadResult&) = delete;
    FluentZipLoadResult& operator=(const FluentZipLoadResult&) = delete;

public:
    explicit FluentZipLoadResult(AzFluentZipLoadResult inner) noexcept : inner_(inner) {}

    FluentZipLoadResult(FluentZipLoadResult&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FluentZipLoadResult& operator=(FluentZipLoadResult&& other) noexcept {
        if (this != &other) {
            AzFluentZipLoadResult_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FluentZipLoadResult() { AzFluentZipLoadResult_delete(&inner_); }

    void delete_();
    FluentZipLoadResult clone() const;
    String toDbgString() const;

    const AzFluentZipLoadResult& inner() const { return inner_; }
    AzFluentZipLoadResult& inner() { return inner_; }
    const AzFluentZipLoadResult* ptr() const { return &inner_; }
    AzFluentZipLoadResult* ptr() { return &inner_; }
    AzFluentZipLoadResult release() { AzFluentZipLoadResult result = inner_; inner_ = {}; return result; }
    operator AzFluentZipLoadResult() && noexcept { AzFluentZipLoadResult result = inner_; inner_ = {}; return result; }
};

class ThreadSender {
private:
    AzThreadSender inner_;

    ThreadSender(const ThreadSender&) = delete;
    ThreadSender& operator=(const ThreadSender&) = delete;

public:
    explicit ThreadSender(AzThreadSender inner) noexcept : inner_(inner) {}

    ThreadSender(ThreadSender&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ThreadSender& operator=(ThreadSender&& other) noexcept {
        if (this != &other) {
            AzThreadSender_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ThreadSender() { AzThreadSender_delete(&inner_); }

    bool send(AzThreadReceiveMsg msg);
    void delete_();
    ThreadSender clone() const;
    String toDbgString() const;

    const AzThreadSender& inner() const { return inner_; }
    AzThreadSender& inner() { return inner_; }
    const AzThreadSender* ptr() const { return &inner_; }
    AzThreadSender* ptr() { return &inner_; }
    AzThreadSender release() { AzThreadSender result = inner_; inner_ = {}; return result; }
    operator AzThreadSender() && noexcept { AzThreadSender result = inner_; inner_ = {}; return result; }
};

class ThreadReceiver {
private:
    AzThreadReceiver inner_;

    ThreadReceiver(const ThreadReceiver&) = delete;
    ThreadReceiver& operator=(const ThreadReceiver&) = delete;

public:
    explicit ThreadReceiver(AzThreadReceiver inner) noexcept : inner_(inner) {}

    ThreadReceiver(ThreadReceiver&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ThreadReceiver& operator=(ThreadReceiver&& other) noexcept {
        if (this != &other) {
            AzThreadReceiver_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ThreadReceiver() { AzThreadReceiver_delete(&inner_); }

    OptionThreadSendMsg recv();
    void delete_();
    ThreadReceiver clone() const;
    String toDbgString() const;

    const AzThreadReceiver& inner() const { return inner_; }
    AzThreadReceiver& inner() { return inner_; }
    const AzThreadReceiver* ptr() const { return &inner_; }
    AzThreadReceiver* ptr() { return &inner_; }
    AzThreadReceiver release() { AzThreadReceiver result = inner_; inner_ = {}; return result; }
    operator AzThreadReceiver() && noexcept { AzThreadReceiver result = inner_; inner_ = {}; return result; }
};

class DbRows {
private:
    AzDbRows inner_;

    DbRows(const DbRows&) = delete;
    DbRows& operator=(const DbRows&) = delete;

public:
    explicit DbRows(AzDbRows inner) noexcept : inner_(inner) {}

    DbRows(DbRows&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DbRows& operator=(DbRows&& other) noexcept {
        if (this != &other) {
            AzDbRows_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DbRows() { AzDbRows_delete(&inner_); }

    void delete_();
    DbRows clone() const;
    bool partialEq(const DbRows& b) const;
    String toDbgString() const;

    const AzDbRows& inner() const { return inner_; }
    AzDbRows& inner() { return inner_; }
    const AzDbRows* ptr() const { return &inner_; }
    AzDbRows* ptr() { return &inner_; }
    AzDbRows release() { AzDbRows result = inner_; inner_ = {}; return result; }
    operator AzDbRows() && noexcept { AzDbRows result = inner_; inner_ = {}; return result; }
};

class ComponentMap {
private:
    AzComponentMap inner_;

    ComponentMap(const ComponentMap&) = delete;
    ComponentMap& operator=(const ComponentMap&) = delete;

public:
    explicit ComponentMap(AzComponentMap inner) noexcept : inner_(inner) {}

    ComponentMap(ComponentMap&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentMap& operator=(ComponentMap&& other) noexcept {
        if (this != &other) {
            AzComponentMap_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentMap() { AzComponentMap_delete(&inner_); }

    [[nodiscard]] static ComponentMap create();
    [[nodiscard]] static ComponentMap default_();

    void delete_();
    ComponentMap clone() const;
    String toDbgString() const;

    const AzComponentMap& inner() const { return inner_; }
    AzComponentMap& inner() { return inner_; }
    const AzComponentMap* ptr() const { return &inner_; }
    AzComponentMap* ptr() { return &inner_; }
    AzComponentMap release() { AzComponentMap result = inner_; inner_ = {}; return result; }
    operator AzComponentMap() && noexcept { AzComponentMap result = inner_; inner_ = {}; return result; }
};

class WaylandTheme {
private:
    AzWaylandTheme inner_;

    WaylandTheme(const WaylandTheme&) = delete;
    WaylandTheme& operator=(const WaylandTheme&) = delete;

public:
    explicit WaylandTheme(AzWaylandTheme inner) noexcept : inner_(inner) {}

    WaylandTheme(WaylandTheme&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    WaylandTheme& operator=(WaylandTheme&& other) noexcept {
        if (this != &other) {
            AzWaylandTheme_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~WaylandTheme() { AzWaylandTheme_delete(&inner_); }

    void delete_();
    WaylandTheme clone() const;
    bool partialEq(const WaylandTheme& b) const;
    uint8_t partialCmp(const WaylandTheme& b) const;
    String toDbgString() const;

    const AzWaylandTheme& inner() const { return inner_; }
    AzWaylandTheme& inner() { return inner_; }
    const AzWaylandTheme* ptr() const { return &inner_; }
    AzWaylandTheme* ptr() { return &inner_; }
    AzWaylandTheme release() { AzWaylandTheme result = inner_; inner_ = {}; return result; }
    operator AzWaylandTheme() && noexcept { AzWaylandTheme result = inner_; inner_ = {}; return result; }
};

class MimeTypeHint {
private:
    AzMimeTypeHint inner_;

    MimeTypeHint(const MimeTypeHint&) = delete;
    MimeTypeHint& operator=(const MimeTypeHint&) = delete;

public:
    explicit MimeTypeHint(AzMimeTypeHint inner) noexcept : inner_(inner) {}

    MimeTypeHint(MimeTypeHint&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MimeTypeHint& operator=(MimeTypeHint&& other) noexcept {
        if (this != &other) {
            AzMimeTypeHint_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MimeTypeHint() { AzMimeTypeHint_delete(&inner_); }

    void delete_();
    MimeTypeHint clone() const;
    bool partialEq(const MimeTypeHint& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const MimeTypeHint& b) const;
    uint8_t cmp(const MimeTypeHint& b) const;
    String toDbgString() const;

    const AzMimeTypeHint& inner() const { return inner_; }
    AzMimeTypeHint& inner() { return inner_; }
    const AzMimeTypeHint* ptr() const { return &inner_; }
    AzMimeTypeHint* ptr() { return &inner_; }
    AzMimeTypeHint release() { AzMimeTypeHint result = inner_; inner_ = {}; return result; }
    operator AzMimeTypeHint() && noexcept { AzMimeTypeHint result = inner_; inner_ = {}; return result; }
};

class MimeTypeData {
private:
    AzMimeTypeData inner_;

    MimeTypeData(const MimeTypeData&) = delete;
    MimeTypeData& operator=(const MimeTypeData&) = delete;

public:
    explicit MimeTypeData(AzMimeTypeData inner) noexcept : inner_(inner) {}

    MimeTypeData(MimeTypeData&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MimeTypeData& operator=(MimeTypeData&& other) noexcept {
        if (this != &other) {
            AzMimeTypeData_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MimeTypeData() { AzMimeTypeData_delete(&inner_); }

    [[nodiscard]] static MimeTypeData default_();

    void delete_();
    MimeTypeData clone() const;
    bool partialEq(const MimeTypeData& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const MimeTypeData& b) const;
    uint8_t cmp(const MimeTypeData& b) const;
    String toDbgString() const;

    const AzMimeTypeData& inner() const { return inner_; }
    AzMimeTypeData& inner() { return inner_; }
    const AzMimeTypeData* ptr() const { return &inner_; }
    AzMimeTypeData* ptr() { return &inner_; }
    AzMimeTypeData release() { AzMimeTypeData result = inner_; inner_ = {}; return result; }
    operator AzMimeTypeData() && noexcept { AzMimeTypeData result = inner_; inner_ = {}; return result; }
};

class HttpHeader {
private:
    AzHttpHeader inner_;

    HttpHeader(const HttpHeader&) = delete;
    HttpHeader& operator=(const HttpHeader&) = delete;

public:
    explicit HttpHeader(AzHttpHeader inner) noexcept : inner_(inner) {}

    HttpHeader(HttpHeader&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    HttpHeader& operator=(HttpHeader&& other) noexcept {
        if (this != &other) {
            AzHttpHeader_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~HttpHeader() { AzHttpHeader_delete(&inner_); }

    void delete_();
    HttpHeader clone() const;
    bool partialEq(const HttpHeader& b) const;
    String toDbgString() const;

    const AzHttpHeader& inner() const { return inner_; }
    AzHttpHeader& inner() { return inner_; }
    const AzHttpHeader* ptr() const { return &inner_; }
    AzHttpHeader* ptr() { return &inner_; }
    AzHttpHeader release() { AzHttpHeader result = inner_; inner_ = {}; return result; }
    operator AzHttpHeader() && noexcept { AzHttpHeader result = inner_; inner_ = {}; return result; }
};

class HttpResponse {
private:
    AzHttpResponse inner_;

    HttpResponse(const HttpResponse&) = delete;
    HttpResponse& operator=(const HttpResponse&) = delete;

public:
    explicit HttpResponse(AzHttpResponse inner) noexcept : inner_(inner) {}

    HttpResponse(HttpResponse&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    HttpResponse& operator=(HttpResponse&& other) noexcept {
        if (this != &other) {
            AzHttpResponse_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~HttpResponse() { AzHttpResponse_delete(&inner_); }

    bool is_success() const;
    bool is_redirect() const;
    bool is_client_error() const;
    bool is_server_error() const;
    OptionString body_as_string() const;
    void delete_();
    HttpResponse clone() const;
    bool partialEq(const HttpResponse& b) const;
    String toDbgString() const;

    const AzHttpResponse& inner() const { return inner_; }
    AzHttpResponse& inner() { return inner_; }
    const AzHttpResponse* ptr() const { return &inner_; }
    AzHttpResponse* ptr() { return &inner_; }
    AzHttpResponse release() { AzHttpResponse result = inner_; inner_ = {}; return result; }
    operator AzHttpResponse() && noexcept { AzHttpResponse result = inner_; inner_ = {}; return result; }
};

class HttpRequestConfig {
private:
    AzHttpRequestConfig inner_;

    HttpRequestConfig(const HttpRequestConfig&) = delete;
    HttpRequestConfig& operator=(const HttpRequestConfig&) = delete;

public:
    explicit HttpRequestConfig(AzHttpRequestConfig inner) noexcept : inner_(inner) {}

    HttpRequestConfig(HttpRequestConfig&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    HttpRequestConfig& operator=(HttpRequestConfig&& other) noexcept {
        if (this != &other) {
            AzHttpRequestConfig_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~HttpRequestConfig() { AzHttpRequestConfig_delete(&inner_); }

    [[nodiscard]] static HttpRequestConfig create();
    [[nodiscard]] static HttpRequestConfig default_();

    HttpRequestConfig with_timeout(uint64_t secs) const;
    HttpRequestConfig with_max_size(uint64_t max_bytes) const;
    HttpRequestConfig with_user_agent(String ua) const;
    HttpRequestConfig with_header(String name, String value) const;
    static ResultHttpResponseHttpError http_get_default(String url);
    ResultHttpResponseHttpError http_get(String url) const;
    static ResultU8VecHttpError download_bytes_default(String url);
    ResultU8VecHttpError download_bytes(String url) const;
    static bool is_url_reachable(String url);
    void delete_();
    HttpRequestConfig clone() const;
    String toDbgString() const;

    const AzHttpRequestConfig& inner() const { return inner_; }
    AzHttpRequestConfig& inner() { return inner_; }
    const AzHttpRequestConfig* ptr() const { return &inner_; }
    AzHttpRequestConfig* ptr() { return &inner_; }
    AzHttpRequestConfig release() { AzHttpRequestConfig result = inner_; inner_ = {}; return result; }
    operator AzHttpRequestConfig() && noexcept { AzHttpRequestConfig result = inner_; inner_ = {}; return result; }
};

class TimerCallbackInfo {
private:
    AzTimerCallbackInfo inner_;

    TimerCallbackInfo(const TimerCallbackInfo&) = delete;
    TimerCallbackInfo& operator=(const TimerCallbackInfo&) = delete;

public:
    explicit TimerCallbackInfo(AzTimerCallbackInfo inner) noexcept : inner_(inner) {}

    TimerCallbackInfo(TimerCallbackInfo&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TimerCallbackInfo& operator=(TimerCallbackInfo&& other) noexcept {
        if (this != &other) {
            AzTimerCallbackInfo_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TimerCallbackInfo() { AzTimerCallbackInfo_delete(&inner_); }

    [[nodiscard]] static TimerCallbackInfo create(CallbackInfo callback_info, OptionDomNodeId node_id, AzInstant frame_start, size_t call_count, bool is_about_to_finish);

    OptionLogicalSize get_attached_node_size() const;
    OptionLogicalPosition get_attached_node_position() const;
    void update_all_image_callbacks();
    void trigger_virtual_view_rerender(DomId dom_id, NodeId node_id);
    void delete_();
    TimerCallbackInfo clone() const;

    const AzTimerCallbackInfo& inner() const { return inner_; }
    AzTimerCallbackInfo& inner() { return inner_; }
    const AzTimerCallbackInfo* ptr() const { return &inner_; }
    AzTimerCallbackInfo* ptr() { return &inner_; }
    AzTimerCallbackInfo release() { AzTimerCallbackInfo result = inner_; inner_ = {}; return result; }
    operator AzTimerCallbackInfo() && noexcept { AzTimerCallbackInfo result = inner_; inner_ = {}; return result; }
};

class CoreCallbackData {
private:
    AzCoreCallbackData inner_;

    CoreCallbackData(const CoreCallbackData&) = delete;
    CoreCallbackData& operator=(const CoreCallbackData&) = delete;

public:
    explicit CoreCallbackData(AzCoreCallbackData inner) noexcept : inner_(inner) {}

    CoreCallbackData(CoreCallbackData&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CoreCallbackData& operator=(CoreCallbackData&& other) noexcept {
        if (this != &other) {
            AzCoreCallbackData_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CoreCallbackData() { AzCoreCallbackData_delete(&inner_); }

    void delete_();
    CoreCallbackData clone() const;
    bool partialEq(const CoreCallbackData& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CoreCallbackData& b) const;
    uint8_t cmp(const CoreCallbackData& b) const;
    String toDbgString() const;

    const AzCoreCallbackData& inner() const { return inner_; }
    AzCoreCallbackData& inner() { return inner_; }
    const AzCoreCallbackData* ptr() const { return &inner_; }
    AzCoreCallbackData* ptr() { return &inner_; }
    AzCoreCallbackData release() { AzCoreCallbackData result = inner_; inner_ = {}; return result; }
    operator AzCoreCallbackData() && noexcept { AzCoreCallbackData result = inner_; inner_ = {}; return result; }
};

class CoreMenuCallback {
private:
    AzCoreMenuCallback inner_;

    CoreMenuCallback(const CoreMenuCallback&) = delete;
    CoreMenuCallback& operator=(const CoreMenuCallback&) = delete;

public:
    explicit CoreMenuCallback(AzCoreMenuCallback inner) noexcept : inner_(inner) {}

    CoreMenuCallback(CoreMenuCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CoreMenuCallback& operator=(CoreMenuCallback&& other) noexcept {
        if (this != &other) {
            AzCoreMenuCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CoreMenuCallback() { AzCoreMenuCallback_delete(&inner_); }

    void delete_();
    CoreMenuCallback clone() const;
    bool partialEq(const CoreMenuCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CoreMenuCallback& b) const;
    uint8_t cmp(const CoreMenuCallback& b) const;
    String toDbgString() const;

    const AzCoreMenuCallback& inner() const { return inner_; }
    AzCoreMenuCallback& inner() { return inner_; }
    const AzCoreMenuCallback* ptr() const { return &inner_; }
    AzCoreMenuCallback* ptr() { return &inner_; }
    AzCoreMenuCallback release() { AzCoreMenuCallback result = inner_; inner_ = {}; return result; }
    operator AzCoreMenuCallback() && noexcept { AzCoreMenuCallback result = inner_; inner_ = {}; return result; }
};

class AttributeNameValue {
private:
    AzAttributeNameValue inner_;

    AttributeNameValue(const AttributeNameValue&) = delete;
    AttributeNameValue& operator=(const AttributeNameValue&) = delete;

public:
    explicit AttributeNameValue(AzAttributeNameValue inner) noexcept : inner_(inner) {}

    AttributeNameValue(AttributeNameValue&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    AttributeNameValue& operator=(AttributeNameValue&& other) noexcept {
        if (this != &other) {
            AzAttributeNameValue_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~AttributeNameValue() { AzAttributeNameValue_delete(&inner_); }

    void delete_();
    AttributeNameValue clone() const;
    bool partialEq(const AttributeNameValue& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const AttributeNameValue& b) const;
    uint8_t cmp(const AttributeNameValue& b) const;
    String toDbgString() const;

    const AzAttributeNameValue& inner() const { return inner_; }
    AzAttributeNameValue& inner() { return inner_; }
    const AzAttributeNameValue* ptr() const { return &inner_; }
    AzAttributeNameValue* ptr() { return &inner_; }
    AzAttributeNameValue release() { AzAttributeNameValue result = inner_; inner_ = {}; return result; }
    operator AzAttributeNameValue() && noexcept { AzAttributeNameValue result = inner_; inner_ = {}; return result; }
};

class XmlTagName {
private:
    AzXmlTagName inner_;

    XmlTagName(const XmlTagName&) = delete;
    XmlTagName& operator=(const XmlTagName&) = delete;

public:
    explicit XmlTagName(AzXmlTagName inner) noexcept : inner_(inner) {}

    XmlTagName(XmlTagName&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    XmlTagName& operator=(XmlTagName&& other) noexcept {
        if (this != &other) {
            AzXmlTagName_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~XmlTagName() { AzXmlTagName_delete(&inner_); }

    [[nodiscard]] static XmlTagName default_();

    void delete_();
    XmlTagName clone() const;
    bool partialEq(const XmlTagName& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const XmlTagName& b) const;
    uint8_t cmp(const XmlTagName& b) const;
    String toDbgString() const;

    const AzXmlTagName& inner() const { return inner_; }
    AzXmlTagName& inner() { return inner_; }
    const AzXmlTagName* ptr() const { return &inner_; }
    AzXmlTagName* ptr() { return &inner_; }
    AzXmlTagName release() { AzXmlTagName result = inner_; inner_ = {}; return result; }
    operator AzXmlTagName() && noexcept { AzXmlTagName result = inner_; inner_ = {}; return result; }
};

class VertexAttribute {
private:
    AzVertexAttribute inner_;

    VertexAttribute(const VertexAttribute&) = delete;
    VertexAttribute& operator=(const VertexAttribute&) = delete;

public:
    explicit VertexAttribute(AzVertexAttribute inner) noexcept : inner_(inner) {}

    VertexAttribute(VertexAttribute&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VertexAttribute& operator=(VertexAttribute&& other) noexcept {
        if (this != &other) {
            AzVertexAttribute_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VertexAttribute() { AzVertexAttribute_delete(&inner_); }

    void delete_();
    VertexAttribute clone() const;
    bool partialEq(const VertexAttribute& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const VertexAttribute& b) const;
    uint8_t cmp(const VertexAttribute& b) const;
    String toDbgString() const;

    const AzVertexAttribute& inner() const { return inner_; }
    AzVertexAttribute& inner() { return inner_; }
    const AzVertexAttribute* ptr() const { return &inner_; }
    AzVertexAttribute* ptr() { return &inner_; }
    AzVertexAttribute release() { AzVertexAttribute result = inner_; inner_ = {}; return result; }
    operator AzVertexAttribute() && noexcept { AzVertexAttribute result = inner_; inner_ = {}; return result; }
};

class CoreImageCallback {
private:
    AzCoreImageCallback inner_;

    CoreImageCallback(const CoreImageCallback&) = delete;
    CoreImageCallback& operator=(const CoreImageCallback&) = delete;

public:
    explicit CoreImageCallback(AzCoreImageCallback inner) noexcept : inner_(inner) {}

    CoreImageCallback(CoreImageCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CoreImageCallback& operator=(CoreImageCallback&& other) noexcept {
        if (this != &other) {
            AzCoreImageCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CoreImageCallback() { AzCoreImageCallback_delete(&inner_); }

    void delete_();
    CoreImageCallback clone() const;
    bool partialEq(const CoreImageCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CoreImageCallback& b) const;
    uint8_t cmp(const CoreImageCallback& b) const;
    String toDbgString() const;

    const AzCoreImageCallback& inner() const { return inner_; }
    AzCoreImageCallback& inner() { return inner_; }
    const AzCoreImageCallback* ptr() const { return &inner_; }
    AzCoreImageCallback* ptr() { return &inner_; }
    AzCoreImageCallback release() { AzCoreImageCallback result = inner_; inner_ = {}; return result; }
    operator AzCoreImageCallback() && noexcept { AzCoreImageCallback result = inner_; inner_ = {}; return result; }
};

class ClipboardContent {
private:
    AzClipboardContent inner_;

    ClipboardContent(const ClipboardContent&) = delete;
    ClipboardContent& operator=(const ClipboardContent&) = delete;

public:
    explicit ClipboardContent(AzClipboardContent inner) noexcept : inner_(inner) {}

    ClipboardContent(ClipboardContent&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ClipboardContent& operator=(ClipboardContent&& other) noexcept {
        if (this != &other) {
            AzClipboardContent_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ClipboardContent() { AzClipboardContent_delete(&inner_); }

    void delete_();
    ClipboardContent clone() const;
    bool partialEq(const ClipboardContent& b) const;
    String toDbgString() const;

    const AzClipboardContent& inner() const { return inner_; }
    AzClipboardContent& inner() { return inner_; }
    const AzClipboardContent* ptr() const { return &inner_; }
    AzClipboardContent* ptr() { return &inner_; }
    AzClipboardContent release() { AzClipboardContent result = inner_; inner_ = {}; return result; }
    operator AzClipboardContent() && noexcept { AzClipboardContent result = inner_; inner_ = {}; return result; }
};

class TextInputOnVirtualKeyDown {
private:
    AzTextInputOnVirtualKeyDown inner_;

    TextInputOnVirtualKeyDown(const TextInputOnVirtualKeyDown&) = delete;
    TextInputOnVirtualKeyDown& operator=(const TextInputOnVirtualKeyDown&) = delete;

public:
    explicit TextInputOnVirtualKeyDown(AzTextInputOnVirtualKeyDown inner) noexcept : inner_(inner) {}

    TextInputOnVirtualKeyDown(TextInputOnVirtualKeyDown&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextInputOnVirtualKeyDown& operator=(TextInputOnVirtualKeyDown&& other) noexcept {
        if (this != &other) {
            AzTextInputOnVirtualKeyDown_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextInputOnVirtualKeyDown() { AzTextInputOnVirtualKeyDown_delete(&inner_); }

    void delete_();
    TextInputOnVirtualKeyDown clone() const;
    bool partialEq(const TextInputOnVirtualKeyDown& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TextInputOnVirtualKeyDown& b) const;
    uint8_t cmp(const TextInputOnVirtualKeyDown& b) const;
    String toDbgString() const;

    const AzTextInputOnVirtualKeyDown& inner() const { return inner_; }
    AzTextInputOnVirtualKeyDown& inner() { return inner_; }
    const AzTextInputOnVirtualKeyDown* ptr() const { return &inner_; }
    AzTextInputOnVirtualKeyDown* ptr() { return &inner_; }
    AzTextInputOnVirtualKeyDown release() { AzTextInputOnVirtualKeyDown result = inner_; inner_ = {}; return result; }
    operator AzTextInputOnVirtualKeyDown() && noexcept { AzTextInputOnVirtualKeyDown result = inner_; inner_ = {}; return result; }
};

class TextOpSetSelection {
private:
    AzTextOpSetSelection inner_;

    TextOpSetSelection(const TextOpSetSelection&) = delete;
    TextOpSetSelection& operator=(const TextOpSetSelection&) = delete;

public:
    explicit TextOpSetSelection(AzTextOpSetSelection inner) noexcept : inner_(inner) {}

    TextOpSetSelection(TextOpSetSelection&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextOpSetSelection& operator=(TextOpSetSelection&& other) noexcept {
        if (this != &other) {
            AzTextOpSetSelection_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextOpSetSelection() { AzTextOpSetSelection_delete(&inner_); }

    void delete_();
    TextOpSetSelection clone() const;
    String toDbgString() const;

    const AzTextOpSetSelection& inner() const { return inner_; }
    AzTextOpSetSelection& inner() { return inner_; }
    const AzTextOpSetSelection* ptr() const { return &inner_; }
    AzTextOpSetSelection* ptr() { return &inner_; }
    AzTextOpSetSelection release() { AzTextOpSetSelection result = inner_; inner_ = {}; return result; }
    operator AzTextOpSetSelection() && noexcept { AzTextOpSetSelection result = inner_; inner_ = {}; return result; }
};

class NodeStateSnapshot {
private:
    AzNodeStateSnapshot inner_;

    NodeStateSnapshot(const NodeStateSnapshot&) = delete;
    NodeStateSnapshot& operator=(const NodeStateSnapshot&) = delete;

public:
    explicit NodeStateSnapshot(AzNodeStateSnapshot inner) noexcept : inner_(inner) {}

    NodeStateSnapshot(NodeStateSnapshot&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NodeStateSnapshot& operator=(NodeStateSnapshot&& other) noexcept {
        if (this != &other) {
            AzNodeStateSnapshot_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NodeStateSnapshot() { AzNodeStateSnapshot_delete(&inner_); }

    void delete_();
    NodeStateSnapshot clone() const;
    String toDbgString() const;

    const AzNodeStateSnapshot& inner() const { return inner_; }
    AzNodeStateSnapshot& inner() { return inner_; }
    const AzNodeStateSnapshot* ptr() const { return &inner_; }
    AzNodeStateSnapshot* ptr() { return &inner_; }
    AzNodeStateSnapshot release() { AzNodeStateSnapshot result = inner_; inner_ = {}; return result; }
    operator AzNodeStateSnapshot() && noexcept { AzNodeStateSnapshot result = inner_; inner_ = {}; return result; }
};

class ParseIntErrorWithInput {
private:
    AzParseIntErrorWithInput inner_;

    ParseIntErrorWithInput(const ParseIntErrorWithInput&) = delete;
    ParseIntErrorWithInput& operator=(const ParseIntErrorWithInput&) = delete;

public:
    explicit ParseIntErrorWithInput(AzParseIntErrorWithInput inner) noexcept : inner_(inner) {}

    ParseIntErrorWithInput(ParseIntErrorWithInput&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ParseIntErrorWithInput& operator=(ParseIntErrorWithInput&& other) noexcept {
        if (this != &other) {
            AzParseIntErrorWithInput_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ParseIntErrorWithInput() { AzParseIntErrorWithInput_delete(&inner_); }

    void delete_();
    ParseIntErrorWithInput clone() const;
    bool partialEq(const ParseIntErrorWithInput& b) const;
    String toDbgString() const;

    const AzParseIntErrorWithInput& inner() const { return inner_; }
    AzParseIntErrorWithInput& inner() { return inner_; }
    const AzParseIntErrorWithInput* ptr() const { return &inner_; }
    AzParseIntErrorWithInput* ptr() { return &inner_; }
    AzParseIntErrorWithInput release() { AzParseIntErrorWithInput result = inner_; inner_ = {}; return result; }
    operator AzParseIntErrorWithInput() && noexcept { AzParseIntErrorWithInput result = inner_; inner_ = {}; return result; }
};

class ParseFloatErrorWithInput {
private:
    AzParseFloatErrorWithInput inner_;

    ParseFloatErrorWithInput(const ParseFloatErrorWithInput&) = delete;
    ParseFloatErrorWithInput& operator=(const ParseFloatErrorWithInput&) = delete;

public:
    explicit ParseFloatErrorWithInput(AzParseFloatErrorWithInput inner) noexcept : inner_(inner) {}

    ParseFloatErrorWithInput(ParseFloatErrorWithInput&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ParseFloatErrorWithInput& operator=(ParseFloatErrorWithInput&& other) noexcept {
        if (this != &other) {
            AzParseFloatErrorWithInput_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ParseFloatErrorWithInput() { AzParseFloatErrorWithInput_delete(&inner_); }

    void delete_();
    ParseFloatErrorWithInput clone() const;
    bool partialEq(const ParseFloatErrorWithInput& b) const;
    String toDbgString() const;

    const AzParseFloatErrorWithInput& inner() const { return inner_; }
    AzParseFloatErrorWithInput& inner() { return inner_; }
    const AzParseFloatErrorWithInput* ptr() const { return &inner_; }
    AzParseFloatErrorWithInput* ptr() { return &inner_; }
    AzParseFloatErrorWithInput release() { AzParseFloatErrorWithInput result = inner_; inner_ = {}; return result; }
    operator AzParseFloatErrorWithInput() && noexcept { AzParseFloatErrorWithInput result = inner_; inner_ = {}; return result; }
};

class CssRuleBlock {
private:
    AzCssRuleBlock inner_;

    CssRuleBlock(const CssRuleBlock&) = delete;
    CssRuleBlock& operator=(const CssRuleBlock&) = delete;

public:
    explicit CssRuleBlock(AzCssRuleBlock inner) noexcept : inner_(inner) {}

    CssRuleBlock(CssRuleBlock&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssRuleBlock& operator=(CssRuleBlock&& other) noexcept {
        if (this != &other) {
            AzCssRuleBlock_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssRuleBlock() { AzCssRuleBlock_delete(&inner_); }

    [[nodiscard]] static CssRuleBlock default_();

    void delete_();
    CssRuleBlock clone() const;
    bool partialEq(const CssRuleBlock& b) const;
    uint8_t partialCmp(const CssRuleBlock& b) const;
    uint8_t cmp(const CssRuleBlock& b) const;
    String toDbgString() const;

    const AzCssRuleBlock& inner() const { return inner_; }
    AzCssRuleBlock& inner() { return inner_; }
    const AzCssRuleBlock* ptr() const { return &inner_; }
    AzCssRuleBlock* ptr() { return &inner_; }
    AzCssRuleBlock release() { AzCssRuleBlock result = inner_; inner_ = {}; return result; }
    operator AzCssRuleBlock() && noexcept { AzCssRuleBlock result = inner_; inner_ = {}; return result; }
};

class RadialGradient {
private:
    AzRadialGradient inner_;

    RadialGradient(const RadialGradient&) = delete;
    RadialGradient& operator=(const RadialGradient&) = delete;

public:
    explicit RadialGradient(AzRadialGradient inner) noexcept : inner_(inner) {}

    RadialGradient(RadialGradient&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RadialGradient& operator=(RadialGradient&& other) noexcept {
        if (this != &other) {
            AzRadialGradient_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RadialGradient() { AzRadialGradient_delete(&inner_); }

    [[nodiscard]] static RadialGradient default_();

    void delete_();
    RadialGradient clone() const;
    bool partialEq(const RadialGradient& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const RadialGradient& b) const;
    uint8_t cmp(const RadialGradient& b) const;
    String toDbgString() const;

    const AzRadialGradient& inner() const { return inner_; }
    AzRadialGradient& inner() { return inner_; }
    const AzRadialGradient* ptr() const { return &inner_; }
    AzRadialGradient* ptr() { return &inner_; }
    AzRadialGradient release() { AzRadialGradient result = inner_; inner_ = {}; return result; }
    operator AzRadialGradient() && noexcept { AzRadialGradient result = inner_; inner_ = {}; return result; }
};

class ConicGradient {
private:
    AzConicGradient inner_;

    ConicGradient(const ConicGradient&) = delete;
    ConicGradient& operator=(const ConicGradient&) = delete;

public:
    explicit ConicGradient(AzConicGradient inner) noexcept : inner_(inner) {}

    ConicGradient(ConicGradient&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ConicGradient& operator=(ConicGradient&& other) noexcept {
        if (this != &other) {
            AzConicGradient_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ConicGradient() { AzConicGradient_delete(&inner_); }

    [[nodiscard]] static ConicGradient default_();

    void delete_();
    ConicGradient clone() const;
    bool partialEq(const ConicGradient& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ConicGradient& b) const;
    uint8_t cmp(const ConicGradient& b) const;
    String toDbgString() const;

    const AzConicGradient& inner() const { return inner_; }
    AzConicGradient& inner() { return inner_; }
    const AzConicGradient* ptr() const { return &inner_; }
    AzConicGradient* ptr() { return &inner_; }
    AzConicGradient release() { AzConicGradient result = inner_; inner_ = {}; return result; }
    operator AzConicGradient() && noexcept { AzConicGradient result = inner_; inner_ = {}; return result; }
};

class CounterReset {
private:
    AzCounterReset inner_;

    CounterReset(const CounterReset&) = delete;
    CounterReset& operator=(const CounterReset&) = delete;

public:
    explicit CounterReset(AzCounterReset inner) noexcept : inner_(inner) {}

    CounterReset(CounterReset&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CounterReset& operator=(CounterReset&& other) noexcept {
        if (this != &other) {
            AzCounterReset_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CounterReset() { AzCounterReset_delete(&inner_); }

    [[nodiscard]] static CounterReset default_();

    void delete_();
    CounterReset clone() const;
    bool partialEq(const CounterReset& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CounterReset& b) const;
    uint8_t cmp(const CounterReset& b) const;
    String toDbgString() const;

    const AzCounterReset& inner() const { return inner_; }
    AzCounterReset& inner() { return inner_; }
    const AzCounterReset* ptr() const { return &inner_; }
    AzCounterReset* ptr() { return &inner_; }
    AzCounterReset release() { AzCounterReset result = inner_; inner_ = {}; return result; }
    operator AzCounterReset() && noexcept { AzCounterReset result = inner_; inner_ = {}; return result; }
};

class Content {
private:
    AzContent inner_;

    Content(const Content&) = delete;
    Content& operator=(const Content&) = delete;

public:
    explicit Content(AzContent inner) noexcept : inner_(inner) {}

    Content(Content&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Content& operator=(Content&& other) noexcept {
        if (this != &other) {
            AzContent_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Content() { AzContent_delete(&inner_); }

    [[nodiscard]] static Content default_();

    void delete_();
    Content clone() const;
    bool partialEq(const Content& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const Content& b) const;
    uint8_t cmp(const Content& b) const;
    String toDbgString() const;

    const AzContent& inner() const { return inner_; }
    AzContent& inner() { return inner_; }
    const AzContent* ptr() const { return &inner_; }
    AzContent* ptr() { return &inner_; }
    AzContent release() { AzContent result = inner_; inner_ = {}; return result; }
    operator AzContent() && noexcept { AzContent result = inner_; inner_ = {}; return result; }
};

class CounterIncrement {
private:
    AzCounterIncrement inner_;

    CounterIncrement(const CounterIncrement&) = delete;
    CounterIncrement& operator=(const CounterIncrement&) = delete;

public:
    explicit CounterIncrement(AzCounterIncrement inner) noexcept : inner_(inner) {}

    CounterIncrement(CounterIncrement&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CounterIncrement& operator=(CounterIncrement&& other) noexcept {
        if (this != &other) {
            AzCounterIncrement_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CounterIncrement() { AzCounterIncrement_delete(&inner_); }

    [[nodiscard]] static CounterIncrement default_();

    void delete_();
    CounterIncrement clone() const;
    bool partialEq(const CounterIncrement& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CounterIncrement& b) const;
    uint8_t cmp(const CounterIncrement& b) const;
    String toDbgString() const;

    const AzCounterIncrement& inner() const { return inner_; }
    AzCounterIncrement& inner() { return inner_; }
    const AzCounterIncrement* ptr() const { return &inner_; }
    AzCounterIncrement* ptr() { return &inner_; }
    AzCounterIncrement release() { AzCounterIncrement result = inner_; inner_ = {}; return result; }
    operator AzCounterIncrement() && noexcept { AzCounterIncrement result = inner_; inner_ = {}; return result; }
};

class StyleHyphenationLanguage {
private:
    AzStyleHyphenationLanguage inner_;

    StyleHyphenationLanguage(const StyleHyphenationLanguage&) = delete;
    StyleHyphenationLanguage& operator=(const StyleHyphenationLanguage&) = delete;

public:
    explicit StyleHyphenationLanguage(AzStyleHyphenationLanguage inner) noexcept : inner_(inner) {}

    StyleHyphenationLanguage(StyleHyphenationLanguage&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyleHyphenationLanguage& operator=(StyleHyphenationLanguage&& other) noexcept {
        if (this != &other) {
            AzStyleHyphenationLanguage_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyleHyphenationLanguage() { AzStyleHyphenationLanguage_delete(&inner_); }

    [[nodiscard]] static StyleHyphenationLanguage default_();

    void delete_();
    StyleHyphenationLanguage clone() const;
    bool partialEq(const StyleHyphenationLanguage& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StyleHyphenationLanguage& b) const;
    uint8_t cmp(const StyleHyphenationLanguage& b) const;
    String toDbgString() const;

    const AzStyleHyphenationLanguage& inner() const { return inner_; }
    AzStyleHyphenationLanguage& inner() { return inner_; }
    const AzStyleHyphenationLanguage* ptr() const { return &inner_; }
    AzStyleHyphenationLanguage* ptr() { return &inner_; }
    AzStyleHyphenationLanguage release() { AzStyleHyphenationLanguage result = inner_; inner_ = {}; return result; }
    operator AzStyleHyphenationLanguage() && noexcept { AzStyleHyphenationLanguage result = inner_; inner_ = {}; return result; }
};

class NamedGridLine {
private:
    AzNamedGridLine inner_;

    NamedGridLine(const NamedGridLine&) = delete;
    NamedGridLine& operator=(const NamedGridLine&) = delete;

public:
    explicit NamedGridLine(AzNamedGridLine inner) noexcept : inner_(inner) {}

    NamedGridLine(NamedGridLine&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NamedGridLine& operator=(NamedGridLine&& other) noexcept {
        if (this != &other) {
            AzNamedGridLine_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NamedGridLine() { AzNamedGridLine_delete(&inner_); }

    [[nodiscard]] static NamedGridLine create(String name, OptionI32 span);

    OptionI32 span() const;
    void delete_();
    NamedGridLine clone() const;
    bool partialEq(const NamedGridLine& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NamedGridLine& b) const;
    uint8_t cmp(const NamedGridLine& b) const;
    String toDbgString() const;

    const AzNamedGridLine& inner() const { return inner_; }
    AzNamedGridLine& inner() { return inner_; }
    const AzNamedGridLine* ptr() const { return &inner_; }
    AzNamedGridLine* ptr() { return &inner_; }
    AzNamedGridLine release() { AzNamedGridLine result = inner_; inner_ = {}; return result; }
    operator AzNamedGridLine() && noexcept { AzNamedGridLine result = inner_; inner_ = {}; return result; }
};

class ShapePath {
private:
    AzShapePath inner_;

    ShapePath(const ShapePath&) = delete;
    ShapePath& operator=(const ShapePath&) = delete;

public:
    explicit ShapePath(AzShapePath inner) noexcept : inner_(inner) {}

    ShapePath(ShapePath&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ShapePath& operator=(ShapePath&& other) noexcept {
        if (this != &other) {
            AzShapePath_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ShapePath() { AzShapePath_delete(&inner_); }

    void delete_();
    ShapePath clone() const;
    bool partialEq(const ShapePath& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ShapePath& b) const;
    uint8_t cmp(const ShapePath& b) const;
    String toDbgString() const;

    const AzShapePath& inner() const { return inner_; }
    AzShapePath& inner() { return inner_; }
    const AzShapePath* ptr() const { return &inner_; }
    AzShapePath* ptr() { return &inner_; }
    AzShapePath release() { AzShapePath result = inner_; inner_ = {}; return result; }
    operator AzShapePath() && noexcept { AzShapePath result = inner_; inner_ = {}; return result; }
};

class TextOpReplaceText {
private:
    AzTextOpReplaceText inner_;

    TextOpReplaceText(const TextOpReplaceText&) = delete;
    TextOpReplaceText& operator=(const TextOpReplaceText&) = delete;

public:
    explicit TextOpReplaceText(AzTextOpReplaceText inner) noexcept : inner_(inner) {}

    TextOpReplaceText(TextOpReplaceText&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextOpReplaceText& operator=(TextOpReplaceText&& other) noexcept {
        if (this != &other) {
            AzTextOpReplaceText_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextOpReplaceText() { AzTextOpReplaceText_delete(&inner_); }

    void delete_();
    TextOpReplaceText clone() const;
    String toDbgString() const;

    const AzTextOpReplaceText& inner() const { return inner_; }
    AzTextOpReplaceText& inner() { return inner_; }
    const AzTextOpReplaceText* ptr() const { return &inner_; }
    AzTextOpReplaceText* ptr() { return &inner_; }
    AzTextOpReplaceText release() { AzTextOpReplaceText result = inner_; inner_ = {}; return result; }
    operator AzTextOpReplaceText() && noexcept { AzTextOpReplaceText result = inner_; inner_ = {}; return result; }
};

class TextOpDeleteText {
private:
    AzTextOpDeleteText inner_;

    TextOpDeleteText(const TextOpDeleteText&) = delete;
    TextOpDeleteText& operator=(const TextOpDeleteText&) = delete;

public:
    explicit TextOpDeleteText(AzTextOpDeleteText inner) noexcept : inner_(inner) {}

    TextOpDeleteText(TextOpDeleteText&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextOpDeleteText& operator=(TextOpDeleteText&& other) noexcept {
        if (this != &other) {
            AzTextOpDeleteText_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextOpDeleteText() { AzTextOpDeleteText_delete(&inner_); }

    void delete_();
    TextOpDeleteText clone() const;
    String toDbgString() const;

    const AzTextOpDeleteText& inner() const { return inner_; }
    AzTextOpDeleteText& inner() { return inner_; }
    const AzTextOpDeleteText* ptr() const { return &inner_; }
    AzTextOpDeleteText* ptr() { return &inner_; }
    AzTextOpDeleteText release() { AzTextOpDeleteText result = inner_; inner_ = {}; return result; }
    operator AzTextOpDeleteText() && noexcept { AzTextOpDeleteText result = inner_; inner_ = {}; return result; }
};

class TextOpSelectAll {
private:
    AzTextOpSelectAll inner_;

    TextOpSelectAll(const TextOpSelectAll&) = delete;
    TextOpSelectAll& operator=(const TextOpSelectAll&) = delete;

public:
    explicit TextOpSelectAll(AzTextOpSelectAll inner) noexcept : inner_(inner) {}

    TextOpSelectAll(TextOpSelectAll&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextOpSelectAll& operator=(TextOpSelectAll&& other) noexcept {
        if (this != &other) {
            AzTextOpSelectAll_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextOpSelectAll() { AzTextOpSelectAll_delete(&inner_); }

    void delete_();
    TextOpSelectAll clone() const;
    String toDbgString() const;

    const AzTextOpSelectAll& inner() const { return inner_; }
    AzTextOpSelectAll& inner() { return inner_; }
    const AzTextOpSelectAll* ptr() const { return &inner_; }
    AzTextOpSelectAll* ptr() { return &inner_; }
    AzTextOpSelectAll release() { AzTextOpSelectAll result = inner_; inner_ = {}; return result; }
    operator AzTextOpSelectAll() && noexcept { AzTextOpSelectAll result = inner_; inner_ = {}; return result; }
};

class TextOpInsertText {
private:
    AzTextOpInsertText inner_;

    TextOpInsertText(const TextOpInsertText&) = delete;
    TextOpInsertText& operator=(const TextOpInsertText&) = delete;

public:
    explicit TextOpInsertText(AzTextOpInsertText inner) noexcept : inner_(inner) {}

    TextOpInsertText(TextOpInsertText&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextOpInsertText& operator=(TextOpInsertText&& other) noexcept {
        if (this != &other) {
            AzTextOpInsertText_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextOpInsertText() { AzTextOpInsertText_delete(&inner_); }

    void delete_();
    TextOpInsertText clone() const;
    String toDbgString() const;

    const AzTextOpInsertText& inner() const { return inner_; }
    AzTextOpInsertText& inner() { return inner_; }
    const AzTextOpInsertText* ptr() const { return &inner_; }
    AzTextOpInsertText* ptr() { return &inner_; }
    AzTextOpInsertText release() { AzTextOpInsertText result = inner_; inner_ = {}; return result; }
    operator AzTextOpInsertText() && noexcept { AzTextOpInsertText result = inner_; inner_ = {}; return result; }
};

class PendingTextEdit {
private:
    AzPendingTextEdit inner_;

    PendingTextEdit(const PendingTextEdit&) = delete;
    PendingTextEdit& operator=(const PendingTextEdit&) = delete;

public:
    explicit PendingTextEdit(AzPendingTextEdit inner) noexcept : inner_(inner) {}

    PendingTextEdit(PendingTextEdit&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    PendingTextEdit& operator=(PendingTextEdit&& other) noexcept {
        if (this != &other) {
            AzPendingTextEdit_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~PendingTextEdit() { AzPendingTextEdit_delete(&inner_); }

    void delete_();
    PendingTextEdit clone() const;
    String toDbgString() const;

    const AzPendingTextEdit& inner() const { return inner_; }
    AzPendingTextEdit& inner() { return inner_; }
    const AzPendingTextEdit* ptr() const { return &inner_; }
    AzPendingTextEdit* ptr() { return &inner_; }
    AzPendingTextEdit release() { AzPendingTextEdit result = inner_; inner_ = {}; return result; }
    operator AzPendingTextEdit() && noexcept { AzPendingTextEdit result = inner_; inner_ = {}; return result; }
};

class NamedFont {
private:
    AzNamedFont inner_;

    NamedFont(const NamedFont&) = delete;
    NamedFont& operator=(const NamedFont&) = delete;

public:
    explicit NamedFont(AzNamedFont inner) noexcept : inner_(inner) {}

    NamedFont(NamedFont&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NamedFont& operator=(NamedFont&& other) noexcept {
        if (this != &other) {
            AzNamedFont_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NamedFont() { AzNamedFont_delete(&inner_); }

    [[nodiscard]] static NamedFont create(String name, U8Vec bytes);

    void delete_();
    NamedFont clone() const;
    bool partialEq(const NamedFont& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NamedFont& b) const;
    uint8_t cmp(const NamedFont& b) const;
    String toDbgString() const;

    const AzNamedFont& inner() const { return inner_; }
    AzNamedFont& inner() { return inner_; }
    const AzNamedFont* ptr() const { return &inner_; }
    AzNamedFont* ptr() { return &inner_; }
    AzNamedFont release() { AzNamedFont result = inner_; inner_ = {}; return result; }
    operator AzNamedFont() && noexcept { AzNamedFont result = inner_; inner_ = {}; return result; }
};

class GridAreaDefinition {
private:
    AzGridAreaDefinition inner_;

    GridAreaDefinition(const GridAreaDefinition&) = delete;
    GridAreaDefinition& operator=(const GridAreaDefinition&) = delete;

public:
    explicit GridAreaDefinition(AzGridAreaDefinition inner) noexcept : inner_(inner) {}

    GridAreaDefinition(GridAreaDefinition&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GridAreaDefinition& operator=(GridAreaDefinition&& other) noexcept {
        if (this != &other) {
            AzGridAreaDefinition_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GridAreaDefinition() { AzGridAreaDefinition_delete(&inner_); }

    void delete_();
    GridAreaDefinition clone() const;
    bool partialEq(const GridAreaDefinition& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GridAreaDefinition& b) const;
    uint8_t cmp(const GridAreaDefinition& b) const;
    String toDbgString() const;

    const AzGridAreaDefinition& inner() const { return inner_; }
    AzGridAreaDefinition& inner() { return inner_; }
    const AzGridAreaDefinition* ptr() const { return &inner_; }
    AzGridAreaDefinition* ptr() { return &inner_; }
    AzGridAreaDefinition release() { AzGridAreaDefinition result = inner_; inner_ = {}; return result; }
    operator AzGridAreaDefinition() && noexcept { AzGridAreaDefinition result = inner_; inner_ = {}; return result; }
};

class InvalidValueErrOwned {
private:
    AzInvalidValueErrOwned inner_;

    InvalidValueErrOwned(const InvalidValueErrOwned&) = delete;
    InvalidValueErrOwned& operator=(const InvalidValueErrOwned&) = delete;

public:
    explicit InvalidValueErrOwned(AzInvalidValueErrOwned inner) noexcept : inner_(inner) {}

    InvalidValueErrOwned(InvalidValueErrOwned&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    InvalidValueErrOwned& operator=(InvalidValueErrOwned&& other) noexcept {
        if (this != &other) {
            AzInvalidValueErrOwned_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~InvalidValueErrOwned() { AzInvalidValueErrOwned_delete(&inner_); }

    void delete_();
    InvalidValueErrOwned clone() const;
    bool partialEq(const InvalidValueErrOwned& b) const;
    String toDbgString() const;

    const AzInvalidValueErrOwned& inner() const { return inner_; }
    AzInvalidValueErrOwned& inner() { return inner_; }
    const AzInvalidValueErrOwned* ptr() const { return &inner_; }
    AzInvalidValueErrOwned* ptr() { return &inner_; }
    AzInvalidValueErrOwned release() { AzInvalidValueErrOwned result = inner_; inner_ = {}; return result; }
    operator AzInvalidValueErrOwned() && noexcept { AzInvalidValueErrOwned result = inner_; inner_ = {}; return result; }
};

class FileTypeList {
private:
    AzFileTypeList inner_;

    FileTypeList(const FileTypeList&) = delete;
    FileTypeList& operator=(const FileTypeList&) = delete;

public:
    explicit FileTypeList(AzFileTypeList inner) noexcept : inner_(inner) {}

    FileTypeList(FileTypeList&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FileTypeList& operator=(FileTypeList&& other) noexcept {
        if (this != &other) {
            AzFileTypeList_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FileTypeList() { AzFileTypeList_delete(&inner_); }

    void delete_();
    FileTypeList clone() const;
    bool partialEq(const FileTypeList& b) const;
    uint8_t partialCmp(const FileTypeList& b) const;
    String toDbgString() const;

    const AzFileTypeList& inner() const { return inner_; }
    AzFileTypeList& inner() { return inner_; }
    const AzFileTypeList* ptr() const { return &inner_; }
    AzFileTypeList* ptr() { return &inner_; }
    AzFileTypeList release() { AzFileTypeList result = inner_; inner_ = {}; return result; }
    operator AzFileTypeList() && noexcept { AzFileTypeList result = inner_; inner_ = {}; return result; }
};

class MapTileLayer {
private:
    AzMapTileLayer inner_;

    MapTileLayer(const MapTileLayer&) = delete;
    MapTileLayer& operator=(const MapTileLayer&) = delete;

public:
    explicit MapTileLayer(AzMapTileLayer inner) noexcept : inner_(inner) {}

    MapTileLayer(MapTileLayer&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MapTileLayer& operator=(MapTileLayer&& other) noexcept {
        if (this != &other) {
            AzMapTileLayer_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MapTileLayer() { AzMapTileLayer_delete(&inner_); }

    [[nodiscard]] static MapTileLayer default_();

    void delete_();
    MapTileLayer clone() const;
    bool partialEq(const MapTileLayer& b) const;
    String toDbgString() const;

    const AzMapTileLayer& inner() const { return inner_; }
    AzMapTileLayer& inner() { return inner_; }
    const AzMapTileLayer* ptr() const { return &inner_; }
    AzMapTileLayer* ptr() { return &inner_; }
    AzMapTileLayer release() { AzMapTileLayer result = inner_; inner_ = {}; return result; }
    operator AzMapTileLayer() && noexcept { AzMapTileLayer result = inner_; inner_ = {}; return result; }
};

class ButtonOnClick {
private:
    AzButtonOnClick inner_;

    ButtonOnClick(const ButtonOnClick&) = delete;
    ButtonOnClick& operator=(const ButtonOnClick&) = delete;

public:
    explicit ButtonOnClick(AzButtonOnClick inner) noexcept : inner_(inner) {}

    ButtonOnClick(ButtonOnClick&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ButtonOnClick& operator=(ButtonOnClick&& other) noexcept {
        if (this != &other) {
            AzButtonOnClick_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ButtonOnClick() { AzButtonOnClick_delete(&inner_); }

    void delete_();
    ButtonOnClick clone() const;
    bool partialEq(const ButtonOnClick& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ButtonOnClick& b) const;
    uint8_t cmp(const ButtonOnClick& b) const;
    String toDbgString() const;

    const AzButtonOnClick& inner() const { return inner_; }
    AzButtonOnClick& inner() { return inner_; }
    const AzButtonOnClick* ptr() const { return &inner_; }
    AzButtonOnClick* ptr() { return &inner_; }
    AzButtonOnClick release() { AzButtonOnClick result = inner_; inner_ = {}; return result; }
    operator AzButtonOnClick() && noexcept { AzButtonOnClick result = inner_; inner_ = {}; return result; }
};

class FileInputOnPathChange {
private:
    AzFileInputOnPathChange inner_;

    FileInputOnPathChange(const FileInputOnPathChange&) = delete;
    FileInputOnPathChange& operator=(const FileInputOnPathChange&) = delete;

public:
    explicit FileInputOnPathChange(AzFileInputOnPathChange inner) noexcept : inner_(inner) {}

    FileInputOnPathChange(FileInputOnPathChange&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FileInputOnPathChange& operator=(FileInputOnPathChange&& other) noexcept {
        if (this != &other) {
            AzFileInputOnPathChange_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FileInputOnPathChange() { AzFileInputOnPathChange_delete(&inner_); }

    void delete_();
    FileInputOnPathChange clone() const;
    bool partialEq(const FileInputOnPathChange& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const FileInputOnPathChange& b) const;
    uint8_t cmp(const FileInputOnPathChange& b) const;
    String toDbgString() const;

    const AzFileInputOnPathChange& inner() const { return inner_; }
    AzFileInputOnPathChange& inner() { return inner_; }
    const AzFileInputOnPathChange* ptr() const { return &inner_; }
    AzFileInputOnPathChange* ptr() { return &inner_; }
    AzFileInputOnPathChange release() { AzFileInputOnPathChange result = inner_; inner_ = {}; return result; }
    operator AzFileInputOnPathChange() && noexcept { AzFileInputOnPathChange result = inner_; inner_ = {}; return result; }
};

class CheckBoxOnToggle {
private:
    AzCheckBoxOnToggle inner_;

    CheckBoxOnToggle(const CheckBoxOnToggle&) = delete;
    CheckBoxOnToggle& operator=(const CheckBoxOnToggle&) = delete;

public:
    explicit CheckBoxOnToggle(AzCheckBoxOnToggle inner) noexcept : inner_(inner) {}

    CheckBoxOnToggle(CheckBoxOnToggle&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CheckBoxOnToggle& operator=(CheckBoxOnToggle&& other) noexcept {
        if (this != &other) {
            AzCheckBoxOnToggle_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CheckBoxOnToggle() { AzCheckBoxOnToggle_delete(&inner_); }

    void delete_();
    CheckBoxOnToggle clone() const;
    bool partialEq(const CheckBoxOnToggle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CheckBoxOnToggle& b) const;
    uint8_t cmp(const CheckBoxOnToggle& b) const;
    String toDbgString() const;

    const AzCheckBoxOnToggle& inner() const { return inner_; }
    AzCheckBoxOnToggle& inner() { return inner_; }
    const AzCheckBoxOnToggle* ptr() const { return &inner_; }
    AzCheckBoxOnToggle* ptr() { return &inner_; }
    AzCheckBoxOnToggle release() { AzCheckBoxOnToggle result = inner_; inner_ = {}; return result; }
    operator AzCheckBoxOnToggle() && noexcept { AzCheckBoxOnToggle result = inner_; inner_ = {}; return result; }
};

class DropDownOnChoiceChange {
private:
    AzDropDownOnChoiceChange inner_;

    DropDownOnChoiceChange(const DropDownOnChoiceChange&) = delete;
    DropDownOnChoiceChange& operator=(const DropDownOnChoiceChange&) = delete;

public:
    explicit DropDownOnChoiceChange(AzDropDownOnChoiceChange inner) noexcept : inner_(inner) {}

    DropDownOnChoiceChange(DropDownOnChoiceChange&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DropDownOnChoiceChange& operator=(DropDownOnChoiceChange&& other) noexcept {
        if (this != &other) {
            AzDropDownOnChoiceChange_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DropDownOnChoiceChange() { AzDropDownOnChoiceChange_delete(&inner_); }

    void delete_();
    DropDownOnChoiceChange clone() const;
    bool partialEq(const DropDownOnChoiceChange& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const DropDownOnChoiceChange& b) const;
    uint8_t cmp(const DropDownOnChoiceChange& b) const;
    String toDbgString() const;

    const AzDropDownOnChoiceChange& inner() const { return inner_; }
    AzDropDownOnChoiceChange& inner() { return inner_; }
    const AzDropDownOnChoiceChange* ptr() const { return &inner_; }
    AzDropDownOnChoiceChange* ptr() { return &inner_; }
    AzDropDownOnChoiceChange release() { AzDropDownOnChoiceChange result = inner_; inner_ = {}; return result; }
    operator AzDropDownOnChoiceChange() && noexcept { AzDropDownOnChoiceChange result = inner_; inner_ = {}; return result; }
};

class ColorInputOnValueChange {
private:
    AzColorInputOnValueChange inner_;

    ColorInputOnValueChange(const ColorInputOnValueChange&) = delete;
    ColorInputOnValueChange& operator=(const ColorInputOnValueChange&) = delete;

public:
    explicit ColorInputOnValueChange(AzColorInputOnValueChange inner) noexcept : inner_(inner) {}

    ColorInputOnValueChange(ColorInputOnValueChange&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ColorInputOnValueChange& operator=(ColorInputOnValueChange&& other) noexcept {
        if (this != &other) {
            AzColorInputOnValueChange_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ColorInputOnValueChange() { AzColorInputOnValueChange_delete(&inner_); }

    void delete_();
    ColorInputOnValueChange clone() const;
    bool partialEq(const ColorInputOnValueChange& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ColorInputOnValueChange& b) const;
    uint8_t cmp(const ColorInputOnValueChange& b) const;
    String toDbgString() const;

    const AzColorInputOnValueChange& inner() const { return inner_; }
    AzColorInputOnValueChange& inner() { return inner_; }
    const AzColorInputOnValueChange* ptr() const { return &inner_; }
    AzColorInputOnValueChange* ptr() { return &inner_; }
    AzColorInputOnValueChange release() { AzColorInputOnValueChange result = inner_; inner_ = {}; return result; }
    operator AzColorInputOnValueChange() && noexcept { AzColorInputOnValueChange result = inner_; inner_ = {}; return result; }
};

class TextInputOnTextInput {
private:
    AzTextInputOnTextInput inner_;

    TextInputOnTextInput(const TextInputOnTextInput&) = delete;
    TextInputOnTextInput& operator=(const TextInputOnTextInput&) = delete;

public:
    explicit TextInputOnTextInput(AzTextInputOnTextInput inner) noexcept : inner_(inner) {}

    TextInputOnTextInput(TextInputOnTextInput&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextInputOnTextInput& operator=(TextInputOnTextInput&& other) noexcept {
        if (this != &other) {
            AzTextInputOnTextInput_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextInputOnTextInput() { AzTextInputOnTextInput_delete(&inner_); }

    void delete_();
    TextInputOnTextInput clone() const;
    bool partialEq(const TextInputOnTextInput& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TextInputOnTextInput& b) const;
    uint8_t cmp(const TextInputOnTextInput& b) const;
    String toDbgString() const;

    const AzTextInputOnTextInput& inner() const { return inner_; }
    AzTextInputOnTextInput& inner() { return inner_; }
    const AzTextInputOnTextInput* ptr() const { return &inner_; }
    AzTextInputOnTextInput* ptr() { return &inner_; }
    AzTextInputOnTextInput release() { AzTextInputOnTextInput result = inner_; inner_ = {}; return result; }
    operator AzTextInputOnTextInput() && noexcept { AzTextInputOnTextInput result = inner_; inner_ = {}; return result; }
};

class TextInputOnFocusLost {
private:
    AzTextInputOnFocusLost inner_;

    TextInputOnFocusLost(const TextInputOnFocusLost&) = delete;
    TextInputOnFocusLost& operator=(const TextInputOnFocusLost&) = delete;

public:
    explicit TextInputOnFocusLost(AzTextInputOnFocusLost inner) noexcept : inner_(inner) {}

    TextInputOnFocusLost(TextInputOnFocusLost&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextInputOnFocusLost& operator=(TextInputOnFocusLost&& other) noexcept {
        if (this != &other) {
            AzTextInputOnFocusLost_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextInputOnFocusLost() { AzTextInputOnFocusLost_delete(&inner_); }

    void delete_();
    TextInputOnFocusLost clone() const;
    bool partialEq(const TextInputOnFocusLost& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TextInputOnFocusLost& b) const;
    uint8_t cmp(const TextInputOnFocusLost& b) const;
    String toDbgString() const;

    const AzTextInputOnFocusLost& inner() const { return inner_; }
    AzTextInputOnFocusLost& inner() { return inner_; }
    const AzTextInputOnFocusLost* ptr() const { return &inner_; }
    AzTextInputOnFocusLost* ptr() { return &inner_; }
    AzTextInputOnFocusLost release() { AzTextInputOnFocusLost result = inner_; inner_ = {}; return result; }
    operator AzTextInputOnFocusLost() && noexcept { AzTextInputOnFocusLost result = inner_; inner_ = {}; return result; }
};

class NumberInputOnValueChange {
private:
    AzNumberInputOnValueChange inner_;

    NumberInputOnValueChange(const NumberInputOnValueChange&) = delete;
    NumberInputOnValueChange& operator=(const NumberInputOnValueChange&) = delete;

public:
    explicit NumberInputOnValueChange(AzNumberInputOnValueChange inner) noexcept : inner_(inner) {}

    NumberInputOnValueChange(NumberInputOnValueChange&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NumberInputOnValueChange& operator=(NumberInputOnValueChange&& other) noexcept {
        if (this != &other) {
            AzNumberInputOnValueChange_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NumberInputOnValueChange() { AzNumberInputOnValueChange_delete(&inner_); }

    void delete_();
    NumberInputOnValueChange clone() const;
    bool partialEq(const NumberInputOnValueChange& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NumberInputOnValueChange& b) const;
    uint8_t cmp(const NumberInputOnValueChange& b) const;
    String toDbgString() const;

    const AzNumberInputOnValueChange& inner() const { return inner_; }
    AzNumberInputOnValueChange& inner() { return inner_; }
    const AzNumberInputOnValueChange* ptr() const { return &inner_; }
    AzNumberInputOnValueChange* ptr() { return &inner_; }
    AzNumberInputOnValueChange release() { AzNumberInputOnValueChange result = inner_; inner_ = {}; return result; }
    operator AzNumberInputOnValueChange() && noexcept { AzNumberInputOnValueChange result = inner_; inner_ = {}; return result; }
};

class NumberInputOnFocusLost {
private:
    AzNumberInputOnFocusLost inner_;

    NumberInputOnFocusLost(const NumberInputOnFocusLost&) = delete;
    NumberInputOnFocusLost& operator=(const NumberInputOnFocusLost&) = delete;

public:
    explicit NumberInputOnFocusLost(AzNumberInputOnFocusLost inner) noexcept : inner_(inner) {}

    NumberInputOnFocusLost(NumberInputOnFocusLost&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NumberInputOnFocusLost& operator=(NumberInputOnFocusLost&& other) noexcept {
        if (this != &other) {
            AzNumberInputOnFocusLost_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NumberInputOnFocusLost() { AzNumberInputOnFocusLost_delete(&inner_); }

    void delete_();
    NumberInputOnFocusLost clone() const;
    bool partialEq(const NumberInputOnFocusLost& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NumberInputOnFocusLost& b) const;
    uint8_t cmp(const NumberInputOnFocusLost& b) const;
    String toDbgString() const;

    const AzNumberInputOnFocusLost& inner() const { return inner_; }
    AzNumberInputOnFocusLost& inner() { return inner_; }
    const AzNumberInputOnFocusLost* ptr() const { return &inner_; }
    AzNumberInputOnFocusLost* ptr() { return &inner_; }
    AzNumberInputOnFocusLost release() { AzNumberInputOnFocusLost result = inner_; inner_ = {}; return result; }
    operator AzNumberInputOnFocusLost() && noexcept { AzNumberInputOnFocusLost result = inner_; inner_ = {}; return result; }
};

class TabOnClick {
private:
    AzTabOnClick inner_;

    TabOnClick(const TabOnClick&) = delete;
    TabOnClick& operator=(const TabOnClick&) = delete;

public:
    explicit TabOnClick(AzTabOnClick inner) noexcept : inner_(inner) {}

    TabOnClick(TabOnClick&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TabOnClick& operator=(TabOnClick&& other) noexcept {
        if (this != &other) {
            AzTabOnClick_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TabOnClick() { AzTabOnClick_delete(&inner_); }

    void delete_();
    TabOnClick clone() const;
    bool partialEq(const TabOnClick& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TabOnClick& b) const;
    uint8_t cmp(const TabOnClick& b) const;
    String toDbgString() const;

    const AzTabOnClick& inner() const { return inner_; }
    AzTabOnClick& inner() { return inner_; }
    const AzTabOnClick* ptr() const { return &inner_; }
    AzTabOnClick* ptr() { return &inner_; }
    AzTabOnClick release() { AzTabOnClick result = inner_; inner_ = {}; return result; }
    operator AzTabOnClick() && noexcept { AzTabOnClick result = inner_; inner_ = {}; return result; }
};

class ListViewRow {
private:
    AzListViewRow inner_;

    ListViewRow(const ListViewRow&) = delete;
    ListViewRow& operator=(const ListViewRow&) = delete;

public:
    explicit ListViewRow(AzListViewRow inner) noexcept : inner_(inner) {}

    ListViewRow(ListViewRow&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ListViewRow& operator=(ListViewRow&& other) noexcept {
        if (this != &other) {
            AzListViewRow_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ListViewRow() { AzListViewRow_delete(&inner_); }

    void delete_();
    ListViewRow clone() const;
    String toDbgString() const;

    const AzListViewRow& inner() const { return inner_; }
    AzListViewRow& inner() { return inner_; }
    const AzListViewRow* ptr() const { return &inner_; }
    AzListViewRow* ptr() { return &inner_; }
    AzListViewRow release() { AzListViewRow result = inner_; inner_ = {}; return result; }
    operator AzListViewRow() && noexcept { AzListViewRow result = inner_; inner_ = {}; return result; }
};

class ListViewOnLazyLoadScroll {
private:
    AzListViewOnLazyLoadScroll inner_;

    ListViewOnLazyLoadScroll(const ListViewOnLazyLoadScroll&) = delete;
    ListViewOnLazyLoadScroll& operator=(const ListViewOnLazyLoadScroll&) = delete;

public:
    explicit ListViewOnLazyLoadScroll(AzListViewOnLazyLoadScroll inner) noexcept : inner_(inner) {}

    ListViewOnLazyLoadScroll(ListViewOnLazyLoadScroll&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ListViewOnLazyLoadScroll& operator=(ListViewOnLazyLoadScroll&& other) noexcept {
        if (this != &other) {
            AzListViewOnLazyLoadScroll_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ListViewOnLazyLoadScroll() { AzListViewOnLazyLoadScroll_delete(&inner_); }

    void delete_();
    ListViewOnLazyLoadScroll clone() const;
    bool partialEq(const ListViewOnLazyLoadScroll& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ListViewOnLazyLoadScroll& b) const;
    uint8_t cmp(const ListViewOnLazyLoadScroll& b) const;
    String toDbgString() const;

    const AzListViewOnLazyLoadScroll& inner() const { return inner_; }
    AzListViewOnLazyLoadScroll& inner() { return inner_; }
    const AzListViewOnLazyLoadScroll* ptr() const { return &inner_; }
    AzListViewOnLazyLoadScroll* ptr() { return &inner_; }
    AzListViewOnLazyLoadScroll release() { AzListViewOnLazyLoadScroll result = inner_; inner_ = {}; return result; }
    operator AzListViewOnLazyLoadScroll() && noexcept { AzListViewOnLazyLoadScroll result = inner_; inner_ = {}; return result; }
};

class ListViewOnColumnClick {
private:
    AzListViewOnColumnClick inner_;

    ListViewOnColumnClick(const ListViewOnColumnClick&) = delete;
    ListViewOnColumnClick& operator=(const ListViewOnColumnClick&) = delete;

public:
    explicit ListViewOnColumnClick(AzListViewOnColumnClick inner) noexcept : inner_(inner) {}

    ListViewOnColumnClick(ListViewOnColumnClick&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ListViewOnColumnClick& operator=(ListViewOnColumnClick&& other) noexcept {
        if (this != &other) {
            AzListViewOnColumnClick_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ListViewOnColumnClick() { AzListViewOnColumnClick_delete(&inner_); }

    void delete_();
    ListViewOnColumnClick clone() const;
    bool partialEq(const ListViewOnColumnClick& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ListViewOnColumnClick& b) const;
    uint8_t cmp(const ListViewOnColumnClick& b) const;
    String toDbgString() const;

    const AzListViewOnColumnClick& inner() const { return inner_; }
    AzListViewOnColumnClick& inner() { return inner_; }
    const AzListViewOnColumnClick* ptr() const { return &inner_; }
    AzListViewOnColumnClick* ptr() { return &inner_; }
    AzListViewOnColumnClick release() { AzListViewOnColumnClick result = inner_; inner_ = {}; return result; }
    operator AzListViewOnColumnClick() && noexcept { AzListViewOnColumnClick result = inner_; inner_ = {}; return result; }
};

class ListViewOnRowClick {
private:
    AzListViewOnRowClick inner_;

    ListViewOnRowClick(const ListViewOnRowClick&) = delete;
    ListViewOnRowClick& operator=(const ListViewOnRowClick&) = delete;

public:
    explicit ListViewOnRowClick(AzListViewOnRowClick inner) noexcept : inner_(inner) {}

    ListViewOnRowClick(ListViewOnRowClick&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ListViewOnRowClick& operator=(ListViewOnRowClick&& other) noexcept {
        if (this != &other) {
            AzListViewOnRowClick_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ListViewOnRowClick() { AzListViewOnRowClick_delete(&inner_); }

    void delete_();
    ListViewOnRowClick clone() const;
    bool partialEq(const ListViewOnRowClick& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ListViewOnRowClick& b) const;
    uint8_t cmp(const ListViewOnRowClick& b) const;
    String toDbgString() const;

    const AzListViewOnRowClick& inner() const { return inner_; }
    AzListViewOnRowClick& inner() { return inner_; }
    const AzListViewOnRowClick* ptr() const { return &inner_; }
    AzListViewOnRowClick* ptr() { return &inner_; }
    AzListViewOnRowClick release() { AzListViewOnRowClick result = inner_; inner_ = {}; return result; }
    operator AzListViewOnRowClick() && noexcept { AzListViewOnRowClick result = inner_; inner_ = {}; return result; }
};

class RibbonTab {
private:
    AzRibbonTab inner_;

    RibbonTab(const RibbonTab&) = delete;
    RibbonTab& operator=(const RibbonTab&) = delete;

public:
    explicit RibbonTab(AzRibbonTab inner) noexcept : inner_(inner) {}

    RibbonTab(RibbonTab&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RibbonTab& operator=(RibbonTab&& other) noexcept {
        if (this != &other) {
            AzRibbonTab_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RibbonTab() { AzRibbonTab_delete(&inner_); }

    [[nodiscard]] static RibbonTab new_(String label);

    void add_section(RibbonSection section);
    RibbonTab with_section(RibbonSection section) const;
    void delete_();
    RibbonTab clone() const;
    String toDbgString() const;

    const AzRibbonTab& inner() const { return inner_; }
    AzRibbonTab& inner() { return inner_; }
    const AzRibbonTab* ptr() const { return &inner_; }
    AzRibbonTab* ptr() { return &inner_; }
    AzRibbonTab release() { AzRibbonTab result = inner_; inner_ = {}; return result; }
    operator AzRibbonTab() && noexcept { AzRibbonTab result = inner_; inner_ = {}; return result; }
};

class RibbonOnTabClick {
private:
    AzRibbonOnTabClick inner_;

    RibbonOnTabClick(const RibbonOnTabClick&) = delete;
    RibbonOnTabClick& operator=(const RibbonOnTabClick&) = delete;

public:
    explicit RibbonOnTabClick(AzRibbonOnTabClick inner) noexcept : inner_(inner) {}

    RibbonOnTabClick(RibbonOnTabClick&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RibbonOnTabClick& operator=(RibbonOnTabClick&& other) noexcept {
        if (this != &other) {
            AzRibbonOnTabClick_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RibbonOnTabClick() { AzRibbonOnTabClick_delete(&inner_); }

    void delete_();
    RibbonOnTabClick clone() const;
    bool partialEq(const RibbonOnTabClick& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const RibbonOnTabClick& b) const;
    uint8_t cmp(const RibbonOnTabClick& b) const;
    String toDbgString() const;

    const AzRibbonOnTabClick& inner() const { return inner_; }
    AzRibbonOnTabClick& inner() { return inner_; }
    const AzRibbonOnTabClick* ptr() const { return &inner_; }
    AzRibbonOnTabClick* ptr() { return &inner_; }
    AzRibbonOnTabClick release() { AzRibbonOnTabClick result = inner_; inner_ = {}; return result; }
    operator AzRibbonOnTabClick() && noexcept { AzRibbonOnTabClick result = inner_; inner_ = {}; return result; }
};

class TreeViewNode {
private:
    AzTreeViewNode inner_;

    TreeViewNode(const TreeViewNode&) = delete;
    TreeViewNode& operator=(const TreeViewNode&) = delete;

public:
    explicit TreeViewNode(AzTreeViewNode inner) noexcept : inner_(inner) {}

    TreeViewNode(TreeViewNode&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TreeViewNode& operator=(TreeViewNode&& other) noexcept {
        if (this != &other) {
            AzTreeViewNode_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TreeViewNode() { AzTreeViewNode_delete(&inner_); }

    [[nodiscard]] static TreeViewNode new_(String label);

    void add_child(TreeViewNode child);
    TreeViewNode with_child(TreeViewNode child) const;
    TreeViewNode with_expanded(bool expanded) const;
    TreeViewNode with_selected(bool selected) const;
    void delete_();
    TreeViewNode clone() const;
    bool partialEq(const TreeViewNode& b) const;
    String toDbgString() const;

    const AzTreeViewNode& inner() const { return inner_; }
    AzTreeViewNode& inner() { return inner_; }
    const AzTreeViewNode* ptr() const { return &inner_; }
    AzTreeViewNode* ptr() { return &inner_; }
    AzTreeViewNode release() { AzTreeViewNode result = inner_; inner_ = {}; return result; }
    operator AzTreeViewNode() && noexcept { AzTreeViewNode result = inner_; inner_ = {}; return result; }
};

class TreeViewOnNodeClick {
private:
    AzTreeViewOnNodeClick inner_;

    TreeViewOnNodeClick(const TreeViewOnNodeClick&) = delete;
    TreeViewOnNodeClick& operator=(const TreeViewOnNodeClick&) = delete;

public:
    explicit TreeViewOnNodeClick(AzTreeViewOnNodeClick inner) noexcept : inner_(inner) {}

    TreeViewOnNodeClick(TreeViewOnNodeClick&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TreeViewOnNodeClick& operator=(TreeViewOnNodeClick&& other) noexcept {
        if (this != &other) {
            AzTreeViewOnNodeClick_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TreeViewOnNodeClick() { AzTreeViewOnNodeClick_delete(&inner_); }

    void delete_();
    TreeViewOnNodeClick clone() const;
    bool partialEq(const TreeViewOnNodeClick& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const TreeViewOnNodeClick& b) const;
    uint8_t cmp(const TreeViewOnNodeClick& b) const;
    String toDbgString() const;

    const AzTreeViewOnNodeClick& inner() const { return inner_; }
    AzTreeViewOnNodeClick& inner() { return inner_; }
    const AzTreeViewOnNodeClick* ptr() const { return &inner_; }
    AzTreeViewOnNodeClick* ptr() { return &inner_; }
    AzTreeViewOnNodeClick release() { AzTreeViewOnNodeClick result = inner_; inner_ = {}; return result; }
    operator AzTreeViewOnNodeClick() && noexcept { AzTreeViewOnNodeClick result = inner_; inner_ = {}; return result; }
};

class Titlebar {
private:
    AzTitlebar inner_;

    Titlebar(const Titlebar&) = delete;
    Titlebar& operator=(const Titlebar&) = delete;

public:
    explicit Titlebar(AzTitlebar inner) noexcept : inner_(inner) {}

    Titlebar(Titlebar&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Titlebar& operator=(Titlebar&& other) noexcept {
        if (this != &other) {
            AzTitlebar_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Titlebar() { AzTitlebar_delete(&inner_); }

    [[nodiscard]] static Titlebar new_(String title);
    [[nodiscard]] static Titlebar default_();

    Dom dom() const;
    Dom domWithButtons(TitlebarButtons buttons, AzTitlebarButtonSide button_side) const;
    void delete_();
    Titlebar clone() const;
    bool partialEq(const Titlebar& b) const;
    uint8_t partialCmp(const Titlebar& b) const;
    String toDbgString() const;

    const AzTitlebar& inner() const { return inner_; }
    AzTitlebar& inner() { return inner_; }
    const AzTitlebar* ptr() const { return &inner_; }
    AzTitlebar* ptr() { return &inner_; }
    AzTitlebar release() { AzTitlebar result = inner_; inner_ = {}; return result; }
    operator AzTitlebar() && noexcept { AzTitlebar result = inner_; inner_ = {}; return result; }
};

class OnVideoFrame {
private:
    AzOnVideoFrame inner_;

    OnVideoFrame(const OnVideoFrame&) = delete;
    OnVideoFrame& operator=(const OnVideoFrame&) = delete;

public:
    explicit OnVideoFrame(AzOnVideoFrame inner) noexcept : inner_(inner) {}

    OnVideoFrame(OnVideoFrame&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OnVideoFrame& operator=(OnVideoFrame&& other) noexcept {
        if (this != &other) {
            AzOnVideoFrame_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OnVideoFrame() { AzOnVideoFrame_delete(&inner_); }

    void delete_();
    OnVideoFrame clone() const;
    bool partialEq(const OnVideoFrame& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OnVideoFrame& b) const;
    uint8_t cmp(const OnVideoFrame& b) const;
    String toDbgString() const;

    const AzOnVideoFrame& inner() const { return inner_; }
    AzOnVideoFrame& inner() { return inner_; }
    const AzOnVideoFrame* ptr() const { return &inner_; }
    AzOnVideoFrame* ptr() { return &inner_; }
    AzOnVideoFrame release() { AzOnVideoFrame result = inner_; inner_ = {}; return result; }
    operator AzOnVideoFrame() && noexcept { AzOnVideoFrame result = inner_; inner_ = {}; return result; }
};

class MapViewportChanged {
private:
    AzMapViewportChanged inner_;

    MapViewportChanged(const MapViewportChanged&) = delete;
    MapViewportChanged& operator=(const MapViewportChanged&) = delete;

public:
    explicit MapViewportChanged(AzMapViewportChanged inner) noexcept : inner_(inner) {}

    MapViewportChanged(MapViewportChanged&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MapViewportChanged& operator=(MapViewportChanged&& other) noexcept {
        if (this != &other) {
            AzMapViewportChanged_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MapViewportChanged() { AzMapViewportChanged_delete(&inner_); }

    void delete_();
    MapViewportChanged clone() const;
    bool partialEq(const MapViewportChanged& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const MapViewportChanged& b) const;
    uint8_t cmp(const MapViewportChanged& b) const;
    String toDbgString() const;

    const AzMapViewportChanged& inner() const { return inner_; }
    AzMapViewportChanged& inner() { return inner_; }
    const AzMapViewportChanged* ptr() const { return &inner_; }
    AzMapViewportChanged* ptr() { return &inner_; }
    AzMapViewportChanged release() { AzMapViewportChanged result = inner_; inner_ = {}; return result; }
    operator AzMapViewportChanged() && noexcept { AzMapViewportChanged result = inner_; inner_ = {}; return result; }
};

class OnAudioFrame {
private:
    AzOnAudioFrame inner_;

    OnAudioFrame(const OnAudioFrame&) = delete;
    OnAudioFrame& operator=(const OnAudioFrame&) = delete;

public:
    explicit OnAudioFrame(AzOnAudioFrame inner) noexcept : inner_(inner) {}

    OnAudioFrame(OnAudioFrame&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OnAudioFrame& operator=(OnAudioFrame&& other) noexcept {
        if (this != &other) {
            AzOnAudioFrame_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OnAudioFrame() { AzOnAudioFrame_delete(&inner_); }

    void delete_();
    OnAudioFrame clone() const;
    bool partialEq(const OnAudioFrame& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OnAudioFrame& b) const;
    uint8_t cmp(const OnAudioFrame& b) const;
    String toDbgString() const;

    const AzOnAudioFrame& inner() const { return inner_; }
    AzOnAudioFrame& inner() { return inner_; }
    const AzOnAudioFrame* ptr() const { return &inner_; }
    AzOnAudioFrame* ptr() { return &inner_; }
    AzOnAudioFrame release() { AzOnAudioFrame result = inner_; inner_ = {}; return result; }
    operator AzOnAudioFrame() && noexcept { AzOnAudioFrame result = inner_; inner_ = {}; return result; }
};

class GetActiveAttribReturn {
private:
    AzGetActiveAttribReturn inner_;

    GetActiveAttribReturn(const GetActiveAttribReturn&) = delete;
    GetActiveAttribReturn& operator=(const GetActiveAttribReturn&) = delete;

public:
    explicit GetActiveAttribReturn(AzGetActiveAttribReturn inner) noexcept : inner_(inner) {}

    GetActiveAttribReturn(GetActiveAttribReturn&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GetActiveAttribReturn& operator=(GetActiveAttribReturn&& other) noexcept {
        if (this != &other) {
            AzGetActiveAttribReturn_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GetActiveAttribReturn() { AzGetActiveAttribReturn_delete(&inner_); }

    void delete_();
    GetActiveAttribReturn clone() const;
    bool partialEq(const GetActiveAttribReturn& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GetActiveAttribReturn& b) const;
    uint8_t cmp(const GetActiveAttribReturn& b) const;
    String toDbgString() const;

    const AzGetActiveAttribReturn& inner() const { return inner_; }
    AzGetActiveAttribReturn& inner() { return inner_; }
    const AzGetActiveAttribReturn* ptr() const { return &inner_; }
    AzGetActiveAttribReturn* ptr() { return &inner_; }
    AzGetActiveAttribReturn release() { AzGetActiveAttribReturn result = inner_; inner_ = {}; return result; }
    operator AzGetActiveAttribReturn() && noexcept { AzGetActiveAttribReturn result = inner_; inner_ = {}; return result; }
};

class GetActiveUniformReturn {
private:
    AzGetActiveUniformReturn inner_;

    GetActiveUniformReturn(const GetActiveUniformReturn&) = delete;
    GetActiveUniformReturn& operator=(const GetActiveUniformReturn&) = delete;

public:
    explicit GetActiveUniformReturn(AzGetActiveUniformReturn inner) noexcept : inner_(inner) {}

    GetActiveUniformReturn(GetActiveUniformReturn&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GetActiveUniformReturn& operator=(GetActiveUniformReturn&& other) noexcept {
        if (this != &other) {
            AzGetActiveUniformReturn_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GetActiveUniformReturn() { AzGetActiveUniformReturn_delete(&inner_); }

    void delete_();
    GetActiveUniformReturn clone() const;
    bool partialEq(const GetActiveUniformReturn& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GetActiveUniformReturn& b) const;
    uint8_t cmp(const GetActiveUniformReturn& b) const;
    String toDbgString() const;

    const AzGetActiveUniformReturn& inner() const { return inner_; }
    AzGetActiveUniformReturn& inner() { return inner_; }
    const AzGetActiveUniformReturn* ptr() const { return &inner_; }
    AzGetActiveUniformReturn* ptr() { return &inner_; }
    AzGetActiveUniformReturn release() { AzGetActiveUniformReturn result = inner_; inner_ = {}; return result; }
    operator AzGetActiveUniformReturn() && noexcept { AzGetActiveUniformReturn result = inner_; inner_ = {}; return result; }
};

class VertexArrayObject {
private:
    AzVertexArrayObject inner_;

    VertexArrayObject(const VertexArrayObject&) = delete;
    VertexArrayObject& operator=(const VertexArrayObject&) = delete;

public:
    explicit VertexArrayObject(AzVertexArrayObject inner) noexcept : inner_(inner) {}

    VertexArrayObject(VertexArrayObject&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VertexArrayObject& operator=(VertexArrayObject&& other) noexcept {
        if (this != &other) {
            AzVertexArrayObject_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VertexArrayObject() { AzVertexArrayObject_delete(&inner_); }

    void delete_();
    VertexArrayObject clone() const;
    bool partialEq(const VertexArrayObject& b) const;
    uint8_t partialCmp(const VertexArrayObject& b) const;
    String toDbgString() const;

    const AzVertexArrayObject& inner() const { return inner_; }
    AzVertexArrayObject& inner() { return inner_; }
    const AzVertexArrayObject* ptr() const { return &inner_; }
    AzVertexArrayObject* ptr() { return &inner_; }
    AzVertexArrayObject release() { AzVertexArrayObject result = inner_; inner_ = {}; return result; }
    operator AzVertexArrayObject() && noexcept { AzVertexArrayObject result = inner_; inner_ = {}; return result; }
};

class DebugMessage {
private:
    AzDebugMessage inner_;

    DebugMessage(const DebugMessage&) = delete;
    DebugMessage& operator=(const DebugMessage&) = delete;

public:
    explicit DebugMessage(AzDebugMessage inner) noexcept : inner_(inner) {}

    DebugMessage(DebugMessage&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DebugMessage& operator=(DebugMessage&& other) noexcept {
        if (this != &other) {
            AzDebugMessage_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DebugMessage() { AzDebugMessage_delete(&inner_); }

    void delete_();
    DebugMessage clone() const;
    bool partialEq(const DebugMessage& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const DebugMessage& b) const;
    uint8_t cmp(const DebugMessage& b) const;
    String toDbgString() const;

    const AzDebugMessage& inner() const { return inner_; }
    AzDebugMessage& inner() { return inner_; }
    const AzDebugMessage* ptr() const { return &inner_; }
    AzDebugMessage* ptr() { return &inner_; }
    AzDebugMessage release() { AzDebugMessage result = inner_; inner_ = {}; return result; }
    operator AzDebugMessage() && noexcept { AzDebugMessage result = inner_; inner_ = {}; return result; }
};

class RawImage {
private:
    AzRawImage inner_;

    RawImage(const RawImage&) = delete;
    RawImage& operator=(const RawImage&) = delete;

public:
    explicit RawImage(AzRawImage inner) noexcept : inner_(inner) {}

    RawImage(RawImage&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RawImage& operator=(RawImage&& other) noexcept {
        if (this != &other) {
            AzRawImage_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RawImage() { AzRawImage_delete(&inner_); }

    [[nodiscard]] static RawImage empty();
    [[nodiscard]] static RawImage allocate_clip_mask(LayoutSize size);
    [[nodiscard]] static ResultRawImageDecodeImageError decode_image_bytes_any(U8VecRef bytes);

    ResultU8VecEncodeImageError encode_bmp() const;
    ResultU8VecEncodeImageError encode_png() const;
    ResultU8VecEncodeImageError encode_jpeg(uint8_t quality) const;
    ResultU8VecEncodeImageError encode_tga() const;
    ResultU8VecEncodeImageError encode_pnm() const;
    ResultU8VecEncodeImageError encode_gif() const;
    ResultU8VecEncodeImageError encode_tiff() const;
    void delete_();
    RawImage clone() const;
    bool partialEq(const RawImage& b) const;
    uint8_t partialCmp(const RawImage& b) const;
    String toDbgString() const;

    const AzRawImage& inner() const { return inner_; }
    AzRawImage& inner() { return inner_; }
    const AzRawImage* ptr() const { return &inner_; }
    AzRawImage* ptr() { return &inner_; }
    AzRawImage release() { AzRawImage result = inner_; inner_ = {}; return result; }
    operator AzRawImage() && noexcept { AzRawImage result = inner_; inner_ = {}; return result; }
};

class Route {
private:
    AzRoute inner_;

    Route(const Route&) = delete;
    Route& operator=(const Route&) = delete;

public:
    explicit Route(AzRoute inner) noexcept : inner_(inner) {}

    Route(Route&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Route& operator=(Route&& other) noexcept {
        if (this != &other) {
            AzRoute_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Route() { AzRoute_delete(&inner_); }

    void delete_();
    Route clone() const;
    bool partialEq(const Route& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const Route& b) const;
    uint8_t cmp(const Route& b) const;
    String toDbgString() const;

    const AzRoute& inner() const { return inner_; }
    AzRoute& inner() { return inner_; }
    const AzRoute* ptr() const { return &inner_; }
    AzRoute* ptr() { return &inner_; }
    AzRoute release() { AzRoute result = inner_; inner_ = {}; return result; }
    operator AzRoute() && noexcept { AzRoute result = inner_; inner_ = {}; return result; }
};

class RouteMatch {
private:
    AzRouteMatch inner_;

    RouteMatch(const RouteMatch&) = delete;
    RouteMatch& operator=(const RouteMatch&) = delete;

public:
    explicit RouteMatch(AzRouteMatch inner) noexcept : inner_(inner) {}

    RouteMatch(RouteMatch&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RouteMatch& operator=(RouteMatch&& other) noexcept {
        if (this != &other) {
            AzRouteMatch_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RouteMatch() { AzRouteMatch_delete(&inner_); }

    void delete_();
    RouteMatch clone() const;
    bool partialEq(const RouteMatch& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const RouteMatch& b) const;
    uint8_t cmp(const RouteMatch& b) const;
    String toDbgString() const;

    const AzRouteMatch& inner() const { return inner_; }
    AzRouteMatch& inner() { return inner_; }
    const AzRouteMatch* ptr() const { return &inner_; }
    AzRouteMatch* ptr() { return &inner_; }
    AzRouteMatch release() { AzRouteMatch result = inner_; inner_ = {}; return result; }
    operator AzRouteMatch() && noexcept { AzRouteMatch result = inner_; inner_ = {}; return result; }
};

class LoadedFont {
private:
    AzLoadedFont inner_;

    LoadedFont(const LoadedFont&) = delete;
    LoadedFont& operator=(const LoadedFont&) = delete;

public:
    explicit LoadedFont(AzLoadedFont inner) noexcept : inner_(inner) {}

    LoadedFont(LoadedFont&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    LoadedFont& operator=(LoadedFont&& other) noexcept {
        if (this != &other) {
            AzLoadedFont_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~LoadedFont() { AzLoadedFont_delete(&inner_); }

    [[nodiscard]] static LoadedFont new_(uint64_t font_hash, String family_name, uint32_t num_glyphs, bool has_bytes);

    void delete_();
    LoadedFont clone() const;
    bool partialEq(const LoadedFont& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const LoadedFont& b) const;
    uint8_t cmp(const LoadedFont& b) const;
    String toDbgString() const;

    const AzLoadedFont& inner() const { return inner_; }
    AzLoadedFont& inner() { return inner_; }
    const AzLoadedFont* ptr() const { return &inner_; }
    AzLoadedFont* ptr() { return &inner_; }
    AzLoadedFont release() { AzLoadedFont result = inner_; inner_ = {}; return result; }
    operator AzLoadedFont() && noexcept { AzLoadedFont result = inner_; inner_ = {}; return result; }
};

class FilePath {
private:
    AzFilePath inner_;

    FilePath(const FilePath&) = delete;
    FilePath& operator=(const FilePath&) = delete;

public:
    explicit FilePath(AzFilePath inner) noexcept : inner_(inner) {}

    FilePath(FilePath&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FilePath& operator=(FilePath&& other) noexcept {
        if (this != &other) {
            AzFilePath_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FilePath() { AzFilePath_delete(&inner_); }

    [[nodiscard]] static FilePath create(String path);
    [[nodiscard]] static FilePath empty();
    [[nodiscard]] static FilePath from_str(String s);
    [[nodiscard]] static FilePath get_temp_dir();
    [[nodiscard]] static FilePath from(String s);
    [[nodiscard]] static FilePath default_();
    [[nodiscard]] static ResultFilePathFileError get_current_dir();
    [[nodiscard]] static OptionFilePath get_home_dir();
    [[nodiscard]] static OptionFilePath get_cache_dir();
    [[nodiscard]] static OptionFilePath get_config_dir();
    [[nodiscard]] static OptionFilePath get_config_local_dir();
    [[nodiscard]] static OptionFilePath get_data_dir();
    [[nodiscard]] static OptionFilePath get_data_local_dir();
    [[nodiscard]] static OptionFilePath get_desktop_dir();
    [[nodiscard]] static OptionFilePath get_document_dir();
    [[nodiscard]] static OptionFilePath get_download_dir();
    [[nodiscard]] static OptionFilePath get_executable_dir();
    [[nodiscard]] static OptionFilePath get_font_dir();
    [[nodiscard]] static OptionFilePath get_picture_dir();
    [[nodiscard]] static OptionFilePath get_preference_dir();
    [[nodiscard]] static OptionFilePath get_public_dir();
    [[nodiscard]] static OptionFilePath get_runtime_dir();
    [[nodiscard]] static OptionFilePath get_state_dir();
    [[nodiscard]] static OptionFilePath get_audio_dir();
    [[nodiscard]] static OptionFilePath get_video_dir();
    [[nodiscard]] static OptionFilePath get_template_dir();

    FilePath join(FilePath other) const;
    FilePath join_str(String component) const;
    OptionFilePath parent() const;
    OptionString file_name() const;
    OptionString extension() const;
    bool exists() const;
    bool is_file() const;
    bool is_dir() const;
    bool is_absolute() const;
    ResultEmptyStructFileError create_dir_all() const;
    ResultEmptyStructFileError create_dir() const;
    ResultEmptyStructFileError remove_file() const;
    ResultEmptyStructFileError remove_dir() const;
    ResultEmptyStructFileError remove_dir_all() const;
    ResultU8VecFileError read_bytes() const;
    ResultStringFileError read_string() const;
    ResultEmptyStructFileError write_bytes(U8Vec data) const;
    ResultEmptyStructFileError write_string(String data) const;
    Resultu64FileError copy_to(FilePath dest) const;
    ResultEmptyStructFileError rename_to(FilePath dest) const;
    String as_string() const;
    ResultDirEntryVecFileError read_dir() const;
    ResultFileMetadataFileError metadata() const;
    ResultFilePathFileError canonicalize() const;
    void delete_();
    FilePath clone() const;
    bool partialEq(const FilePath& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzFilePath& inner() const { return inner_; }
    AzFilePath& inner() { return inner_; }
    const AzFilePath* ptr() const { return &inner_; }
    AzFilePath* ptr() { return &inner_; }
    AzFilePath release() { AzFilePath result = inner_; inner_ = {}; return result; }
    operator AzFilePath() && noexcept { AzFilePath result = inner_; inner_ = {}; return result; }
};

class StringPair {
private:
    AzStringPair inner_;

    StringPair(const StringPair&) = delete;
    StringPair& operator=(const StringPair&) = delete;

public:
    explicit StringPair(AzStringPair inner) noexcept : inner_(inner) {}

    StringPair(StringPair&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StringPair& operator=(StringPair&& other) noexcept {
        if (this != &other) {
            AzStringPair_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StringPair() { AzStringPair_delete(&inner_); }

    [[nodiscard]] static StringPair default_();

    void delete_();
    StringPair clone() const;
    bool partialEq(const StringPair& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StringPair& b) const;
    uint8_t cmp(const StringPair& b) const;
    String toDbgString() const;

    const AzStringPair& inner() const { return inner_; }
    AzStringPair& inner() { return inner_; }
    const AzStringPair* ptr() const { return &inner_; }
    AzStringPair* ptr() { return &inner_; }
    AzStringPair release() { AzStringPair result = inner_; inner_ = {}; return result; }
    operator AzStringPair() && noexcept { AzStringPair result = inner_; inner_ = {}; return result; }
};

class StringSet {
private:
    AzStringSet inner_;

    StringSet(const StringSet&) = delete;
    StringSet& operator=(const StringSet&) = delete;

public:
    explicit StringSet(AzStringSet inner) noexcept : inner_(inner) {}

    StringSet(StringSet&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StringSet& operator=(StringSet&& other) noexcept {
        if (this != &other) {
            AzStringSet_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StringSet() { AzStringSet_delete(&inner_); }

    [[nodiscard]] static StringSet default_();

    void delete_();
    StringSet clone() const;
    bool partialEq(const StringSet& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StringSet& b) const;
    uint8_t cmp(const StringSet& b) const;
    String toDbgString() const;

    const AzStringSet& inner() const { return inner_; }
    AzStringSet& inner() { return inner_; }
    const AzStringSet* ptr() const { return &inner_; }
    AzStringSet* ptr() { return &inner_; }
    AzStringSet release() { AzStringSet result = inner_; inner_ = {}; return result; }
    operator AzStringSet() && noexcept { AzStringSet result = inner_; inner_ = {}; return result; }
};

class DuplicatedNamespaceError {
private:
    AzDuplicatedNamespaceError inner_;

    DuplicatedNamespaceError(const DuplicatedNamespaceError&) = delete;
    DuplicatedNamespaceError& operator=(const DuplicatedNamespaceError&) = delete;

public:
    explicit DuplicatedNamespaceError(AzDuplicatedNamespaceError inner) noexcept : inner_(inner) {}

    DuplicatedNamespaceError(DuplicatedNamespaceError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DuplicatedNamespaceError& operator=(DuplicatedNamespaceError&& other) noexcept {
        if (this != &other) {
            AzDuplicatedNamespaceError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DuplicatedNamespaceError() { AzDuplicatedNamespaceError_delete(&inner_); }

    void delete_();
    DuplicatedNamespaceError clone() const;
    bool partialEq(const DuplicatedNamespaceError& b) const;
    uint8_t partialCmp(const DuplicatedNamespaceError& b) const;
    String toDbgString() const;

    const AzDuplicatedNamespaceError& inner() const { return inner_; }
    AzDuplicatedNamespaceError& inner() { return inner_; }
    const AzDuplicatedNamespaceError* ptr() const { return &inner_; }
    AzDuplicatedNamespaceError* ptr() { return &inner_; }
    AzDuplicatedNamespaceError release() { AzDuplicatedNamespaceError result = inner_; inner_ = {}; return result; }
    operator AzDuplicatedNamespaceError() && noexcept { AzDuplicatedNamespaceError result = inner_; inner_ = {}; return result; }
};

class UnknownNamespaceError {
private:
    AzUnknownNamespaceError inner_;

    UnknownNamespaceError(const UnknownNamespaceError&) = delete;
    UnknownNamespaceError& operator=(const UnknownNamespaceError&) = delete;

public:
    explicit UnknownNamespaceError(AzUnknownNamespaceError inner) noexcept : inner_(inner) {}

    UnknownNamespaceError(UnknownNamespaceError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    UnknownNamespaceError& operator=(UnknownNamespaceError&& other) noexcept {
        if (this != &other) {
            AzUnknownNamespaceError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~UnknownNamespaceError() { AzUnknownNamespaceError_delete(&inner_); }

    void delete_();
    UnknownNamespaceError clone() const;
    bool partialEq(const UnknownNamespaceError& b) const;
    uint8_t partialCmp(const UnknownNamespaceError& b) const;
    String toDbgString() const;

    const AzUnknownNamespaceError& inner() const { return inner_; }
    AzUnknownNamespaceError& inner() { return inner_; }
    const AzUnknownNamespaceError* ptr() const { return &inner_; }
    AzUnknownNamespaceError* ptr() { return &inner_; }
    AzUnknownNamespaceError release() { AzUnknownNamespaceError result = inner_; inner_ = {}; return result; }
    operator AzUnknownNamespaceError() && noexcept { AzUnknownNamespaceError result = inner_; inner_ = {}; return result; }
};

class UnexpectedCloseTagError {
private:
    AzUnexpectedCloseTagError inner_;

    UnexpectedCloseTagError(const UnexpectedCloseTagError&) = delete;
    UnexpectedCloseTagError& operator=(const UnexpectedCloseTagError&) = delete;

public:
    explicit UnexpectedCloseTagError(AzUnexpectedCloseTagError inner) noexcept : inner_(inner) {}

    UnexpectedCloseTagError(UnexpectedCloseTagError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    UnexpectedCloseTagError& operator=(UnexpectedCloseTagError&& other) noexcept {
        if (this != &other) {
            AzUnexpectedCloseTagError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~UnexpectedCloseTagError() { AzUnexpectedCloseTagError_delete(&inner_); }

    void delete_();
    UnexpectedCloseTagError clone() const;
    bool partialEq(const UnexpectedCloseTagError& b) const;
    uint8_t partialCmp(const UnexpectedCloseTagError& b) const;
    String toDbgString() const;

    const AzUnexpectedCloseTagError& inner() const { return inner_; }
    AzUnexpectedCloseTagError& inner() { return inner_; }
    const AzUnexpectedCloseTagError* ptr() const { return &inner_; }
    AzUnexpectedCloseTagError* ptr() { return &inner_; }
    AzUnexpectedCloseTagError release() { AzUnexpectedCloseTagError result = inner_; inner_ = {}; return result; }
    operator AzUnexpectedCloseTagError() && noexcept { AzUnexpectedCloseTagError result = inner_; inner_ = {}; return result; }
};

class UnknownEntityReferenceError {
private:
    AzUnknownEntityReferenceError inner_;

    UnknownEntityReferenceError(const UnknownEntityReferenceError&) = delete;
    UnknownEntityReferenceError& operator=(const UnknownEntityReferenceError&) = delete;

public:
    explicit UnknownEntityReferenceError(AzUnknownEntityReferenceError inner) noexcept : inner_(inner) {}

    UnknownEntityReferenceError(UnknownEntityReferenceError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    UnknownEntityReferenceError& operator=(UnknownEntityReferenceError&& other) noexcept {
        if (this != &other) {
            AzUnknownEntityReferenceError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~UnknownEntityReferenceError() { AzUnknownEntityReferenceError_delete(&inner_); }

    void delete_();
    UnknownEntityReferenceError clone() const;
    bool partialEq(const UnknownEntityReferenceError& b) const;
    uint8_t partialCmp(const UnknownEntityReferenceError& b) const;
    String toDbgString() const;

    const AzUnknownEntityReferenceError& inner() const { return inner_; }
    AzUnknownEntityReferenceError& inner() { return inner_; }
    const AzUnknownEntityReferenceError* ptr() const { return &inner_; }
    AzUnknownEntityReferenceError* ptr() { return &inner_; }
    AzUnknownEntityReferenceError release() { AzUnknownEntityReferenceError result = inner_; inner_ = {}; return result; }
    operator AzUnknownEntityReferenceError() && noexcept { AzUnknownEntityReferenceError result = inner_; inner_ = {}; return result; }
};

class DuplicatedAttributeError {
private:
    AzDuplicatedAttributeError inner_;

    DuplicatedAttributeError(const DuplicatedAttributeError&) = delete;
    DuplicatedAttributeError& operator=(const DuplicatedAttributeError&) = delete;

public:
    explicit DuplicatedAttributeError(AzDuplicatedAttributeError inner) noexcept : inner_(inner) {}

    DuplicatedAttributeError(DuplicatedAttributeError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DuplicatedAttributeError& operator=(DuplicatedAttributeError&& other) noexcept {
        if (this != &other) {
            AzDuplicatedAttributeError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DuplicatedAttributeError() { AzDuplicatedAttributeError_delete(&inner_); }

    void delete_();
    DuplicatedAttributeError clone() const;
    bool partialEq(const DuplicatedAttributeError& b) const;
    uint8_t partialCmp(const DuplicatedAttributeError& b) const;
    String toDbgString() const;

    const AzDuplicatedAttributeError& inner() const { return inner_; }
    AzDuplicatedAttributeError& inner() { return inner_; }
    const AzDuplicatedAttributeError* ptr() const { return &inner_; }
    AzDuplicatedAttributeError* ptr() { return &inner_; }
    AzDuplicatedAttributeError release() { AzDuplicatedAttributeError result = inner_; inner_ = {}; return result; }
    operator AzDuplicatedAttributeError() && noexcept { AzDuplicatedAttributeError result = inner_; inner_ = {}; return result; }
};

class InvalidStringError {
private:
    AzInvalidStringError inner_;

    InvalidStringError(const InvalidStringError&) = delete;
    InvalidStringError& operator=(const InvalidStringError&) = delete;

public:
    explicit InvalidStringError(AzInvalidStringError inner) noexcept : inner_(inner) {}

    InvalidStringError(InvalidStringError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    InvalidStringError& operator=(InvalidStringError&& other) noexcept {
        if (this != &other) {
            AzInvalidStringError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~InvalidStringError() { AzInvalidStringError_delete(&inner_); }

    void delete_();
    InvalidStringError clone() const;
    bool partialEq(const InvalidStringError& b) const;
    uint8_t partialCmp(const InvalidStringError& b) const;
    String toDbgString() const;

    const AzInvalidStringError& inner() const { return inner_; }
    AzInvalidStringError& inner() { return inner_; }
    const AzInvalidStringError* ptr() const { return &inner_; }
    AzInvalidStringError* ptr() { return &inner_; }
    AzInvalidStringError release() { AzInvalidStringError result = inner_; inner_ = {}; return result; }
    operator AzInvalidStringError() && noexcept { AzInvalidStringError result = inner_; inner_ = {}; return result; }
};

class MalformedHierarchyError {
private:
    AzMalformedHierarchyError inner_;

    MalformedHierarchyError(const MalformedHierarchyError&) = delete;
    MalformedHierarchyError& operator=(const MalformedHierarchyError&) = delete;

public:
    explicit MalformedHierarchyError(AzMalformedHierarchyError inner) noexcept : inner_(inner) {}

    MalformedHierarchyError(MalformedHierarchyError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MalformedHierarchyError& operator=(MalformedHierarchyError&& other) noexcept {
        if (this != &other) {
            AzMalformedHierarchyError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MalformedHierarchyError() { AzMalformedHierarchyError_delete(&inner_); }

    void delete_();
    MalformedHierarchyError clone() const;
    bool partialEq(const MalformedHierarchyError& b) const;
    uint8_t partialCmp(const MalformedHierarchyError& b) const;
    String toDbgString() const;

    const AzMalformedHierarchyError& inner() const { return inner_; }
    AzMalformedHierarchyError& inner() { return inner_; }
    const AzMalformedHierarchyError* ptr() const { return &inner_; }
    AzMalformedHierarchyError* ptr() { return &inner_; }
    AzMalformedHierarchyError release() { AzMalformedHierarchyError result = inner_; inner_ = {}; return result; }
    operator AzMalformedHierarchyError() && noexcept { AzMalformedHierarchyError result = inner_; inner_ = {}; return result; }
};

class SelectAllResult {
private:
    AzSelectAllResult inner_;

    SelectAllResult(const SelectAllResult&) = delete;
    SelectAllResult& operator=(const SelectAllResult&) = delete;

public:
    explicit SelectAllResult(AzSelectAllResult inner) noexcept : inner_(inner) {}

    SelectAllResult(SelectAllResult&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SelectAllResult& operator=(SelectAllResult&& other) noexcept {
        if (this != &other) {
            AzSelectAllResult_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SelectAllResult() { AzSelectAllResult_delete(&inner_); }

    void delete_();
    SelectAllResult clone() const;
    bool partialEq(const SelectAllResult& b) const;
    String toDbgString() const;

    const AzSelectAllResult& inner() const { return inner_; }
    AzSelectAllResult& inner() { return inner_; }
    const AzSelectAllResult* ptr() const { return &inner_; }
    AzSelectAllResult* ptr() { return &inner_; }
    AzSelectAllResult release() { AzSelectAllResult result = inner_; inner_ = {}; return result; }
    operator AzSelectAllResult() && noexcept { AzSelectAllResult result = inner_; inner_ = {}; return result; }
};

class DeleteResult {
private:
    AzDeleteResult inner_;

    DeleteResult(const DeleteResult&) = delete;
    DeleteResult& operator=(const DeleteResult&) = delete;

public:
    explicit DeleteResult(AzDeleteResult inner) noexcept : inner_(inner) {}

    DeleteResult(DeleteResult&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DeleteResult& operator=(DeleteResult&& other) noexcept {
        if (this != &other) {
            AzDeleteResult_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DeleteResult() { AzDeleteResult_delete(&inner_); }

    void delete_();
    DeleteResult clone() const;
    bool partialEq(const DeleteResult& b) const;
    String toDbgString() const;

    const AzDeleteResult& inner() const { return inner_; }
    AzDeleteResult& inner() { return inner_; }
    const AzDeleteResult* ptr() const { return &inner_; }
    AzDeleteResult* ptr() { return &inner_; }
    AzDeleteResult release() { AzDeleteResult result = inner_; inner_ = {}; return result; }
    operator AzDeleteResult() && noexcept { AzDeleteResult result = inner_; inner_ = {}; return result; }
};

class IcuError {
private:
    AzIcuError inner_;

    IcuError(const IcuError&) = delete;
    IcuError& operator=(const IcuError&) = delete;

public:
    explicit IcuError(AzIcuError inner) noexcept : inner_(inner) {}

    IcuError(IcuError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    IcuError& operator=(IcuError&& other) noexcept {
        if (this != &other) {
            AzIcuError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~IcuError() { AzIcuError_delete(&inner_); }

    void delete_();
    IcuError clone() const;
    bool partialEq(const IcuError& b) const;
    String toDbgString() const;

    const AzIcuError& inner() const { return inner_; }
    AzIcuError& inner() { return inner_; }
    const AzIcuError* ptr() const { return &inner_; }
    AzIcuError* ptr() { return &inner_; }
    AzIcuError release() { AzIcuError result = inner_; inner_ = {}; return result; }
    operator AzIcuError() && noexcept { AzIcuError result = inner_; inner_ = {}; return result; }
};

class HttpStatusError {
private:
    AzHttpStatusError inner_;

    HttpStatusError(const HttpStatusError&) = delete;
    HttpStatusError& operator=(const HttpStatusError&) = delete;

public:
    explicit HttpStatusError(AzHttpStatusError inner) noexcept : inner_(inner) {}

    HttpStatusError(HttpStatusError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    HttpStatusError& operator=(HttpStatusError&& other) noexcept {
        if (this != &other) {
            AzHttpStatusError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~HttpStatusError() { AzHttpStatusError_delete(&inner_); }

    void delete_();
    HttpStatusError clone() const;
    bool partialEq(const HttpStatusError& b) const;
    String toDbgString() const;

    const AzHttpStatusError& inner() const { return inner_; }
    AzHttpStatusError& inner() { return inner_; }
    const AzHttpStatusError* ptr() const { return &inner_; }
    AzHttpStatusError* ptr() { return &inner_; }
    AzHttpStatusError release() { AzHttpStatusError result = inner_; inner_ = {}; return result; }
    operator AzHttpStatusError() && noexcept { AzHttpStatusError result = inner_; inner_ = {}; return result; }
};

class FileError {
private:
    AzFileError inner_;

    FileError(const FileError&) = delete;
    FileError& operator=(const FileError&) = delete;

public:
    explicit FileError(AzFileError inner) noexcept : inner_(inner) {}

    FileError(FileError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FileError& operator=(FileError&& other) noexcept {
        if (this != &other) {
            AzFileError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FileError() { AzFileError_delete(&inner_); }

    void delete_();
    FileError clone() const;
    bool partialEq(const FileError& b) const;
    String toDbgString() const;

    const AzFileError& inner() const { return inner_; }
    AzFileError& inner() { return inner_; }
    const AzFileError* ptr() const { return &inner_; }
    AzFileError* ptr() { return &inner_; }
    AzFileError release() { AzFileError result = inner_; inner_ = {}; return result; }
    operator AzFileError() && noexcept { AzFileError result = inner_; inner_ = {}; return result; }
};

class JsonParseError {
private:
    AzJsonParseError inner_;

    JsonParseError(const JsonParseError&) = delete;
    JsonParseError& operator=(const JsonParseError&) = delete;

public:
    explicit JsonParseError(AzJsonParseError inner) noexcept : inner_(inner) {}

    JsonParseError(JsonParseError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    JsonParseError& operator=(JsonParseError&& other) noexcept {
        if (this != &other) {
            AzJsonParseError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~JsonParseError() { AzJsonParseError_delete(&inner_); }

    void delete_();
    JsonParseError clone() const;
    bool partialEq(const JsonParseError& b) const;
    String toDbgString() const;

    const AzJsonParseError& inner() const { return inner_; }
    AzJsonParseError& inner() { return inner_; }
    const AzJsonParseError* ptr() const { return &inner_; }
    AzJsonParseError* ptr() { return &inner_; }
    AzJsonParseError release() { AzJsonParseError result = inner_; inner_ = {}; return result; }
    operator AzJsonParseError() && noexcept { AzJsonParseError result = inner_; inner_ = {}; return result; }
};

class UrlParseError {
private:
    AzUrlParseError inner_;

    UrlParseError(const UrlParseError&) = delete;
    UrlParseError& operator=(const UrlParseError&) = delete;

public:
    explicit UrlParseError(AzUrlParseError inner) noexcept : inner_(inner) {}

    UrlParseError(UrlParseError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    UrlParseError& operator=(UrlParseError&& other) noexcept {
        if (this != &other) {
            AzUrlParseError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~UrlParseError() { AzUrlParseError_delete(&inner_); }

    void delete_();
    UrlParseError clone() const;
    bool partialEq(const UrlParseError& b) const;
    String toDbgString() const;

    const AzUrlParseError& inner() const { return inner_; }
    AzUrlParseError& inner() { return inner_; }
    const AzUrlParseError* ptr() const { return &inner_; }
    AzUrlParseError* ptr() { return &inner_; }
    AzUrlParseError release() { AzUrlParseError result = inner_; inner_ = {}; return result; }
    operator AzUrlParseError() && noexcept { AzUrlParseError result = inner_; inner_ = {}; return result; }
};

class PixelNoValueGivenError {
private:
    AzPixelNoValueGivenError inner_;

    PixelNoValueGivenError(const PixelNoValueGivenError&) = delete;
    PixelNoValueGivenError& operator=(const PixelNoValueGivenError&) = delete;

public:
    explicit PixelNoValueGivenError(AzPixelNoValueGivenError inner) noexcept : inner_(inner) {}

    PixelNoValueGivenError(PixelNoValueGivenError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    PixelNoValueGivenError& operator=(PixelNoValueGivenError&& other) noexcept {
        if (this != &other) {
            AzPixelNoValueGivenError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~PixelNoValueGivenError() { AzPixelNoValueGivenError_delete(&inner_); }

    void delete_();
    PixelNoValueGivenError clone() const;
    bool partialEq(const PixelNoValueGivenError& b) const;
    String toDbgString() const;

    const AzPixelNoValueGivenError& inner() const { return inner_; }
    AzPixelNoValueGivenError& inner() { return inner_; }
    const AzPixelNoValueGivenError* ptr() const { return &inner_; }
    AzPixelNoValueGivenError* ptr() { return &inner_; }
    AzPixelNoValueGivenError release() { AzPixelNoValueGivenError result = inner_; inner_ = {}; return result; }
    operator AzPixelNoValueGivenError() && noexcept { AzPixelNoValueGivenError result = inner_; inner_ = {}; return result; }
};

class VarOnShorthandPropertyError {
private:
    AzVarOnShorthandPropertyError inner_;

    VarOnShorthandPropertyError(const VarOnShorthandPropertyError&) = delete;
    VarOnShorthandPropertyError& operator=(const VarOnShorthandPropertyError&) = delete;

public:
    explicit VarOnShorthandPropertyError(AzVarOnShorthandPropertyError inner) noexcept : inner_(inner) {}

    VarOnShorthandPropertyError(VarOnShorthandPropertyError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VarOnShorthandPropertyError& operator=(VarOnShorthandPropertyError&& other) noexcept {
        if (this != &other) {
            AzVarOnShorthandPropertyError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VarOnShorthandPropertyError() { AzVarOnShorthandPropertyError_delete(&inner_); }

    void delete_();
    VarOnShorthandPropertyError clone() const;
    bool partialEq(const VarOnShorthandPropertyError& b) const;
    String toDbgString() const;

    const AzVarOnShorthandPropertyError& inner() const { return inner_; }
    AzVarOnShorthandPropertyError& inner() { return inner_; }
    const AzVarOnShorthandPropertyError* ptr() const { return &inner_; }
    AzVarOnShorthandPropertyError* ptr() { return &inner_; }
    AzVarOnShorthandPropertyError release() { AzVarOnShorthandPropertyError result = inner_; inner_ = {}; return result; }
    operator AzVarOnShorthandPropertyError() && noexcept { AzVarOnShorthandPropertyError result = inner_; inner_ = {}; return result; }
};

class WrongComponentCountError {
private:
    AzWrongComponentCountError inner_;

    WrongComponentCountError(const WrongComponentCountError&) = delete;
    WrongComponentCountError& operator=(const WrongComponentCountError&) = delete;

public:
    explicit WrongComponentCountError(AzWrongComponentCountError inner) noexcept : inner_(inner) {}

    WrongComponentCountError(WrongComponentCountError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    WrongComponentCountError& operator=(WrongComponentCountError&& other) noexcept {
        if (this != &other) {
            AzWrongComponentCountError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~WrongComponentCountError() { AzWrongComponentCountError_delete(&inner_); }

    void delete_();
    WrongComponentCountError clone() const;
    bool partialEq(const WrongComponentCountError& b) const;
    String toDbgString() const;

    const AzWrongComponentCountError& inner() const { return inner_; }
    AzWrongComponentCountError& inner() { return inner_; }
    const AzWrongComponentCountError* ptr() const { return &inner_; }
    AzWrongComponentCountError* ptr() { return &inner_; }
    AzWrongComponentCountError release() { AzWrongComponentCountError result = inner_; inner_ = {}; return result; }
    operator AzWrongComponentCountError() && noexcept { AzWrongComponentCountError result = inner_; inner_ = {}; return result; }
};

class AngleNoValueGivenError {
private:
    AzAngleNoValueGivenError inner_;

    AngleNoValueGivenError(const AngleNoValueGivenError&) = delete;
    AngleNoValueGivenError& operator=(const AngleNoValueGivenError&) = delete;

public:
    explicit AngleNoValueGivenError(AzAngleNoValueGivenError inner) noexcept : inner_(inner) {}

    AngleNoValueGivenError(AngleNoValueGivenError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    AngleNoValueGivenError& operator=(AngleNoValueGivenError&& other) noexcept {
        if (this != &other) {
            AzAngleNoValueGivenError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~AngleNoValueGivenError() { AzAngleNoValueGivenError_delete(&inner_); }

    void delete_();
    AngleNoValueGivenError clone() const;
    bool partialEq(const AngleNoValueGivenError& b) const;
    String toDbgString() const;

    const AzAngleNoValueGivenError& inner() const { return inner_; }
    AzAngleNoValueGivenError& inner() { return inner_; }
    const AzAngleNoValueGivenError* ptr() const { return &inner_; }
    AzAngleNoValueGivenError* ptr() { return &inner_; }
    AzAngleNoValueGivenError release() { AzAngleNoValueGivenError result = inner_; inner_ = {}; return result; }
    operator AzAngleNoValueGivenError() && noexcept { AzAngleNoValueGivenError result = inner_; inner_ = {}; return result; }
};

class WhiteSpaceInComponentNameError {
private:
    AzWhiteSpaceInComponentNameError inner_;

    WhiteSpaceInComponentNameError(const WhiteSpaceInComponentNameError&) = delete;
    WhiteSpaceInComponentNameError& operator=(const WhiteSpaceInComponentNameError&) = delete;

public:
    explicit WhiteSpaceInComponentNameError(AzWhiteSpaceInComponentNameError inner) noexcept : inner_(inner) {}

    WhiteSpaceInComponentNameError(WhiteSpaceInComponentNameError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    WhiteSpaceInComponentNameError& operator=(WhiteSpaceInComponentNameError&& other) noexcept {
        if (this != &other) {
            AzWhiteSpaceInComponentNameError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~WhiteSpaceInComponentNameError() { AzWhiteSpaceInComponentNameError_delete(&inner_); }

    void delete_();
    WhiteSpaceInComponentNameError clone() const;
    bool partialEq(const WhiteSpaceInComponentNameError& b) const;
    String toDbgString() const;

    const AzWhiteSpaceInComponentNameError& inner() const { return inner_; }
    AzWhiteSpaceInComponentNameError& inner() { return inner_; }
    const AzWhiteSpaceInComponentNameError* ptr() const { return &inner_; }
    AzWhiteSpaceInComponentNameError* ptr() { return &inner_; }
    AzWhiteSpaceInComponentNameError release() { AzWhiteSpaceInComponentNameError result = inner_; inner_ = {}; return result; }
    operator AzWhiteSpaceInComponentNameError() && noexcept { AzWhiteSpaceInComponentNameError result = inner_; inner_ = {}; return result; }
};

class WhiteSpaceInComponentTypeError {
private:
    AzWhiteSpaceInComponentTypeError inner_;

    WhiteSpaceInComponentTypeError(const WhiteSpaceInComponentTypeError&) = delete;
    WhiteSpaceInComponentTypeError& operator=(const WhiteSpaceInComponentTypeError&) = delete;

public:
    explicit WhiteSpaceInComponentTypeError(AzWhiteSpaceInComponentTypeError inner) noexcept : inner_(inner) {}

    WhiteSpaceInComponentTypeError(WhiteSpaceInComponentTypeError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    WhiteSpaceInComponentTypeError& operator=(WhiteSpaceInComponentTypeError&& other) noexcept {
        if (this != &other) {
            AzWhiteSpaceInComponentTypeError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~WhiteSpaceInComponentTypeError() { AzWhiteSpaceInComponentTypeError_delete(&inner_); }

    void delete_();
    WhiteSpaceInComponentTypeError clone() const;
    bool partialEq(const WhiteSpaceInComponentTypeError& b) const;
    String toDbgString() const;

    const AzWhiteSpaceInComponentTypeError& inner() const { return inner_; }
    AzWhiteSpaceInComponentTypeError& inner() { return inner_; }
    const AzWhiteSpaceInComponentTypeError* ptr() const { return &inner_; }
    AzWhiteSpaceInComponentTypeError* ptr() { return &inner_; }
    AzWhiteSpaceInComponentTypeError release() { AzWhiteSpaceInComponentTypeError result = inner_; inner_ = {}; return result; }
    operator AzWhiteSpaceInComponentTypeError() && noexcept { AzWhiteSpaceInComponentTypeError result = inner_; inner_ = {}; return result; }
};

class UnknownPropertyKeyError {
private:
    AzUnknownPropertyKeyError inner_;

    UnknownPropertyKeyError(const UnknownPropertyKeyError&) = delete;
    UnknownPropertyKeyError& operator=(const UnknownPropertyKeyError&) = delete;

public:
    explicit UnknownPropertyKeyError(AzUnknownPropertyKeyError inner) noexcept : inner_(inner) {}

    UnknownPropertyKeyError(UnknownPropertyKeyError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    UnknownPropertyKeyError& operator=(UnknownPropertyKeyError&& other) noexcept {
        if (this != &other) {
            AzUnknownPropertyKeyError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~UnknownPropertyKeyError() { AzUnknownPropertyKeyError_delete(&inner_); }

    void delete_();
    UnknownPropertyKeyError clone() const;
    bool partialEq(const UnknownPropertyKeyError& b) const;
    String toDbgString() const;

    const AzUnknownPropertyKeyError& inner() const { return inner_; }
    AzUnknownPropertyKeyError& inner() { return inner_; }
    const AzUnknownPropertyKeyError* ptr() const { return &inner_; }
    AzUnknownPropertyKeyError* ptr() { return &inner_; }
    AzUnknownPropertyKeyError release() { AzUnknownPropertyKeyError result = inner_; inner_ = {}; return result; }
    operator AzUnknownPropertyKeyError() && noexcept { AzUnknownPropertyKeyError result = inner_; inner_ = {}; return result; }
};

class UselessFunctionArgumentError {
private:
    AzUselessFunctionArgumentError inner_;

    UselessFunctionArgumentError(const UselessFunctionArgumentError&) = delete;
    UselessFunctionArgumentError& operator=(const UselessFunctionArgumentError&) = delete;

public:
    explicit UselessFunctionArgumentError(AzUselessFunctionArgumentError inner) noexcept : inner_(inner) {}

    UselessFunctionArgumentError(UselessFunctionArgumentError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    UselessFunctionArgumentError& operator=(UselessFunctionArgumentError&& other) noexcept {
        if (this != &other) {
            AzUselessFunctionArgumentError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~UselessFunctionArgumentError() { AzUselessFunctionArgumentError_delete(&inner_); }

    void delete_();
    UselessFunctionArgumentError clone() const;
    bool partialEq(const UselessFunctionArgumentError& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const UselessFunctionArgumentError& b) const;
    uint8_t cmp(const UselessFunctionArgumentError& b) const;
    String toDbgString() const;

    const AzUselessFunctionArgumentError& inner() const { return inner_; }
    AzUselessFunctionArgumentError& inner() { return inner_; }
    const AzUselessFunctionArgumentError* ptr() const { return &inner_; }
    AzUselessFunctionArgumentError* ptr() { return &inner_; }
    AzUselessFunctionArgumentError release() { AzUselessFunctionArgumentError result = inner_; inner_ = {}; return result; }
    operator AzUselessFunctionArgumentError() && noexcept { AzUselessFunctionArgumentError result = inner_; inner_ = {}; return result; }
};

class MissingTypeError {
private:
    AzMissingTypeError inner_;

    MissingTypeError(const MissingTypeError&) = delete;
    MissingTypeError& operator=(const MissingTypeError&) = delete;

public:
    explicit MissingTypeError(AzMissingTypeError inner) noexcept : inner_(inner) {}

    MissingTypeError(MissingTypeError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MissingTypeError& operator=(MissingTypeError&& other) noexcept {
        if (this != &other) {
            AzMissingTypeError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MissingTypeError() { AzMissingTypeError_delete(&inner_); }

    void delete_();
    MissingTypeError clone() const;
    bool partialEq(const MissingTypeError& b) const;
    String toDbgString() const;

    const AzMissingTypeError& inner() const { return inner_; }
    AzMissingTypeError& inner() { return inner_; }
    const AzMissingTypeError* ptr() const { return &inner_; }
    AzMissingTypeError* ptr() { return &inner_; }
    AzMissingTypeError release() { AzMissingTypeError result = inner_; inner_ = {}; return result; }
    operator AzMissingTypeError() && noexcept { AzMissingTypeError result = inner_; inner_ = {}; return result; }
};

class MapPinTap {
private:
    AzMapPinTap inner_;

    MapPinTap(const MapPinTap&) = delete;
    MapPinTap& operator=(const MapPinTap&) = delete;

public:
    explicit MapPinTap(AzMapPinTap inner) noexcept : inner_(inner) {}

    MapPinTap(MapPinTap&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MapPinTap& operator=(MapPinTap&& other) noexcept {
        if (this != &other) {
            AzMapPinTap_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MapPinTap() { AzMapPinTap_delete(&inner_); }

    void delete_();
    MapPinTap clone() const;
    bool partialEq(const MapPinTap& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const MapPinTap& b) const;
    uint8_t cmp(const MapPinTap& b) const;
    String toDbgString() const;

    const AzMapPinTap& inner() const { return inner_; }
    AzMapPinTap& inner() { return inner_; }
    const AzMapPinTap* ptr() const { return &inner_; }
    AzMapPinTap* ptr() { return &inner_; }
    AzMapPinTap release() { AzMapPinTap result = inner_; inner_ = {}; return result; }
    operator AzMapPinTap() && noexcept { AzMapPinTap result = inner_; inner_ = {}; return result; }
};

class ThreadWriteBackMsg {
private:
    AzThreadWriteBackMsg inner_;

    ThreadWriteBackMsg(const ThreadWriteBackMsg&) = delete;
    ThreadWriteBackMsg& operator=(const ThreadWriteBackMsg&) = delete;

public:
    explicit ThreadWriteBackMsg(AzThreadWriteBackMsg inner) noexcept : inner_(inner) {}

    ThreadWriteBackMsg(ThreadWriteBackMsg&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ThreadWriteBackMsg& operator=(ThreadWriteBackMsg&& other) noexcept {
        if (this != &other) {
            AzThreadWriteBackMsg_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ThreadWriteBackMsg() { AzThreadWriteBackMsg_delete(&inner_); }

    [[nodiscard]] static ThreadWriteBackMsg create(AzWriteBackCallbackType callback, RefAny data);

    void delete_();
    ThreadWriteBackMsg clone() const;
    bool partialEq(const ThreadWriteBackMsg& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ThreadWriteBackMsg& b) const;
    uint8_t cmp(const ThreadWriteBackMsg& b) const;
    String toDbgString() const;

    const AzThreadWriteBackMsg& inner() const { return inner_; }
    AzThreadWriteBackMsg& inner() { return inner_; }
    const AzThreadWriteBackMsg* ptr() const { return &inner_; }
    AzThreadWriteBackMsg* ptr() { return &inner_; }
    AzThreadWriteBackMsg release() { AzThreadWriteBackMsg result = inner_; inner_ = {}; return result; }
    operator AzThreadWriteBackMsg() && noexcept { AzThreadWriteBackMsg result = inner_; inner_ = {}; return result; }
};

class Url {
private:
    AzUrl inner_;

    Url(const Url&) = delete;
    Url& operator=(const Url&) = delete;

public:
    explicit Url(AzUrl inner) noexcept : inner_(inner) {}

    Url(Url&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Url& operator=(Url&& other) noexcept {
        if (this != &other) {
            AzUrl_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Url() { AzUrl_delete(&inner_); }

    [[nodiscard]] static Url from_parts(String scheme, String host, uint16_t port, String path);
    [[nodiscard]] static ResultUrlUrlParseError parse(String s);

    String to_string() const;
    bool is_https() const;
    bool is_http() const;
    uint16_t effective_port() const;
    ResultUrlUrlParseError join(String path) const;
    void delete_();
    Url clone() const;
    bool partialEq(const Url& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzUrl& inner() const { return inner_; }
    AzUrl& inner() { return inner_; }
    const AzUrl* ptr() const { return &inner_; }
    AzUrl* ptr() { return &inner_; }
    AzUrl release() { AzUrl result = inner_; inner_ = {}; return result; }
    operator AzUrl() && noexcept { AzUrl result = inner_; inner_ = {}; return result; }
};

class JsonInternal {
private:
    AzJsonInternal inner_;

    JsonInternal(const JsonInternal&) = delete;
    JsonInternal& operator=(const JsonInternal&) = delete;

public:
    explicit JsonInternal(AzJsonInternal inner) noexcept : inner_(inner) {}

    JsonInternal(JsonInternal&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    JsonInternal& operator=(JsonInternal&& other) noexcept {
        if (this != &other) {
            AzJsonInternal_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~JsonInternal() { AzJsonInternal_delete(&inner_); }

    [[nodiscard]] static JsonInternal default_();

    void delete_();
    JsonInternal clone() const;
    bool partialEq(const JsonInternal& b) const;
    String toDbgString() const;

    const AzJsonInternal& inner() const { return inner_; }
    AzJsonInternal& inner() { return inner_; }
    const AzJsonInternal* ptr() const { return &inner_; }
    AzJsonInternal* ptr() { return &inner_; }
    AzJsonInternal release() { AzJsonInternal result = inner_; inner_ = {}; return result; }
    operator AzJsonInternal() && noexcept { AzJsonInternal result = inner_; inner_ = {}; return result; }
};

class DirEntry {
private:
    AzDirEntry inner_;

    DirEntry(const DirEntry&) = delete;
    DirEntry& operator=(const DirEntry&) = delete;

public:
    explicit DirEntry(AzDirEntry inner) noexcept : inner_(inner) {}

    DirEntry(DirEntry&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DirEntry& operator=(DirEntry&& other) noexcept {
        if (this != &other) {
            AzDirEntry_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DirEntry() { AzDirEntry_delete(&inner_); }

    void delete_();
    DirEntry clone() const;
    String toDbgString() const;

    const AzDirEntry& inner() const { return inner_; }
    AzDirEntry& inner() { return inner_; }
    const AzDirEntry* ptr() const { return &inner_; }
    AzDirEntry* ptr() { return &inner_; }
    AzDirEntry release() { AzDirEntry result = inner_; inner_ = {}; return result; }
    operator AzDirEntry() && noexcept { AzDirEntry result = inner_; inner_ = {}; return result; }
};

class BiometricPrompt {
private:
    AzBiometricPrompt inner_;

    BiometricPrompt(const BiometricPrompt&) = delete;
    BiometricPrompt& operator=(const BiometricPrompt&) = delete;

public:
    explicit BiometricPrompt(AzBiometricPrompt inner) noexcept : inner_(inner) {}

    BiometricPrompt(BiometricPrompt&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    BiometricPrompt& operator=(BiometricPrompt&& other) noexcept {
        if (this != &other) {
            AzBiometricPrompt_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~BiometricPrompt() { AzBiometricPrompt_delete(&inner_); }

    [[nodiscard]] static BiometricPrompt default_();

    void delete_();
    BiometricPrompt clone() const;
    bool partialEq(const BiometricPrompt& b) const;
    String toDbgString() const;

    const AzBiometricPrompt& inner() const { return inner_; }
    AzBiometricPrompt& inner() { return inner_; }
    const AzBiometricPrompt* ptr() const { return &inner_; }
    AzBiometricPrompt* ptr() { return &inner_; }
    AzBiometricPrompt release() { AzBiometricPrompt result = inner_; inner_ = {}; return result; }
    operator AzBiometricPrompt() && noexcept { AzBiometricPrompt result = inner_; inner_ = {}; return result; }
};

class VideoConfig {
private:
    AzVideoConfig inner_;

    VideoConfig(const VideoConfig&) = delete;
    VideoConfig& operator=(const VideoConfig&) = delete;

public:
    explicit VideoConfig(AzVideoConfig inner) noexcept : inner_(inner) {}

    VideoConfig(VideoConfig&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VideoConfig& operator=(VideoConfig&& other) noexcept {
        if (this != &other) {
            AzVideoConfig_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VideoConfig() { AzVideoConfig_delete(&inner_); }

    [[nodiscard]] static VideoConfig default_();

    void delete_();
    VideoConfig clone() const;
    bool partialEq(const VideoConfig& b) const;
    String toDbgString() const;

    const AzVideoConfig& inner() const { return inner_; }
    AzVideoConfig& inner() { return inner_; }
    const AzVideoConfig* ptr() const { return &inner_; }
    AzVideoConfig* ptr() { return &inner_; }
    AzVideoConfig release() { AzVideoConfig result = inner_; inner_ = {}; return result; }
    operator AzVideoConfig() && noexcept { AzVideoConfig result = inner_; inner_ = {}; return result; }
};

class ComponentId {
private:
    AzComponentId inner_;

    ComponentId(const ComponentId&) = delete;
    ComponentId& operator=(const ComponentId&) = delete;

public:
    explicit ComponentId(AzComponentId inner) noexcept : inner_(inner) {}

    ComponentId(ComponentId&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentId& operator=(ComponentId&& other) noexcept {
        if (this != &other) {
            AzComponentId_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentId() { AzComponentId_delete(&inner_); }

    [[nodiscard]] static ComponentId builtin(String name);
    [[nodiscard]] static ComponentId new_(String collection, String name);

    String qualified_name() const;
    void delete_();
    ComponentId clone() const;
    bool partialEq(const ComponentId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ComponentId& b) const;
    uint8_t cmp(const ComponentId& b) const;
    String toDbgString() const;

    const AzComponentId& inner() const { return inner_; }
    AzComponentId& inner() { return inner_; }
    const AzComponentId* ptr() const { return &inner_; }
    AzComponentId* ptr() { return &inner_; }
    AzComponentId release() { AzComponentId result = inner_; inner_ = {}; return result; }
    operator AzComponentId() && noexcept { AzComponentId result = inner_; inner_ = {}; return result; }
};

class ComponentLibrary {
private:
    AzComponentLibrary inner_;

    ComponentLibrary(const ComponentLibrary&) = delete;
    ComponentLibrary& operator=(const ComponentLibrary&) = delete;

public:
    explicit ComponentLibrary(AzComponentLibrary inner) noexcept : inner_(inner) {}

    ComponentLibrary(ComponentLibrary&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentLibrary& operator=(ComponentLibrary&& other) noexcept {
        if (this != &other) {
            AzComponentLibrary_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentLibrary() { AzComponentLibrary_delete(&inner_); }

    void delete_();
    ComponentLibrary clone() const;
    String toDbgString() const;

    const AzComponentLibrary& inner() const { return inner_; }
    AzComponentLibrary& inner() { return inner_; }
    const AzComponentLibrary* ptr() const { return &inner_; }
    AzComponentLibrary* ptr() { return &inner_; }
    AzComponentLibrary release() { AzComponentLibrary result = inner_; inner_ = {}; return result; }
    operator AzComponentLibrary() && noexcept { AzComponentLibrary result = inner_; inner_ = {}; return result; }
};

class ComponentDataModel {
private:
    AzComponentDataModel inner_;

    ComponentDataModel(const ComponentDataModel&) = delete;
    ComponentDataModel& operator=(const ComponentDataModel&) = delete;

public:
    explicit ComponentDataModel(AzComponentDataModel inner) noexcept : inner_(inner) {}

    ComponentDataModel(ComponentDataModel&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentDataModel& operator=(ComponentDataModel&& other) noexcept {
        if (this != &other) {
            AzComponentDataModel_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentDataModel() { AzComponentDataModel_delete(&inner_); }

    void delete_();
    ComponentDataModel clone() const;
    String toDbgString() const;

    const AzComponentDataModel& inner() const { return inner_; }
    AzComponentDataModel& inner() { return inner_; }
    const AzComponentDataModel* ptr() const { return &inner_; }
    AzComponentDataModel* ptr() { return &inner_; }
    AzComponentDataModel release() { AzComponentDataModel result = inner_; inner_ = {}; return result; }
    operator AzComponentDataModel() && noexcept { AzComponentDataModel result = inner_; inner_ = {}; return result; }
};

class ComponentEnumVariant {
private:
    AzComponentEnumVariant inner_;

    ComponentEnumVariant(const ComponentEnumVariant&) = delete;
    ComponentEnumVariant& operator=(const ComponentEnumVariant&) = delete;

public:
    explicit ComponentEnumVariant(AzComponentEnumVariant inner) noexcept : inner_(inner) {}

    ComponentEnumVariant(ComponentEnumVariant&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentEnumVariant& operator=(ComponentEnumVariant&& other) noexcept {
        if (this != &other) {
            AzComponentEnumVariant_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentEnumVariant() { AzComponentEnumVariant_delete(&inner_); }

    void delete_();
    ComponentEnumVariant clone() const;
    bool partialEq(const ComponentEnumVariant& b) const;
    String toDbgString() const;

    const AzComponentEnumVariant& inner() const { return inner_; }
    AzComponentEnumVariant& inner() { return inner_; }
    const AzComponentEnumVariant* ptr() const { return &inner_; }
    AzComponentEnumVariant* ptr() { return &inner_; }
    AzComponentEnumVariant release() { AzComponentEnumVariant result = inner_; inner_ = {}; return result; }
    operator AzComponentEnumVariant() && noexcept { AzComponentEnumVariant result = inner_; inner_ = {}; return result; }
};

class ComponentEnumModel {
private:
    AzComponentEnumModel inner_;

    ComponentEnumModel(const ComponentEnumModel&) = delete;
    ComponentEnumModel& operator=(const ComponentEnumModel&) = delete;

public:
    explicit ComponentEnumModel(AzComponentEnumModel inner) noexcept : inner_(inner) {}

    ComponentEnumModel(ComponentEnumModel&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentEnumModel& operator=(ComponentEnumModel&& other) noexcept {
        if (this != &other) {
            AzComponentEnumModel_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentEnumModel() { AzComponentEnumModel_delete(&inner_); }

    void delete_();
    ComponentEnumModel clone() const;
    bool partialEq(const ComponentEnumModel& b) const;
    String toDbgString() const;

    const AzComponentEnumModel& inner() const { return inner_; }
    AzComponentEnumModel& inner() { return inner_; }
    const AzComponentEnumModel* ptr() const { return &inner_; }
    AzComponentEnumModel* ptr() { return &inner_; }
    AzComponentEnumModel release() { AzComponentEnumModel result = inner_; inner_ = {}; return result; }
    operator AzComponentEnumModel() && noexcept { AzComponentEnumModel result = inner_; inner_ = {}; return result; }
};

class ComponentInstanceDefault {
private:
    AzComponentInstanceDefault inner_;

    ComponentInstanceDefault(const ComponentInstanceDefault&) = delete;
    ComponentInstanceDefault& operator=(const ComponentInstanceDefault&) = delete;

public:
    explicit ComponentInstanceDefault(AzComponentInstanceDefault inner) noexcept : inner_(inner) {}

    ComponentInstanceDefault(ComponentInstanceDefault&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentInstanceDefault& operator=(ComponentInstanceDefault&& other) noexcept {
        if (this != &other) {
            AzComponentInstanceDefault_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentInstanceDefault() { AzComponentInstanceDefault_delete(&inner_); }

    void delete_();
    ComponentInstanceDefault clone() const;
    bool partialEq(const ComponentInstanceDefault& b) const;
    String toDbgString() const;

    const AzComponentInstanceDefault& inner() const { return inner_; }
    AzComponentInstanceDefault& inner() { return inner_; }
    const AzComponentInstanceDefault* ptr() const { return &inner_; }
    AzComponentInstanceDefault* ptr() { return &inner_; }
    AzComponentInstanceDefault release() { AzComponentInstanceDefault result = inner_; inner_ = {}; return result; }
    operator AzComponentInstanceDefault() && noexcept { AzComponentInstanceDefault result = inner_; inner_ = {}; return result; }
};

class ComponentCallbackSignature {
private:
    AzComponentCallbackSignature inner_;

    ComponentCallbackSignature(const ComponentCallbackSignature&) = delete;
    ComponentCallbackSignature& operator=(const ComponentCallbackSignature&) = delete;

public:
    explicit ComponentCallbackSignature(AzComponentCallbackSignature inner) noexcept : inner_(inner) {}

    ComponentCallbackSignature(ComponentCallbackSignature&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentCallbackSignature& operator=(ComponentCallbackSignature&& other) noexcept {
        if (this != &other) {
            AzComponentCallbackSignature_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentCallbackSignature() { AzComponentCallbackSignature_delete(&inner_); }

    void delete_();
    ComponentCallbackSignature clone() const;
    bool partialEq(const ComponentCallbackSignature& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ComponentCallbackSignature& b) const;
    uint8_t cmp(const ComponentCallbackSignature& b) const;
    String toDbgString() const;

    const AzComponentCallbackSignature& inner() const { return inner_; }
    AzComponentCallbackSignature& inner() { return inner_; }
    const AzComponentCallbackSignature* ptr() const { return &inner_; }
    AzComponentCallbackSignature* ptr() { return &inner_; }
    AzComponentCallbackSignature release() { AzComponentCallbackSignature result = inner_; inner_ = {}; return result; }
    operator AzComponentCallbackSignature() && noexcept { AzComponentCallbackSignature result = inner_; inner_ = {}; return result; }
};

class Monitor {
private:
    AzMonitor inner_;

    Monitor(const Monitor&) = delete;
    Monitor& operator=(const Monitor&) = delete;

public:
    explicit Monitor(AzMonitor inner) noexcept : inner_(inner) {}

    Monitor(Monitor&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Monitor& operator=(Monitor&& other) noexcept {
        if (this != &other) {
            AzMonitor_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Monitor() { AzMonitor_delete(&inner_); }

    [[nodiscard]] static Monitor default_();

    void delete_();
    Monitor clone() const;
    bool partialEq(const Monitor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const Monitor& b) const;
    String toDbgString() const;

    const AzMonitor& inner() const { return inner_; }
    AzMonitor& inner() { return inner_; }
    const AzMonitor* ptr() const { return &inner_; }
    AzMonitor* ptr() { return &inner_; }
    AzMonitor release() { AzMonitor result = inner_; inner_ = {}; return result; }
    operator AzMonitor() && noexcept { AzMonitor result = inner_; inner_ = {}; return result; }
};

class DialogAriaInfo {
private:
    AzDialogAriaInfo inner_;

    DialogAriaInfo(const DialogAriaInfo&) = delete;
    DialogAriaInfo& operator=(const DialogAriaInfo&) = delete;

public:
    explicit DialogAriaInfo(AzDialogAriaInfo inner) noexcept : inner_(inner) {}

    DialogAriaInfo(DialogAriaInfo&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DialogAriaInfo& operator=(DialogAriaInfo&& other) noexcept {
        if (this != &other) {
            AzDialogAriaInfo_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DialogAriaInfo() { AzDialogAriaInfo_delete(&inner_); }

    [[nodiscard]] static DialogAriaInfo create(String label);

    DialogAriaInfo with_modal(bool modal) const;
    DialogAriaInfo with_described_by(String described_by) const;
    DialogAriaInfo with_role(AzAccessibilityRole role) const;
    DialogAriaInfo with_description(String desc) const;
    void delete_();
    DialogAriaInfo clone() const;
    bool partialEq(const DialogAriaInfo& b) const;
    String toDbgString() const;

    const AzDialogAriaInfo& inner() const { return inner_; }
    AzDialogAriaInfo& inner() { return inner_; }
    const AzDialogAriaInfo* ptr() const { return &inner_; }
    AzDialogAriaInfo* ptr() { return &inner_; }
    AzDialogAriaInfo release() { AzDialogAriaInfo result = inner_; inner_ = {}; return result; }
    operator AzDialogAriaInfo() && noexcept { AzDialogAriaInfo result = inner_; inner_ = {}; return result; }
};

class AccessibilityInfo {
private:
    AzAccessibilityInfo inner_;

    AccessibilityInfo(const AccessibilityInfo&) = delete;
    AccessibilityInfo& operator=(const AccessibilityInfo&) = delete;

public:
    explicit AccessibilityInfo(AzAccessibilityInfo inner) noexcept : inner_(inner) {}

    AccessibilityInfo(AccessibilityInfo&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    AccessibilityInfo& operator=(AccessibilityInfo&& other) noexcept {
        if (this != &other) {
            AzAccessibilityInfo_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~AccessibilityInfo() { AzAccessibilityInfo_delete(&inner_); }

    void delete_();
    AccessibilityInfo clone() const;
    bool partialEq(const AccessibilityInfo& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const AccessibilityInfo& b) const;
    uint8_t cmp(const AccessibilityInfo& b) const;
    String toDbgString() const;

    const AzAccessibilityInfo& inner() const { return inner_; }
    AzAccessibilityInfo& inner() { return inner_; }
    const AzAccessibilityInfo* ptr() const { return &inner_; }
    AzAccessibilityInfo* ptr() { return &inner_; }
    AzAccessibilityInfo release() { AzAccessibilityInfo result = inner_; inner_ = {}; return result; }
    operator AzAccessibilityInfo() && noexcept { AzAccessibilityInfo result = inner_; inner_ = {}; return result; }
};

class DragState {
private:
    AzDragState inner_;

    DragState(const DragState&) = delete;
    DragState& operator=(const DragState&) = delete;

public:
    explicit DragState(AzDragState inner) noexcept : inner_(inner) {}

    DragState(DragState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DragState& operator=(DragState&& other) noexcept {
        if (this != &other) {
            AzDragState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DragState() { AzDragState_delete(&inner_); }

    void delete_();
    DragState clone() const;
    bool partialEq(const DragState& b) const;
    String toDbgString() const;

    const AzDragState& inner() const { return inner_; }
    AzDragState& inner() { return inner_; }
    const AzDragState* ptr() const { return &inner_; }
    AzDragState* ptr() { return &inner_; }
    AzDragState release() { AzDragState result = inner_; inner_ = {}; return result; }
    operator AzDragState() && noexcept { AzDragState result = inner_; inner_ = {}; return result; }
};

class SmallAriaInfo {
private:
    AzSmallAriaInfo inner_;

    SmallAriaInfo(const SmallAriaInfo&) = delete;
    SmallAriaInfo& operator=(const SmallAriaInfo&) = delete;

public:
    explicit SmallAriaInfo(AzSmallAriaInfo inner) noexcept : inner_(inner) {}

    SmallAriaInfo(SmallAriaInfo&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SmallAriaInfo& operator=(SmallAriaInfo&& other) noexcept {
        if (this != &other) {
            AzSmallAriaInfo_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SmallAriaInfo() { AzSmallAriaInfo_delete(&inner_); }

    [[nodiscard]] static SmallAriaInfo label(String text);

    SmallAriaInfo with_role(AzAccessibilityRole role) const;
    SmallAriaInfo with_description(String desc) const;
    void delete_();
    SmallAriaInfo clone() const;
    bool partialEq(const SmallAriaInfo& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzSmallAriaInfo& inner() const { return inner_; }
    AzSmallAriaInfo& inner() { return inner_; }
    const AzSmallAriaInfo* ptr() const { return &inner_; }
    AzSmallAriaInfo* ptr() { return &inner_; }
    AzSmallAriaInfo release() { AzSmallAriaInfo result = inner_; inner_ = {}; return result; }
    operator AzSmallAriaInfo() && noexcept { AzSmallAriaInfo result = inner_; inner_ = {}; return result; }
};

class ProgressAriaInfo {
private:
    AzProgressAriaInfo inner_;

    ProgressAriaInfo(const ProgressAriaInfo&) = delete;
    ProgressAriaInfo& operator=(const ProgressAriaInfo&) = delete;

public:
    explicit ProgressAriaInfo(AzProgressAriaInfo inner) noexcept : inner_(inner) {}

    ProgressAriaInfo(ProgressAriaInfo&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ProgressAriaInfo& operator=(ProgressAriaInfo&& other) noexcept {
        if (this != &other) {
            AzProgressAriaInfo_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ProgressAriaInfo() { AzProgressAriaInfo_delete(&inner_); }

    [[nodiscard]] static ProgressAriaInfo create(String label);

    ProgressAriaInfo with_current_value(float value) const;
    ProgressAriaInfo with_max(float max) const;
    ProgressAriaInfo with_indeterminate(bool indeterminate) const;
    ProgressAriaInfo with_description(String desc) const;
    void delete_();
    ProgressAriaInfo clone() const;
    bool partialEq(const ProgressAriaInfo& b) const;
    String toDbgString() const;

    const AzProgressAriaInfo& inner() const { return inner_; }
    AzProgressAriaInfo& inner() { return inner_; }
    const AzProgressAriaInfo* ptr() const { return &inner_; }
    AzProgressAriaInfo* ptr() { return &inner_; }
    AzProgressAriaInfo release() { AzProgressAriaInfo result = inner_; inner_ = {}; return result; }
    operator AzProgressAriaInfo() && noexcept { AzProgressAriaInfo result = inner_; inner_ = {}; return result; }
};

class MeterAriaInfo {
private:
    AzMeterAriaInfo inner_;

    MeterAriaInfo(const MeterAriaInfo&) = delete;
    MeterAriaInfo& operator=(const MeterAriaInfo&) = delete;

public:
    explicit MeterAriaInfo(AzMeterAriaInfo inner) noexcept : inner_(inner) {}

    MeterAriaInfo(MeterAriaInfo&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MeterAriaInfo& operator=(MeterAriaInfo&& other) noexcept {
        if (this != &other) {
            AzMeterAriaInfo_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MeterAriaInfo() { AzMeterAriaInfo_delete(&inner_); }

    [[nodiscard]] static MeterAriaInfo create(String label, float current_value, float min, float max);

    MeterAriaInfo with_low(float low) const;
    MeterAriaInfo with_high(float high) const;
    MeterAriaInfo with_optimum(float optimum) const;
    MeterAriaInfo with_description(String desc) const;
    void delete_();
    MeterAriaInfo clone() const;
    bool partialEq(const MeterAriaInfo& b) const;
    String toDbgString() const;

    const AzMeterAriaInfo& inner() const { return inner_; }
    AzMeterAriaInfo& inner() { return inner_; }
    const AzMeterAriaInfo* ptr() const { return &inner_; }
    AzMeterAriaInfo* ptr() { return &inner_; }
    AzMeterAriaInfo release() { AzMeterAriaInfo result = inner_; inner_ = {}; return result; }
    operator AzMeterAriaInfo() && noexcept { AzMeterAriaInfo result = inner_; inner_ = {}; return result; }
};

class CssAttributeSelector {
private:
    AzCssAttributeSelector inner_;

    CssAttributeSelector(const CssAttributeSelector&) = delete;
    CssAttributeSelector& operator=(const CssAttributeSelector&) = delete;

public:
    explicit CssAttributeSelector(AzCssAttributeSelector inner) noexcept : inner_(inner) {}

    CssAttributeSelector(CssAttributeSelector&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssAttributeSelector& operator=(CssAttributeSelector&& other) noexcept {
        if (this != &other) {
            AzCssAttributeSelector_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssAttributeSelector() { AzCssAttributeSelector_delete(&inner_); }

    [[nodiscard]] static CssAttributeSelector default_();

    void delete_();
    CssAttributeSelector clone() const;
    bool partialEq(const CssAttributeSelector& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CssAttributeSelector& b) const;
    uint8_t cmp(const CssAttributeSelector& b) const;
    String toDbgString() const;

    const AzCssAttributeSelector& inner() const { return inner_; }
    AzCssAttributeSelector& inner() { return inner_; }
    const AzCssAttributeSelector* ptr() const { return &inner_; }
    AzCssAttributeSelector* ptr() { return &inner_; }
    AzCssAttributeSelector release() { AzCssAttributeSelector result = inner_; inner_ = {}; return result; }
    operator AzCssAttributeSelector() && noexcept { AzCssAttributeSelector result = inner_; inner_ = {}; return result; }
};

class StyledTextRun {
private:
    AzStyledTextRun inner_;

    StyledTextRun(const StyledTextRun&) = delete;
    StyledTextRun& operator=(const StyledTextRun&) = delete;

public:
    explicit StyledTextRun(AzStyledTextRun inner) noexcept : inner_(inner) {}

    StyledTextRun(StyledTextRun&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StyledTextRun& operator=(StyledTextRun&& other) noexcept {
        if (this != &other) {
            AzStyledTextRun_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StyledTextRun() { AzStyledTextRun_delete(&inner_); }

    void delete_();
    StyledTextRun clone() const;
    bool partialEq(const StyledTextRun& b) const;
    String toDbgString() const;

    const AzStyledTextRun& inner() const { return inner_; }
    AzStyledTextRun& inner() { return inner_; }
    const AzStyledTextRun* ptr() const { return &inner_; }
    AzStyledTextRun* ptr() { return &inner_; }
    AzStyledTextRun release() { AzStyledTextRun result = inner_; inner_ = {}; return result; }
    operator AzStyledTextRun() && noexcept { AzStyledTextRun result = inner_; inner_ = {}; return result; }
};

class TextOpCopy {
private:
    AzTextOpCopy inner_;

    TextOpCopy(const TextOpCopy&) = delete;
    TextOpCopy& operator=(const TextOpCopy&) = delete;

public:
    explicit TextOpCopy(AzTextOpCopy inner) noexcept : inner_(inner) {}

    TextOpCopy(TextOpCopy&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextOpCopy& operator=(TextOpCopy&& other) noexcept {
        if (this != &other) {
            AzTextOpCopy_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextOpCopy() { AzTextOpCopy_delete(&inner_); }

    void delete_();
    TextOpCopy clone() const;
    String toDbgString() const;

    const AzTextOpCopy& inner() const { return inner_; }
    AzTextOpCopy& inner() { return inner_; }
    const AzTextOpCopy* ptr() const { return &inner_; }
    AzTextOpCopy* ptr() { return &inner_; }
    AzTextOpCopy release() { AzTextOpCopy result = inner_; inner_ = {}; return result; }
    operator AzTextOpCopy() && noexcept { AzTextOpCopy result = inner_; inner_ = {}; return result; }
};

class TextOpPaste {
private:
    AzTextOpPaste inner_;

    TextOpPaste(const TextOpPaste&) = delete;
    TextOpPaste& operator=(const TextOpPaste&) = delete;

public:
    explicit TextOpPaste(AzTextOpPaste inner) noexcept : inner_(inner) {}

    TextOpPaste(TextOpPaste&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextOpPaste& operator=(TextOpPaste&& other) noexcept {
        if (this != &other) {
            AzTextOpPaste_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextOpPaste() { AzTextOpPaste_delete(&inner_); }

    void delete_();
    TextOpPaste clone() const;
    String toDbgString() const;

    const AzTextOpPaste& inner() const { return inner_; }
    AzTextOpPaste& inner() { return inner_; }
    const AzTextOpPaste* ptr() const { return &inner_; }
    AzTextOpPaste* ptr() { return &inner_; }
    AzTextOpPaste release() { AzTextOpPaste result = inner_; inner_ = {}; return result; }
    operator AzTextOpPaste() && noexcept { AzTextOpPaste result = inner_; inner_ = {}; return result; }
};

class TextOpCut {
private:
    AzTextOpCut inner_;

    TextOpCut(const TextOpCut&) = delete;
    TextOpCut& operator=(const TextOpCut&) = delete;

public:
    explicit TextOpCut(AzTextOpCut inner) noexcept : inner_(inner) {}

    TextOpCut(TextOpCut&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextOpCut& operator=(TextOpCut&& other) noexcept {
        if (this != &other) {
            AzTextOpCut_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextOpCut() { AzTextOpCut_delete(&inner_); }

    void delete_();
    TextOpCut clone() const;
    String toDbgString() const;

    const AzTextOpCut& inner() const { return inner_; }
    AzTextOpCut& inner() { return inner_; }
    const AzTextOpCut* ptr() const { return &inner_; }
    AzTextOpCut* ptr() { return &inner_; }
    AzTextOpCut release() { AzTextOpCut result = inner_; inner_ = {}; return result; }
    operator AzTextOpCut() && noexcept { AzTextOpCut result = inner_; inner_ = {}; return result; }
};

class SystemFonts {
private:
    AzSystemFonts inner_;

    SystemFonts(const SystemFonts&) = delete;
    SystemFonts& operator=(const SystemFonts&) = delete;

public:
    explicit SystemFonts(AzSystemFonts inner) noexcept : inner_(inner) {}

    SystemFonts(SystemFonts&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SystemFonts& operator=(SystemFonts&& other) noexcept {
        if (this != &other) {
            AzSystemFonts_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SystemFonts() { AzSystemFonts_delete(&inner_); }

    [[nodiscard]] static SystemFonts default_();

    void delete_();
    SystemFonts clone() const;
    bool partialEq(const SystemFonts& b) const;
    String toDbgString() const;

    const AzSystemFonts& inner() const { return inner_; }
    AzSystemFonts& inner() { return inner_; }
    const AzSystemFonts* ptr() const { return &inner_; }
    AzSystemFonts* ptr() { return &inner_; }
    AzSystemFonts release() { AzSystemFonts result = inner_; inner_ = {}; return result; }
    operator AzSystemFonts() && noexcept { AzSystemFonts result = inner_; inner_ = {}; return result; }
};

class PercentageParseErrorWithInput {
private:
    AzPercentageParseErrorWithInput inner_;

    PercentageParseErrorWithInput(const PercentageParseErrorWithInput&) = delete;
    PercentageParseErrorWithInput& operator=(const PercentageParseErrorWithInput&) = delete;

public:
    explicit PercentageParseErrorWithInput(AzPercentageParseErrorWithInput inner) noexcept : inner_(inner) {}

    PercentageParseErrorWithInput(PercentageParseErrorWithInput&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    PercentageParseErrorWithInput& operator=(PercentageParseErrorWithInput&& other) noexcept {
        if (this != &other) {
            AzPercentageParseErrorWithInput_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~PercentageParseErrorWithInput() { AzPercentageParseErrorWithInput_delete(&inner_); }

    void delete_();
    PercentageParseErrorWithInput clone() const;
    bool partialEq(const PercentageParseErrorWithInput& b) const;
    String toDbgString() const;

    const AzPercentageParseErrorWithInput& inner() const { return inner_; }
    AzPercentageParseErrorWithInput& inner() { return inner_; }
    const AzPercentageParseErrorWithInput* ptr() const { return &inner_; }
    AzPercentageParseErrorWithInput* ptr() { return &inner_; }
    AzPercentageParseErrorWithInput release() { AzPercentageParseErrorWithInput result = inner_; inner_ = {}; return result; }
    operator AzPercentageParseErrorWithInput() && noexcept { AzPercentageParseErrorWithInput result = inner_; inner_ = {}; return result; }
};

class TitlebarMetrics {
private:
    AzTitlebarMetrics inner_;

    TitlebarMetrics(const TitlebarMetrics&) = delete;
    TitlebarMetrics& operator=(const TitlebarMetrics&) = delete;

public:
    explicit TitlebarMetrics(AzTitlebarMetrics inner) noexcept : inner_(inner) {}

    TitlebarMetrics(TitlebarMetrics&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TitlebarMetrics& operator=(TitlebarMetrics&& other) noexcept {
        if (this != &other) {
            AzTitlebarMetrics_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TitlebarMetrics() { AzTitlebarMetrics_delete(&inner_); }

    [[nodiscard]] static TitlebarMetrics windows();
    [[nodiscard]] static TitlebarMetrics macos();
    [[nodiscard]] static TitlebarMetrics linux_gnome();
    [[nodiscard]] static TitlebarMetrics ios();
    [[nodiscard]] static TitlebarMetrics android();
    [[nodiscard]] static TitlebarMetrics default_();

    void delete_();
    TitlebarMetrics clone() const;
    bool partialEq(const TitlebarMetrics& b) const;
    String toDbgString() const;

    const AzTitlebarMetrics& inner() const { return inner_; }
    AzTitlebarMetrics& inner() { return inner_; }
    const AzTitlebarMetrics* ptr() const { return &inner_; }
    AzTitlebarMetrics* ptr() { return &inner_; }
    AzTitlebarMetrics release() { AzTitlebarMetrics result = inner_; inner_ = {}; return result; }
    operator AzTitlebarMetrics() && noexcept { AzTitlebarMetrics result = inner_; inner_ = {}; return result; }
};

class LinuxCustomization {
private:
    AzLinuxCustomization inner_;

    LinuxCustomization(const LinuxCustomization&) = delete;
    LinuxCustomization& operator=(const LinuxCustomization&) = delete;

public:
    explicit LinuxCustomization(AzLinuxCustomization inner) noexcept : inner_(inner) {}

    LinuxCustomization(LinuxCustomization&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    LinuxCustomization& operator=(LinuxCustomization&& other) noexcept {
        if (this != &other) {
            AzLinuxCustomization_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~LinuxCustomization() { AzLinuxCustomization_delete(&inner_); }

    [[nodiscard]] static LinuxCustomization default_();

    void delete_();
    LinuxCustomization clone() const;
    bool partialEq(const LinuxCustomization& b) const;
    String toDbgString() const;

    const AzLinuxCustomization& inner() const { return inner_; }
    AzLinuxCustomization& inner() { return inner_; }
    const AzLinuxCustomization* ptr() const { return &inner_; }
    AzLinuxCustomization* ptr() { return &inner_; }
    AzLinuxCustomization release() { AzLinuxCustomization result = inner_; inner_ = {}; return result; }
    operator AzLinuxCustomization() && noexcept { AzLinuxCustomization result = inner_; inner_ = {}; return result; }
};

class FileInputState {
private:
    AzFileInputState inner_;

    FileInputState(const FileInputState&) = delete;
    FileInputState& operator=(const FileInputState&) = delete;

public:
    explicit FileInputState(AzFileInputState inner) noexcept : inner_(inner) {}

    FileInputState(FileInputState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FileInputState& operator=(FileInputState&& other) noexcept {
        if (this != &other) {
            AzFileInputState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FileInputState() { AzFileInputState_delete(&inner_); }

    [[nodiscard]] static FileInputState default_();

    void delete_();
    FileInputState clone() const;
    bool partialEq(const FileInputState& b) const;
    String toDbgString() const;

    const AzFileInputState& inner() const { return inner_; }
    AzFileInputState& inner() { return inner_; }
    const AzFileInputState* ptr() const { return &inner_; }
    AzFileInputState* ptr() { return &inner_; }
    AzFileInputState release() { AzFileInputState result = inner_; inner_ = {}; return result; }
    operator AzFileInputState() && noexcept { AzFileInputState result = inner_; inner_ = {}; return result; }
};

class TextInputState {
private:
    AzTextInputState inner_;

    TextInputState(const TextInputState&) = delete;
    TextInputState& operator=(const TextInputState&) = delete;

public:
    explicit TextInputState(AzTextInputState inner) noexcept : inner_(inner) {}

    TextInputState(TextInputState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextInputState& operator=(TextInputState&& other) noexcept {
        if (this != &other) {
            AzTextInputState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextInputState() { AzTextInputState_delete(&inner_); }

    [[nodiscard]] static TextInputState default_();

    String get_text() const;
    void delete_();
    TextInputState clone() const;
    bool partialEq(const TextInputState& b) const;
    String toDbgString() const;

    const AzTextInputState& inner() const { return inner_; }
    AzTextInputState& inner() { return inner_; }
    const AzTextInputState* ptr() const { return &inner_; }
    AzTextInputState* ptr() { return &inner_; }
    AzTextInputState release() { AzTextInputState result = inner_; inner_ = {}; return result; }
    operator AzTextInputState() && noexcept { AzTextInputState result = inner_; inner_ = {}; return result; }
};

class VertexBuffer {
private:
    AzVertexBuffer inner_;

    VertexBuffer(const VertexBuffer&) = delete;
    VertexBuffer& operator=(const VertexBuffer&) = delete;

public:
    explicit VertexBuffer(AzVertexBuffer inner) noexcept : inner_(inner) {}

    VertexBuffer(VertexBuffer&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VertexBuffer& operator=(VertexBuffer&& other) noexcept {
        if (this != &other) {
            AzVertexBuffer_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VertexBuffer() { AzVertexBuffer_delete(&inner_); }

    void delete_();
    VertexBuffer clone() const;

    const AzVertexBuffer& inner() const { return inner_; }
    AzVertexBuffer& inner() { return inner_; }
    const AzVertexBuffer* ptr() const { return &inner_; }
    AzVertexBuffer* ptr() { return &inner_; }
    AzVertexBuffer release() { AzVertexBuffer result = inner_; inner_ = {}; return result; }
    operator AzVertexBuffer() && noexcept { AzVertexBuffer result = inner_; inner_ = {}; return result; }
};

class SvgParseOptions {
private:
    AzSvgParseOptions inner_;

    SvgParseOptions(const SvgParseOptions&) = delete;
    SvgParseOptions& operator=(const SvgParseOptions&) = delete;

public:
    explicit SvgParseOptions(AzSvgParseOptions inner) noexcept : inner_(inner) {}

    SvgParseOptions(SvgParseOptions&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SvgParseOptions& operator=(SvgParseOptions&& other) noexcept {
        if (this != &other) {
            AzSvgParseOptions_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SvgParseOptions() { AzSvgParseOptions_delete(&inner_); }

    [[nodiscard]] static SvgParseOptions default_();

    void delete_();
    SvgParseOptions clone() const;
    bool partialEq(const SvgParseOptions& b) const;
    uint8_t partialCmp(const SvgParseOptions& b) const;
    String toDbgString() const;

    const AzSvgParseOptions& inner() const { return inner_; }
    AzSvgParseOptions& inner() { return inner_; }
    const AzSvgParseOptions* ptr() const { return &inner_; }
    AzSvgParseOptions* ptr() { return &inner_; }
    AzSvgParseOptions release() { AzSvgParseOptions result = inner_; inner_ = {}; return result; }
    operator AzSvgParseOptions() && noexcept { AzSvgParseOptions result = inner_; inner_ = {}; return result; }
};

class UnknownSelectorError {
private:
    AzUnknownSelectorError inner_;

    UnknownSelectorError(const UnknownSelectorError&) = delete;
    UnknownSelectorError& operator=(const UnknownSelectorError&) = delete;

public:
    explicit UnknownSelectorError(AzUnknownSelectorError inner) noexcept : inner_(inner) {}

    UnknownSelectorError(UnknownSelectorError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    UnknownSelectorError& operator=(UnknownSelectorError&& other) noexcept {
        if (this != &other) {
            AzUnknownSelectorError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~UnknownSelectorError() { AzUnknownSelectorError_delete(&inner_); }

    void delete_();
    UnknownSelectorError clone() const;
    bool partialEq(const UnknownSelectorError& b) const;
    String toDbgString() const;

    const AzUnknownSelectorError& inner() const { return inner_; }
    AzUnknownSelectorError& inner() { return inner_; }
    const AzUnknownSelectorError* ptr() const { return &inner_; }
    AzUnknownSelectorError* ptr() { return &inner_; }
    AzUnknownSelectorError release() { AzUnknownSelectorError result = inner_; inner_ = {}; return result; }
    operator AzUnknownSelectorError() && noexcept { AzUnknownSelectorError result = inner_; inner_ = {}; return result; }
};

class Timer {
private:
    AzTimer inner_;

    Timer(const Timer&) = delete;
    Timer& operator=(const Timer&) = delete;

public:
    explicit Timer(AzTimer inner) noexcept : inner_(inner) {}

    Timer(Timer&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Timer& operator=(Timer&& other) noexcept {
        if (this != &other) {
            AzTimer_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Timer() { AzTimer_delete(&inner_); }

    [[nodiscard]] static Timer create(RefAny refany, AzTimerCallbackType callback, GetSystemTimeCallback get_system_time_fn);
    [[nodiscard]] static Timer default_();

    uint64_t tick_millis() const;
    AzInstant instant_of_next_run() const;
    Timer with_delay(AzDuration delay) const;
    Timer with_interval(AzDuration interval) const;
    Timer with_timeout(AzDuration timeout) const;
    bool is_about_to_finish(AzInstant instant_now) const;
    TimerCallbackReturn invoke(CallbackInfo callback_info, GetSystemTimeCallback get_system_time_fn);
    void delete_();
    Timer clone() const;
    bool partialEq(const Timer& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzTimer& inner() const { return inner_; }
    AzTimer& inner() { return inner_; }
    const AzTimer* ptr() const { return &inner_; }
    AzTimer* ptr() { return &inner_; }
    AzTimer release() { AzTimer result = inner_; inner_ = {}; return result; }
    operator AzTimer() && noexcept { AzTimer result = inner_; inner_ = {}; return result; }
};

class FmtArg {
private:
    AzFmtArg inner_;

    FmtArg(const FmtArg&) = delete;
    FmtArg& operator=(const FmtArg&) = delete;

public:
    explicit FmtArg(AzFmtArg inner) noexcept : inner_(inner) {}

    FmtArg(FmtArg&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FmtArg& operator=(FmtArg&& other) noexcept {
        if (this != &other) {
            AzFmtArg_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FmtArg() { AzFmtArg_delete(&inner_); }

    void delete_();
    FmtArg clone() const;
    bool partialEq(const FmtArg& b) const;
    uint8_t partialCmp(const FmtArg& b) const;
    String toDbgString() const;

    const AzFmtArg& inner() const { return inner_; }
    AzFmtArg& inner() { return inner_; }
    const AzFmtArg* ptr() const { return &inner_; }
    AzFmtArg* ptr() { return &inner_; }
    AzFmtArg release() { AzFmtArg result = inner_; inner_ = {}; return result; }
    operator AzFmtArg() && noexcept { AzFmtArg result = inner_; inner_ = {}; return result; }
};

class Json {
private:
    AzJson inner_;

    Json(const Json&) = delete;
    Json& operator=(const Json&) = delete;

public:
    explicit Json(AzJson inner) noexcept : inner_(inner) {}

    Json(Json&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Json& operator=(Json&& other) noexcept {
        if (this != &other) {
            AzJson_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Json() { AzJson_delete(&inner_); }

    [[nodiscard]] static Json null();
    [[nodiscard]] static Json bool_(bool value);
    [[nodiscard]] static Json float_(double value);
    [[nodiscard]] static Json int_(int64_t value);
    [[nodiscard]] static Json string(String value);
    [[nodiscard]] static Json array(JsonVec values);
    [[nodiscard]] static Json object(JsonKeyValueVec entries);
    [[nodiscard]] static ResultJsonJsonParseError parse(String s);
    [[nodiscard]] static ResultJsonJsonParseError parse_bytes(U8VecRef bytes);

    bool is_null() const;
    bool is_bool() const;
    bool is_float() const;
    bool is_string() const;
    bool is_array() const;
    bool is_object() const;
    OptionBool as_bool() const;
    OptionF64 as_float() const;
    OptionI64 as_int() const;
    OptionString as_string() const;
    size_t len() const;
    bool is_empty() const;
    OptionJson get_index(size_t index) const;
    OptionJson get_key(String key) const;
    StringVec keys() const;
    OptionJsonVec to_array() const;
    OptionJsonKeyValueVec to_object() const;
    String to_string() const;
    String to_string_pretty() const;
    Json jq(String path) const;
    JsonVec jq_all(String path) const;
    ResultRefAnyString deserialize_to_refany(size_t deserialize_fn) const;
    void delete_();
    Json clone() const;
    bool partialEq(const Json& b) const;
    String toDbgString() const;

    const AzJson& inner() const { return inner_; }
    AzJson& inner() { return inner_; }
    const AzJson* ptr() const { return &inner_; }
    AzJson* ptr() { return &inner_; }
    AzJson release() { AzJson result = inner_; inner_ = {}; return result; }
    operator AzJson() && noexcept { AzJson result = inner_; inner_ = {}; return result; }
};

class ComponentDef {
private:
    AzComponentDef inner_;

    ComponentDef(const ComponentDef&) = delete;
    ComponentDef& operator=(const ComponentDef&) = delete;

public:
    explicit ComponentDef(AzComponentDef inner) noexcept : inner_(inner) {}

    ComponentDef(ComponentDef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentDef& operator=(ComponentDef&& other) noexcept {
        if (this != &other) {
            AzComponentDef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentDef() { AzComponentDef_delete(&inner_); }

    void delete_();
    ComponentDef clone() const;
    String toDbgString() const;

    const AzComponentDef& inner() const { return inner_; }
    AzComponentDef& inner() { return inner_; }
    const AzComponentDef* ptr() const { return &inner_; }
    AzComponentDef* ptr() { return &inner_; }
    AzComponentDef release() { AzComponentDef result = inner_; inner_ = {}; return result; }
    operator AzComponentDef() && noexcept { AzComponentDef result = inner_; inner_ = {}; return result; }
};

class ComponentFieldOverride {
private:
    AzComponentFieldOverride inner_;

    ComponentFieldOverride(const ComponentFieldOverride&) = delete;
    ComponentFieldOverride& operator=(const ComponentFieldOverride&) = delete;

public:
    explicit ComponentFieldOverride(AzComponentFieldOverride inner) noexcept : inner_(inner) {}

    ComponentFieldOverride(ComponentFieldOverride&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentFieldOverride& operator=(ComponentFieldOverride&& other) noexcept {
        if (this != &other) {
            AzComponentFieldOverride_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentFieldOverride() { AzComponentFieldOverride_delete(&inner_); }

    void delete_();
    ComponentFieldOverride clone() const;
    bool partialEq(const ComponentFieldOverride& b) const;
    String toDbgString() const;

    const AzComponentFieldOverride& inner() const { return inner_; }
    AzComponentFieldOverride& inner() { return inner_; }
    const AzComponentFieldOverride* ptr() const { return &inner_; }
    AzComponentFieldOverride* ptr() { return &inner_; }
    AzComponentFieldOverride release() { AzComponentFieldOverride result = inner_; inner_ = {}; return result; }
    operator AzComponentFieldOverride() && noexcept { AzComponentFieldOverride result = inner_; inner_ = {}; return result; }
};

class LinuxWindowOptions {
private:
    AzLinuxWindowOptions inner_;

    LinuxWindowOptions(const LinuxWindowOptions&) = delete;
    LinuxWindowOptions& operator=(const LinuxWindowOptions&) = delete;

public:
    explicit LinuxWindowOptions(AzLinuxWindowOptions inner) noexcept : inner_(inner) {}

    LinuxWindowOptions(LinuxWindowOptions&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    LinuxWindowOptions& operator=(LinuxWindowOptions&& other) noexcept {
        if (this != &other) {
            AzLinuxWindowOptions_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~LinuxWindowOptions() { AzLinuxWindowOptions_delete(&inner_); }

    [[nodiscard]] static LinuxWindowOptions default_();

    void delete_();
    LinuxWindowOptions clone() const;
    bool partialEq(const LinuxWindowOptions& b) const;
    uint8_t partialCmp(const LinuxWindowOptions& b) const;
    String toDbgString() const;

    const AzLinuxWindowOptions& inner() const { return inner_; }
    AzLinuxWindowOptions& inner() { return inner_; }
    const AzLinuxWindowOptions* ptr() const { return &inner_; }
    AzLinuxWindowOptions* ptr() { return &inner_; }
    AzLinuxWindowOptions release() { AzLinuxWindowOptions result = inner_; inner_ = {}; return result; }
    operator AzLinuxWindowOptions() && noexcept { AzLinuxWindowOptions result = inner_; inner_ = {}; return result; }
};

class WindowsWindowOptions {
private:
    AzWindowsWindowOptions inner_;

    WindowsWindowOptions(const WindowsWindowOptions&) = delete;
    WindowsWindowOptions& operator=(const WindowsWindowOptions&) = delete;

public:
    explicit WindowsWindowOptions(AzWindowsWindowOptions inner) noexcept : inner_(inner) {}

    WindowsWindowOptions(WindowsWindowOptions&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    WindowsWindowOptions& operator=(WindowsWindowOptions&& other) noexcept {
        if (this != &other) {
            AzWindowsWindowOptions_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~WindowsWindowOptions() { AzWindowsWindowOptions_delete(&inner_); }

    [[nodiscard]] static WindowsWindowOptions default_();

    void delete_();
    WindowsWindowOptions clone() const;
    bool partialEq(const WindowsWindowOptions& b) const;
    uint8_t partialCmp(const WindowsWindowOptions& b) const;
    String toDbgString() const;

    const AzWindowsWindowOptions& inner() const { return inner_; }
    AzWindowsWindowOptions& inner() { return inner_; }
    const AzWindowsWindowOptions* ptr() const { return &inner_; }
    AzWindowsWindowOptions* ptr() { return &inner_; }
    AzWindowsWindowOptions release() { AzWindowsWindowOptions result = inner_; inner_ = {}; return result; }
    operator AzWindowsWindowOptions() && noexcept { AzWindowsWindowOptions result = inner_; inner_ = {}; return result; }
};

class NodeData {
private:
    AzNodeData inner_;

    NodeData(const NodeData&) = delete;
    NodeData& operator=(const NodeData&) = delete;

public:
    explicit NodeData(AzNodeData inner) noexcept : inner_(inner) {}

    NodeData(NodeData&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NodeData& operator=(NodeData&& other) noexcept {
        if (this != &other) {
            AzNodeData_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NodeData() { AzNodeData_delete(&inner_); }

    [[nodiscard]] static NodeData create(AzNodeType node_type);
    [[nodiscard]] static NodeData create_body();
    [[nodiscard]] static NodeData create_div();
    [[nodiscard]] static NodeData create_br();
    [[nodiscard]] static NodeData create_text(String value);
    [[nodiscard]] static NodeData create_image(ImageRef image);
    [[nodiscard]] static NodeData create_virtual_view(RefAny data, AzVirtualViewCallbackType callback);
    [[nodiscard]] static NodeData create_node(AzNodeType node_type);
    [[nodiscard]] static NodeData create_button(SmallAriaInfo aria);
    [[nodiscard]] static NodeData create_button_no_a11y();
    [[nodiscard]] static NodeData create_a(String href, SmallAriaInfo aria);
    [[nodiscard]] static NodeData create_a_no_a11y(String href);
    [[nodiscard]] static NodeData create_input(String input_type, String name, String label, SmallAriaInfo aria);
    [[nodiscard]] static NodeData create_input_no_a11y(String input_type, String name, String label);
    [[nodiscard]] static NodeData create_textarea(String name, String label, SmallAriaInfo aria);
    [[nodiscard]] static NodeData create_textarea_no_a11y(String name, String label);
    [[nodiscard]] static NodeData create_select(String name, String label, SmallAriaInfo aria);
    [[nodiscard]] static NodeData create_select_no_a11y(String name, String label);
    [[nodiscard]] static NodeData create_table(SmallAriaInfo aria);
    [[nodiscard]] static NodeData create_table_no_a11y();
    [[nodiscard]] static NodeData create_label(String for_id, SmallAriaInfo aria);
    [[nodiscard]] static NodeData create_label_no_a11y(String for_id);
    [[nodiscard]] static NodeData default_();

    void set_dataset(OptionRefAny data);
    void set_ids_and_classes(IdOrClassVec ids_and_classes);
    void add_callback(AzEventFilter event, RefAny data, AzCallbackType callback);
    void set_callbacks(CoreCallbackDataVec callbacks);
    void set_clip_mask(ImageMask clip_mask);
    void set_tab_index(AzTabIndex tab_index);
    void set_contenteditable(bool contenteditable);
    bool is_contenteditable() const;
    NodeData with_contenteditable(bool contenteditable) const;
    void set_accessibility_info(AccessibilityInfo accessibility_info);
    void set_menu_bar(Menu menu_bar);
    void set_context_menu(Menu context_menu);
    bool has_context_menu() const;
    bool is_text_node() const;
    bool is_virtual_view_node() const;
    bool is_anonymous() const;
    void set_anonymous(bool is_anonymous);
    void add_id(String s);
    void add_class(String s);
    void add_css_property(CssPropertyWithConditions p);
    bool is_focusable() const;
    String debug_print_end() const;
    void set_merge_callback(AzDatasetMergeCallbackType callback);
    OptionDatasetMergeCallback get_merge_callback() const;
    NodeData with_merge_callback(AzDatasetMergeCallbackType callback) const;
    OptionTabIndex get_tab_index() const;
    bool has_id(String id) const;
    bool has_class(String class_) const;
    IdOrClassVec get_ids_and_classes() const;
    void delete_();
    NodeData clone() const;
    bool partialEq(const NodeData& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const NodeData& b) const;
    uint8_t cmp(const NodeData& b) const;
    String toDbgString() const;

    const AzNodeData& inner() const { return inner_; }
    AzNodeData& inner() { return inner_; }
    const AzNodeData* ptr() const { return &inner_; }
    AzNodeData* ptr() { return &inner_; }
    AzNodeData release() { AzNodeData result = inner_; inner_ = {}; return result; }
    operator AzNodeData() && noexcept { AzNodeData result = inner_; inner_ = {}; return result; }
};

class StringMenuItem {
private:
    AzStringMenuItem inner_;

    StringMenuItem(const StringMenuItem&) = delete;
    StringMenuItem& operator=(const StringMenuItem&) = delete;

public:
    explicit StringMenuItem(AzStringMenuItem inner) noexcept : inner_(inner) {}

    StringMenuItem(StringMenuItem&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    StringMenuItem& operator=(StringMenuItem&& other) noexcept {
        if (this != &other) {
            AzStringMenuItem_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~StringMenuItem() { AzStringMenuItem_delete(&inner_); }

    [[nodiscard]] static StringMenuItem create(String label);

    void delete_();
    StringMenuItem clone() const;
    bool partialEq(const StringMenuItem& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const StringMenuItem& b) const;
    uint8_t cmp(const StringMenuItem& b) const;
    String toDbgString() const;

    const AzStringMenuItem& inner() const { return inner_; }
    AzStringMenuItem& inner() { return inner_; }
    const AzStringMenuItem* ptr() const { return &inner_; }
    AzStringMenuItem* ptr() { return &inner_; }
    AzStringMenuItem release() { AzStringMenuItem result = inner_; inner_ = {}; return result; }
    operator AzStringMenuItem() && noexcept { AzStringMenuItem result = inner_; inner_ = {}; return result; }
};

class GridPlacement {
private:
    AzGridPlacement inner_;

    GridPlacement(const GridPlacement&) = delete;
    GridPlacement& operator=(const GridPlacement&) = delete;

public:
    explicit GridPlacement(AzGridPlacement inner) noexcept : inner_(inner) {}

    GridPlacement(GridPlacement&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    GridPlacement& operator=(GridPlacement&& other) noexcept {
        if (this != &other) {
            AzGridPlacement_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~GridPlacement() { AzGridPlacement_delete(&inner_); }

    [[nodiscard]] static GridPlacement default_();

    void delete_();
    GridPlacement clone() const;
    bool partialEq(const GridPlacement& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const GridPlacement& b) const;
    uint8_t cmp(const GridPlacement& b) const;
    String toDbgString() const;

    const AzGridPlacement& inner() const { return inner_; }
    AzGridPlacement& inner() { return inner_; }
    const AzGridPlacement* ptr() const { return &inner_; }
    AzGridPlacement* ptr() { return &inner_; }
    AzGridPlacement release() { AzGridPlacement result = inner_; inner_ = {}; return result; }
    operator AzGridPlacement() && noexcept { AzGridPlacement result = inner_; inner_ = {}; return result; }
};

class CssMockEnvironment {
private:
    AzCssMockEnvironment inner_;

    CssMockEnvironment(const CssMockEnvironment&) = delete;
    CssMockEnvironment& operator=(const CssMockEnvironment&) = delete;

public:
    explicit CssMockEnvironment(AzCssMockEnvironment inner) noexcept : inner_(inner) {}

    CssMockEnvironment(CssMockEnvironment&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssMockEnvironment& operator=(CssMockEnvironment&& other) noexcept {
        if (this != &other) {
            AzCssMockEnvironment_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssMockEnvironment() { AzCssMockEnvironment_delete(&inner_); }

    [[nodiscard]] static CssMockEnvironment default_();

    void delete_();
    CssMockEnvironment clone() const;
    String toDbgString() const;

    const AzCssMockEnvironment& inner() const { return inner_; }
    AzCssMockEnvironment& inner() { return inner_; }
    const AzCssMockEnvironment* ptr() const { return &inner_; }
    AzCssMockEnvironment* ptr() { return &inner_; }
    AzCssMockEnvironment release() { AzCssMockEnvironment result = inner_; inner_ = {}; return result; }
    operator AzCssMockEnvironment() && noexcept { AzCssMockEnvironment result = inner_; inner_ = {}; return result; }
};

class SystemMetrics {
private:
    AzSystemMetrics inner_;

    SystemMetrics(const SystemMetrics&) = delete;
    SystemMetrics& operator=(const SystemMetrics&) = delete;

public:
    explicit SystemMetrics(AzSystemMetrics inner) noexcept : inner_(inner) {}

    SystemMetrics(SystemMetrics&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SystemMetrics& operator=(SystemMetrics&& other) noexcept {
        if (this != &other) {
            AzSystemMetrics_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SystemMetrics() { AzSystemMetrics_delete(&inner_); }

    [[nodiscard]] static SystemMetrics default_();

    void delete_();
    SystemMetrics clone() const;
    bool partialEq(const SystemMetrics& b) const;
    String toDbgString() const;

    const AzSystemMetrics& inner() const { return inner_; }
    AzSystemMetrics& inner() { return inner_; }
    const AzSystemMetrics* ptr() const { return &inner_; }
    AzSystemMetrics* ptr() { return &inner_; }
    AzSystemMetrics release() { AzSystemMetrics result = inner_; inner_ = {}; return result; }
    operator AzSystemMetrics() && noexcept { AzSystemMetrics result = inner_; inner_ = {}; return result; }
};

class Button {
private:
    AzButton inner_;

    Button(const Button&) = delete;
    Button& operator=(const Button&) = delete;

public:
    explicit Button(AzButton inner) noexcept : inner_(inner) {}

    Button(Button&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Button& operator=(Button&& other) noexcept {
        if (this != &other) {
            AzButton_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Button() { AzButton_delete(&inner_); }

    [[nodiscard]] static Button create(String label);
    [[nodiscard]] static Button with_type(String label, AzButtonType button_type);

    void set_on_click(RefAny data, AzCallbackType callback);
    Button with_on_click(RefAny data, AzCallbackType callback) const;
    void set_button_type(AzButtonType button_type);
    Button with_button_type(AzButtonType button_type) const;
    Dom dom() const;
    void delete_();
    Button clone() const;
    bool partialEq(const Button& b) const;
    uint8_t partialCmp(const Button& b) const;
    String toDbgString() const;

    const AzButton& inner() const { return inner_; }
    AzButton& inner() { return inner_; }
    const AzButton* ptr() const { return &inner_; }
    AzButton* ptr() { return &inner_; }
    AzButton release() { AzButton result = inner_; inner_ = {}; return result; }
    operator AzButton() && noexcept { AzButton result = inner_; inner_ = {}; return result; }
};

class MapWidget {
private:
    AzMapWidget inner_;

    MapWidget(const MapWidget&) = delete;
    MapWidget& operator=(const MapWidget&) = delete;

public:
    explicit MapWidget(AzMapWidget inner) noexcept : inner_(inner) {}

    MapWidget(MapWidget&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MapWidget& operator=(MapWidget&& other) noexcept {
        if (this != &other) {
            AzMapWidget_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MapWidget() { AzMapWidget_delete(&inner_); }

    [[nodiscard]] static MapWidget create(MapTileLayer layer);

    MapWidget with_viewport(MapViewport viewport) const;
    void set_viewport(MapViewport viewport);
    MapWidget with_container_style(CssPropertyWithConditionsVec css) const;
    Dom dom() const;
    Dom dom_with_fetch(AzThreadCallbackType cb) const;
    MapWidget with_on_viewport_changed(RefAny data, AzMapViewportChangedCallbackType callback) const;
    void set_on_viewport_changed(RefAny data, AzMapViewportChangedCallbackType callback);
    static MapLatLon latlon_at_px(MapViewport viewport, LogicalPosition px, LogicalSize container);
    static LogicalPosition px_at_latlon(MapViewport viewport, MapLatLon coord, LogicalSize container);
    void set_on_pin_tap(RefAny data, AzMapPinTapCallbackType callback);
    MapWidget with_on_pin_tap(RefAny data, AzMapPinTapCallbackType callback) const;
    void delete_();
    MapWidget clone() const;
    bool partialEq(const MapWidget& b) const;
    String toDbgString() const;

    const AzMapWidget& inner() const { return inner_; }
    AzMapWidget& inner() { return inner_; }
    const AzMapWidget* ptr() const { return &inner_; }
    AzMapWidget* ptr() { return &inner_; }
    AzMapWidget release() { AzMapWidget result = inner_; inner_ = {}; return result; }
    operator AzMapWidget() && noexcept { AzMapWidget result = inner_; inner_ = {}; return result; }
};

class FileInputStateWrapper {
private:
    AzFileInputStateWrapper inner_;

    FileInputStateWrapper(const FileInputStateWrapper&) = delete;
    FileInputStateWrapper& operator=(const FileInputStateWrapper&) = delete;

public:
    explicit FileInputStateWrapper(AzFileInputStateWrapper inner) noexcept : inner_(inner) {}

    FileInputStateWrapper(FileInputStateWrapper&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FileInputStateWrapper& operator=(FileInputStateWrapper&& other) noexcept {
        if (this != &other) {
            AzFileInputStateWrapper_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FileInputStateWrapper() { AzFileInputStateWrapper_delete(&inner_); }

    [[nodiscard]] static FileInputStateWrapper default_();

    void delete_();
    FileInputStateWrapper clone() const;
    bool partialEq(const FileInputStateWrapper& b) const;
    String toDbgString() const;

    const AzFileInputStateWrapper& inner() const { return inner_; }
    AzFileInputStateWrapper& inner() { return inner_; }
    const AzFileInputStateWrapper* ptr() const { return &inner_; }
    AzFileInputStateWrapper* ptr() { return &inner_; }
    AzFileInputStateWrapper release() { AzFileInputStateWrapper result = inner_; inner_ = {}; return result; }
    operator AzFileInputStateWrapper() && noexcept { AzFileInputStateWrapper result = inner_; inner_ = {}; return result; }
};

class CheckBoxStateWrapper {
private:
    AzCheckBoxStateWrapper inner_;

    CheckBoxStateWrapper(const CheckBoxStateWrapper&) = delete;
    CheckBoxStateWrapper& operator=(const CheckBoxStateWrapper&) = delete;

public:
    explicit CheckBoxStateWrapper(AzCheckBoxStateWrapper inner) noexcept : inner_(inner) {}

    CheckBoxStateWrapper(CheckBoxStateWrapper&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CheckBoxStateWrapper& operator=(CheckBoxStateWrapper&& other) noexcept {
        if (this != &other) {
            AzCheckBoxStateWrapper_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CheckBoxStateWrapper() { AzCheckBoxStateWrapper_delete(&inner_); }

    [[nodiscard]] static CheckBoxStateWrapper default_();

    void delete_();
    CheckBoxStateWrapper clone() const;
    bool partialEq(const CheckBoxStateWrapper& b) const;
    String toDbgString() const;

    const AzCheckBoxStateWrapper& inner() const { return inner_; }
    AzCheckBoxStateWrapper& inner() { return inner_; }
    const AzCheckBoxStateWrapper* ptr() const { return &inner_; }
    AzCheckBoxStateWrapper* ptr() { return &inner_; }
    AzCheckBoxStateWrapper release() { AzCheckBoxStateWrapper result = inner_; inner_ = {}; return result; }
    operator AzCheckBoxStateWrapper() && noexcept { AzCheckBoxStateWrapper result = inner_; inner_ = {}; return result; }
};

class DropDown {
private:
    AzDropDown inner_;

    DropDown(const DropDown&) = delete;
    DropDown& operator=(const DropDown&) = delete;

public:
    explicit DropDown(AzDropDown inner) noexcept : inner_(inner) {}

    DropDown(DropDown&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DropDown& operator=(DropDown&& other) noexcept {
        if (this != &other) {
            AzDropDown_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DropDown() { AzDropDown_delete(&inner_); }

    [[nodiscard]] static DropDown create(StringVec choices);
    [[nodiscard]] static DropDown default_();

    void set_on_choice_change(RefAny data, AzDropDownOnChoiceChangeCallbackType callback);
    DropDown with_on_choice_change(RefAny data, AzDropDownOnChoiceChangeCallbackType callback) const;
    Dom dom() const;
    void delete_();
    DropDown clone() const;
    bool partialEq(const DropDown& b) const;
    String toDbgString() const;

    const AzDropDown& inner() const { return inner_; }
    AzDropDown& inner() { return inner_; }
    const AzDropDown* ptr() const { return &inner_; }
    AzDropDown* ptr() { return &inner_; }
    AzDropDown release() { AzDropDown result = inner_; inner_ = {}; return result; }
    operator AzDropDown() && noexcept { AzDropDown result = inner_; inner_ = {}; return result; }
};

class ColorInputStateWrapper {
private:
    AzColorInputStateWrapper inner_;

    ColorInputStateWrapper(const ColorInputStateWrapper&) = delete;
    ColorInputStateWrapper& operator=(const ColorInputStateWrapper&) = delete;

public:
    explicit ColorInputStateWrapper(AzColorInputStateWrapper inner) noexcept : inner_(inner) {}

    ColorInputStateWrapper(ColorInputStateWrapper&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ColorInputStateWrapper& operator=(ColorInputStateWrapper&& other) noexcept {
        if (this != &other) {
            AzColorInputStateWrapper_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ColorInputStateWrapper() { AzColorInputStateWrapper_delete(&inner_); }

    [[nodiscard]] static ColorInputStateWrapper default_();

    void delete_();
    ColorInputStateWrapper clone() const;
    bool partialEq(const ColorInputStateWrapper& b) const;
    uint8_t partialCmp(const ColorInputStateWrapper& b) const;
    String toDbgString() const;

    const AzColorInputStateWrapper& inner() const { return inner_; }
    AzColorInputStateWrapper& inner() { return inner_; }
    const AzColorInputStateWrapper* ptr() const { return &inner_; }
    AzColorInputStateWrapper* ptr() { return &inner_; }
    AzColorInputStateWrapper release() { AzColorInputStateWrapper result = inner_; inner_ = {}; return result; }
    operator AzColorInputStateWrapper() && noexcept { AzColorInputStateWrapper result = inner_; inner_ = {}; return result; }
};

class TextInputStateWrapper {
private:
    AzTextInputStateWrapper inner_;

    TextInputStateWrapper(const TextInputStateWrapper&) = delete;
    TextInputStateWrapper& operator=(const TextInputStateWrapper&) = delete;

public:
    explicit TextInputStateWrapper(AzTextInputStateWrapper inner) noexcept : inner_(inner) {}

    TextInputStateWrapper(TextInputStateWrapper&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextInputStateWrapper& operator=(TextInputStateWrapper&& other) noexcept {
        if (this != &other) {
            AzTextInputStateWrapper_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextInputStateWrapper() { AzTextInputStateWrapper_delete(&inner_); }

    [[nodiscard]] static TextInputStateWrapper default_();

    void delete_();
    TextInputStateWrapper clone() const;
    bool partialEq(const TextInputStateWrapper& b) const;
    String toDbgString() const;

    const AzTextInputStateWrapper& inner() const { return inner_; }
    AzTextInputStateWrapper& inner() { return inner_; }
    const AzTextInputStateWrapper* ptr() const { return &inner_; }
    AzTextInputStateWrapper* ptr() { return &inner_; }
    AzTextInputStateWrapper release() { AzTextInputStateWrapper result = inner_; inner_ = {}; return result; }
    operator AzTextInputStateWrapper() && noexcept { AzTextInputStateWrapper result = inner_; inner_ = {}; return result; }
};

class NumberInputStateWrapper {
private:
    AzNumberInputStateWrapper inner_;

    NumberInputStateWrapper(const NumberInputStateWrapper&) = delete;
    NumberInputStateWrapper& operator=(const NumberInputStateWrapper&) = delete;

public:
    explicit NumberInputStateWrapper(AzNumberInputStateWrapper inner) noexcept : inner_(inner) {}

    NumberInputStateWrapper(NumberInputStateWrapper&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NumberInputStateWrapper& operator=(NumberInputStateWrapper&& other) noexcept {
        if (this != &other) {
            AzNumberInputStateWrapper_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NumberInputStateWrapper() { AzNumberInputStateWrapper_delete(&inner_); }

    [[nodiscard]] static NumberInputStateWrapper default_();

    void delete_();
    NumberInputStateWrapper clone() const;
    bool partialEq(const NumberInputStateWrapper& b) const;
    String toDbgString() const;

    const AzNumberInputStateWrapper& inner() const { return inner_; }
    AzNumberInputStateWrapper& inner() { return inner_; }
    const AzNumberInputStateWrapper* ptr() const { return &inner_; }
    AzNumberInputStateWrapper* ptr() { return &inner_; }
    AzNumberInputStateWrapper release() { AzNumberInputStateWrapper result = inner_; inner_ = {}; return result; }
    operator AzNumberInputStateWrapper() && noexcept { AzNumberInputStateWrapper result = inner_; inner_ = {}; return result; }
};

class TabHeader {
private:
    AzTabHeader inner_;

    TabHeader(const TabHeader&) = delete;
    TabHeader& operator=(const TabHeader&) = delete;

public:
    explicit TabHeader(AzTabHeader inner) noexcept : inner_(inner) {}

    TabHeader(TabHeader&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TabHeader& operator=(TabHeader&& other) noexcept {
        if (this != &other) {
            AzTabHeader_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TabHeader() { AzTabHeader_delete(&inner_); }

    [[nodiscard]] static TabHeader create(StringVec tabs);
    [[nodiscard]] static TabHeader default_();

    void set_active_tab(size_t active_tab);
    TabHeader with_active_tab(size_t active_tab) const;
    void set_on_click(RefAny data, AzTabOnClickCallbackType callback);
    TabHeader with_on_click(RefAny data, AzTabOnClickCallbackType callback) const;
    Dom dom() const;
    void delete_();
    TabHeader clone() const;
    String toDbgString() const;

    const AzTabHeader& inner() const { return inner_; }
    AzTabHeader& inner() { return inner_; }
    const AzTabHeader* ptr() const { return &inner_; }
    AzTabHeader* ptr() { return &inner_; }
    AzTabHeader release() { AzTabHeader result = inner_; inner_ = {}; return result; }
    operator AzTabHeader() && noexcept { AzTabHeader result = inner_; inner_ = {}; return result; }
};

class ListView {
private:
    AzListView inner_;

    ListView(const ListView&) = delete;
    ListView& operator=(const ListView&) = delete;

public:
    explicit ListView(AzListView inner) noexcept : inner_(inner) {}

    ListView(ListView&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ListView& operator=(ListView&& other) noexcept {
        if (this != &other) {
            AzListView_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ListView() { AzListView_delete(&inner_); }

    [[nodiscard]] static ListView create(StringVec columns);
    [[nodiscard]] static ListView default_();

    ListView with_rows(ListViewRowVec rows) const;
    Dom dom() const;
    void delete_();
    ListView clone() const;
    String toDbgString() const;

    const AzListView& inner() const { return inner_; }
    AzListView& inner() { return inner_; }
    const AzListView* ptr() const { return &inner_; }
    AzListView* ptr() { return &inner_; }
    AzListView release() { AzListView result = inner_; inner_ = {}; return result; }
    operator AzListView() && noexcept { AzListView result = inner_; inner_ = {}; return result; }
};

class Ribbon {
private:
    AzRibbon inner_;

    Ribbon(const Ribbon&) = delete;
    Ribbon& operator=(const Ribbon&) = delete;

public:
    explicit Ribbon(AzRibbon inner) noexcept : inner_(inner) {}

    Ribbon(Ribbon&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Ribbon& operator=(Ribbon&& other) noexcept {
        if (this != &other) {
            AzRibbon_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Ribbon() { AzRibbon_delete(&inner_); }

    [[nodiscard]] static Ribbon new_(RibbonTabVec tabs);

    void set_active_tab(size_t index);
    void set_on_tab_click(RefAny data, AzRibbonOnTabClickCallbackType cb);
    Ribbon with_on_tab_click(RefAny data, AzRibbonOnTabClickCallbackType cb) const;
    Dom dom() const;
    void delete_();
    Ribbon clone() const;
    String toDbgString() const;

    const AzRibbon& inner() const { return inner_; }
    AzRibbon& inner() { return inner_; }
    const AzRibbon* ptr() const { return &inner_; }
    AzRibbon* ptr() { return &inner_; }
    AzRibbon release() { AzRibbon result = inner_; inner_ = {}; return result; }
    operator AzRibbon() && noexcept { AzRibbon result = inner_; inner_ = {}; return result; }
};

class TreeView {
private:
    AzTreeView inner_;

    TreeView(const TreeView&) = delete;
    TreeView& operator=(const TreeView&) = delete;

public:
    explicit TreeView(AzTreeView inner) noexcept : inner_(inner) {}

    TreeView(TreeView&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TreeView& operator=(TreeView&& other) noexcept {
        if (this != &other) {
            AzTreeView_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TreeView() { AzTreeView_delete(&inner_); }

    [[nodiscard]] static TreeView new_(TreeViewNode root);

    void set_on_node_click(RefAny data, AzTreeViewOnNodeClickCallbackType callback);
    TreeView with_on_node_click(RefAny data, AzTreeViewOnNodeClickCallbackType callback) const;
    Dom dom() const;
    void delete_();
    TreeView clone() const;
    bool partialEq(const TreeView& b) const;
    String toDbgString() const;

    const AzTreeView& inner() const { return inner_; }
    AzTreeView& inner() { return inner_; }
    const AzTreeView* ptr() const { return &inner_; }
    AzTreeView* ptr() { return &inner_; }
    AzTreeView release() { AzTreeView result = inner_; inner_ = {}; return result; }
    operator AzTreeView() && noexcept { AzTreeView result = inner_; inner_ = {}; return result; }
};

class CameraWidget {
private:
    AzCameraWidget inner_;

    CameraWidget(const CameraWidget&) = delete;
    CameraWidget& operator=(const CameraWidget&) = delete;

public:
    explicit CameraWidget(AzCameraWidget inner) noexcept : inner_(inner) {}

    CameraWidget(CameraWidget&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CameraWidget& operator=(CameraWidget&& other) noexcept {
        if (this != &other) {
            AzCameraWidget_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CameraWidget() { AzCameraWidget_delete(&inner_); }

    [[nodiscard]] static CameraWidget create(CameraConfig config);

    Dom dom() const;
    CameraWidget with_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame) const;
    void set_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame);
    void delete_();

    const AzCameraWidget& inner() const { return inner_; }
    AzCameraWidget& inner() { return inner_; }
    const AzCameraWidget* ptr() const { return &inner_; }
    AzCameraWidget* ptr() { return &inner_; }
    AzCameraWidget release() { AzCameraWidget result = inner_; inner_ = {}; return result; }
    operator AzCameraWidget() && noexcept { AzCameraWidget result = inner_; inner_ = {}; return result; }
};

class ScreenCaptureWidget {
private:
    AzScreenCaptureWidget inner_;

    ScreenCaptureWidget(const ScreenCaptureWidget&) = delete;
    ScreenCaptureWidget& operator=(const ScreenCaptureWidget&) = delete;

public:
    explicit ScreenCaptureWidget(AzScreenCaptureWidget inner) noexcept : inner_(inner) {}

    ScreenCaptureWidget(ScreenCaptureWidget&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ScreenCaptureWidget& operator=(ScreenCaptureWidget&& other) noexcept {
        if (this != &other) {
            AzScreenCaptureWidget_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ScreenCaptureWidget() { AzScreenCaptureWidget_delete(&inner_); }

    [[nodiscard]] static ScreenCaptureWidget create(ScreenCaptureConfig config);

    Dom dom() const;
    ScreenCaptureWidget with_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame) const;
    void set_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame);
    void delete_();

    const AzScreenCaptureWidget& inner() const { return inner_; }
    AzScreenCaptureWidget& inner() { return inner_; }
    const AzScreenCaptureWidget* ptr() const { return &inner_; }
    AzScreenCaptureWidget* ptr() { return &inner_; }
    AzScreenCaptureWidget release() { AzScreenCaptureWidget result = inner_; inner_ = {}; return result; }
    operator AzScreenCaptureWidget() && noexcept { AzScreenCaptureWidget result = inner_; inner_ = {}; return result; }
};

class VideoWidget {
private:
    AzVideoWidget inner_;

    VideoWidget(const VideoWidget&) = delete;
    VideoWidget& operator=(const VideoWidget&) = delete;

public:
    explicit VideoWidget(AzVideoWidget inner) noexcept : inner_(inner) {}

    VideoWidget(VideoWidget&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VideoWidget& operator=(VideoWidget&& other) noexcept {
        if (this != &other) {
            AzVideoWidget_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VideoWidget() { AzVideoWidget_delete(&inner_); }

    [[nodiscard]] static VideoWidget create(VideoConfig config);

    Dom dom() const;
    VideoWidget with_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame) const;
    void set_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame);
    void delete_();

    const AzVideoWidget& inner() const { return inner_; }
    AzVideoWidget& inner() { return inner_; }
    const AzVideoWidget* ptr() const { return &inner_; }
    AzVideoWidget* ptr() { return &inner_; }
    AzVideoWidget release() { AzVideoWidget result = inner_; inner_ = {}; return result; }
    operator AzVideoWidget() && noexcept { AzVideoWidget result = inner_; inner_ = {}; return result; }
};

class MicrophoneWidget {
private:
    AzMicrophoneWidget inner_;

    MicrophoneWidget(const MicrophoneWidget&) = delete;
    MicrophoneWidget& operator=(const MicrophoneWidget&) = delete;

public:
    explicit MicrophoneWidget(AzMicrophoneWidget inner) noexcept : inner_(inner) {}

    MicrophoneWidget(MicrophoneWidget&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    MicrophoneWidget& operator=(MicrophoneWidget&& other) noexcept {
        if (this != &other) {
            AzMicrophoneWidget_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~MicrophoneWidget() { AzMicrophoneWidget_delete(&inner_); }

    [[nodiscard]] static MicrophoneWidget create(AudioConfig config);

    MicrophoneWidget with_on_frame(RefAny data, AzOnAudioFrameCallbackType on_frame) const;
    void set_on_frame(RefAny data, AzOnAudioFrameCallbackType on_frame);
    Dom dom() const;
    void delete_();

    const AzMicrophoneWidget& inner() const { return inner_; }
    AzMicrophoneWidget& inner() { return inner_; }
    const AzMicrophoneWidget* ptr() const { return &inner_; }
    AzMicrophoneWidget* ptr() { return &inner_; }
    AzMicrophoneWidget release() { AzMicrophoneWidget result = inner_; inner_ = {}; return result; }
    operator AzMicrophoneWidget() && noexcept { AzMicrophoneWidget result = inner_; inner_ = {}; return result; }
};

class TessellatedGPUSvgNode {
private:
    AzTessellatedGPUSvgNode inner_;

    TessellatedGPUSvgNode(const TessellatedGPUSvgNode&) = delete;
    TessellatedGPUSvgNode& operator=(const TessellatedGPUSvgNode&) = delete;

public:
    explicit TessellatedGPUSvgNode(AzTessellatedGPUSvgNode inner) noexcept : inner_(inner) {}

    TessellatedGPUSvgNode(TessellatedGPUSvgNode&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TessellatedGPUSvgNode& operator=(TessellatedGPUSvgNode&& other) noexcept {
        if (this != &other) {
            AzTessellatedGPUSvgNode_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TessellatedGPUSvgNode() { AzTessellatedGPUSvgNode_delete(&inner_); }

    [[nodiscard]] static TessellatedGPUSvgNode create(TessellatedSvgNode node, GlContextPtr gl);

    bool draw(Texture& texture, AzPhysicalSizeU32 target_size, ColorU color, StyleTransformVec transforms) const;
    void delete_();
    TessellatedGPUSvgNode clone() const;
    bool partialEq(const TessellatedGPUSvgNode& b) const;
    uint8_t partialCmp(const TessellatedGPUSvgNode& b) const;
    String toDbgString() const;

    const AzTessellatedGPUSvgNode& inner() const { return inner_; }
    AzTessellatedGPUSvgNode& inner() { return inner_; }
    const AzTessellatedGPUSvgNode* ptr() const { return &inner_; }
    AzTessellatedGPUSvgNode* ptr() { return &inner_; }
    AzTessellatedGPUSvgNode release() { AzTessellatedGPUSvgNode result = inner_; inner_ = {}; return result; }
    operator AzTessellatedGPUSvgNode() && noexcept { AzTessellatedGPUSvgNode result = inner_; inner_ = {}; return result; }
};

class TessellatedColoredGPUSvgNode {
private:
    AzTessellatedColoredGPUSvgNode inner_;

    TessellatedColoredGPUSvgNode(const TessellatedColoredGPUSvgNode&) = delete;
    TessellatedColoredGPUSvgNode& operator=(const TessellatedColoredGPUSvgNode&) = delete;

public:
    explicit TessellatedColoredGPUSvgNode(AzTessellatedColoredGPUSvgNode inner) noexcept : inner_(inner) {}

    TessellatedColoredGPUSvgNode(TessellatedColoredGPUSvgNode&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TessellatedColoredGPUSvgNode& operator=(TessellatedColoredGPUSvgNode&& other) noexcept {
        if (this != &other) {
            AzTessellatedColoredGPUSvgNode_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TessellatedColoredGPUSvgNode() { AzTessellatedColoredGPUSvgNode_delete(&inner_); }

    void delete_();
    TessellatedColoredGPUSvgNode clone() const;
    bool partialEq(const TessellatedColoredGPUSvgNode& b) const;
    uint8_t partialCmp(const TessellatedColoredGPUSvgNode& b) const;
    String toDbgString() const;

    const AzTessellatedColoredGPUSvgNode& inner() const { return inner_; }
    AzTessellatedColoredGPUSvgNode& inner() { return inner_; }
    const AzTessellatedColoredGPUSvgNode* ptr() const { return &inner_; }
    AzTessellatedColoredGPUSvgNode* ptr() { return &inner_; }
    AzTessellatedColoredGPUSvgNode release() { AzTessellatedColoredGPUSvgNode result = inner_; inner_ = {}; return result; }
    operator AzTessellatedColoredGPUSvgNode() && noexcept { AzTessellatedColoredGPUSvgNode result = inner_; inner_ = {}; return result; }
};

class XmlTextError {
private:
    AzXmlTextError inner_;

    XmlTextError(const XmlTextError&) = delete;
    XmlTextError& operator=(const XmlTextError&) = delete;

public:
    explicit XmlTextError(AzXmlTextError inner) noexcept : inner_(inner) {}

    XmlTextError(XmlTextError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    XmlTextError& operator=(XmlTextError&& other) noexcept {
        if (this != &other) {
            AzXmlTextError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~XmlTextError() { AzXmlTextError_delete(&inner_); }

    void delete_();
    XmlTextError clone() const;
    bool partialEq(const XmlTextError& b) const;
    uint8_t partialCmp(const XmlTextError& b) const;
    String toDbgString() const;

    const AzXmlTextError& inner() const { return inner_; }
    AzXmlTextError& inner() { return inner_; }
    const AzXmlTextError* ptr() const { return &inner_; }
    AzXmlTextError* ptr() { return &inner_; }
    AzXmlTextError release() { AzXmlTextError result = inner_; inner_ = {}; return result; }
    operator AzXmlTextError() && noexcept { AzXmlTextError result = inner_; inner_ = {}; return result; }
};

class JsonKeyValue {
private:
    AzJsonKeyValue inner_;

    JsonKeyValue(const JsonKeyValue&) = delete;
    JsonKeyValue& operator=(const JsonKeyValue&) = delete;

public:
    explicit JsonKeyValue(AzJsonKeyValue inner) noexcept : inner_(inner) {}

    JsonKeyValue(JsonKeyValue&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    JsonKeyValue& operator=(JsonKeyValue&& other) noexcept {
        if (this != &other) {
            AzJsonKeyValue_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~JsonKeyValue() { AzJsonKeyValue_delete(&inner_); }

    [[nodiscard]] static JsonKeyValue create(String key, Json value);

    void delete_();
    JsonKeyValue clone() const;
    bool partialEq(const JsonKeyValue& b) const;
    String toDbgString() const;

    const AzJsonKeyValue& inner() const { return inner_; }
    AzJsonKeyValue& inner() { return inner_; }
    const AzJsonKeyValue* ptr() const { return &inner_; }
    AzJsonKeyValue* ptr() { return &inner_; }
    AzJsonKeyValue release() { AzJsonKeyValue result = inner_; inner_ = {}; return result; }
    operator AzJsonKeyValue() && noexcept { AzJsonKeyValue result = inner_; inner_ = {}; return result; }
};

class ExternalResource {
private:
    AzExternalResource inner_;

    ExternalResource(const ExternalResource&) = delete;
    ExternalResource& operator=(const ExternalResource&) = delete;

public:
    explicit ExternalResource(AzExternalResource inner) noexcept : inner_(inner) {}

    ExternalResource(ExternalResource&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ExternalResource& operator=(ExternalResource&& other) noexcept {
        if (this != &other) {
            AzExternalResource_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ExternalResource() { AzExternalResource_delete(&inner_); }

    void delete_();
    ExternalResource clone() const;
    bool partialEq(const ExternalResource& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ExternalResource& b) const;
    uint8_t cmp(const ExternalResource& b) const;
    String toDbgString() const;

    const AzExternalResource& inner() const { return inner_; }
    AzExternalResource& inner() { return inner_; }
    const AzExternalResource* ptr() const { return &inner_; }
    AzExternalResource* ptr() { return &inner_; }
    AzExternalResource release() { AzExternalResource result = inner_; inner_ = {}; return result; }
    operator AzExternalResource() && noexcept { AzExternalResource result = inner_; inner_ = {}; return result; }
};

class ComponentCallbackArg {
private:
    AzComponentCallbackArg inner_;

    ComponentCallbackArg(const ComponentCallbackArg&) = delete;
    ComponentCallbackArg& operator=(const ComponentCallbackArg&) = delete;

public:
    explicit ComponentCallbackArg(AzComponentCallbackArg inner) noexcept : inner_(inner) {}

    ComponentCallbackArg(ComponentCallbackArg&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentCallbackArg& operator=(ComponentCallbackArg&& other) noexcept {
        if (this != &other) {
            AzComponentCallbackArg_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentCallbackArg() { AzComponentCallbackArg_delete(&inner_); }

    void delete_();
    ComponentCallbackArg clone() const;
    bool partialEq(const ComponentCallbackArg& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const ComponentCallbackArg& b) const;
    uint8_t cmp(const ComponentCallbackArg& b) const;
    String toDbgString() const;

    const AzComponentCallbackArg& inner() const { return inner_; }
    AzComponentCallbackArg& inner() { return inner_; }
    const AzComponentCallbackArg* ptr() const { return &inner_; }
    AzComponentCallbackArg* ptr() { return &inner_; }
    AzComponentCallbackArg release() { AzComponentCallbackArg result = inner_; inner_ = {}; return result; }
    operator AzComponentCallbackArg() && noexcept { AzComponentCallbackArg result = inner_; inner_ = {}; return result; }
};

class PlatformSpecificOptions {
private:
    AzPlatformSpecificOptions inner_;

    PlatformSpecificOptions(const PlatformSpecificOptions&) = delete;
    PlatformSpecificOptions& operator=(const PlatformSpecificOptions&) = delete;

public:
    explicit PlatformSpecificOptions(AzPlatformSpecificOptions inner) noexcept : inner_(inner) {}

    PlatformSpecificOptions(PlatformSpecificOptions&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    PlatformSpecificOptions& operator=(PlatformSpecificOptions&& other) noexcept {
        if (this != &other) {
            AzPlatformSpecificOptions_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~PlatformSpecificOptions() { AzPlatformSpecificOptions_delete(&inner_); }

    [[nodiscard]] static PlatformSpecificOptions default_();

    void delete_();
    PlatformSpecificOptions clone() const;
    bool partialEq(const PlatformSpecificOptions& b) const;
    uint8_t partialCmp(const PlatformSpecificOptions& b) const;
    String toDbgString() const;

    const AzPlatformSpecificOptions& inner() const { return inner_; }
    AzPlatformSpecificOptions& inner() { return inner_; }
    const AzPlatformSpecificOptions* ptr() const { return &inner_; }
    AzPlatformSpecificOptions* ptr() { return &inner_; }
    AzPlatformSpecificOptions release() { AzPlatformSpecificOptions result = inner_; inner_ = {}; return result; }
    operator AzPlatformSpecificOptions() && noexcept { AzPlatformSpecificOptions result = inner_; inner_ = {}; return result; }
};

class TextChangeset {
private:
    AzTextChangeset inner_;

    TextChangeset(const TextChangeset&) = delete;
    TextChangeset& operator=(const TextChangeset&) = delete;

public:
    explicit TextChangeset(AzTextChangeset inner) noexcept : inner_(inner) {}

    TextChangeset(TextChangeset&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextChangeset& operator=(TextChangeset&& other) noexcept {
        if (this != &other) {
            AzTextChangeset_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextChangeset() { AzTextChangeset_delete(&inner_); }

    void delete_();
    TextChangeset clone() const;
    String toDbgString() const;

    const AzTextChangeset& inner() const { return inner_; }
    AzTextChangeset& inner() { return inner_; }
    const AzTextChangeset* ptr() const { return &inner_; }
    AzTextChangeset* ptr() { return &inner_; }
    AzTextChangeset release() { AzTextChangeset result = inner_; inner_ = {}; return result; }
    operator AzTextChangeset() && noexcept { AzTextChangeset result = inner_; inner_ = {}; return result; }
};

class Dom {
private:
    AzDom inner_;

    Dom(const Dom&) = delete;
    Dom& operator=(const Dom&) = delete;

public:
    explicit Dom(AzDom inner) noexcept : inner_(inner) {}

    Dom(Dom&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Dom& operator=(Dom&& other) noexcept {
        if (this != &other) {
            AzDom_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Dom() { AzDom_delete(&inner_); }

    [[nodiscard]] static Dom create_body();
    [[nodiscard]] static Dom create_div();
    [[nodiscard]] static Dom create_br();
    [[nodiscard]] static Dom create_text(String value);
    [[nodiscard]] static Dom create_image(ImageRef image);
    [[nodiscard]] static Dom create_icon(String icon_name);
    [[nodiscard]] static Dom create_virtual_view(RefAny data, AzVirtualViewCallbackType callback);
    [[nodiscard]] static Dom create_node(AzNodeType node_type);
    [[nodiscard]] static Dom create_from_data(NodeData node_data);
    [[nodiscard]] static Dom create_from_parsed_xml(AzXml xml);
    [[nodiscard]] static Dom create_html();
    [[nodiscard]] static Dom create_head();
    [[nodiscard]] static Dom create_article();
    [[nodiscard]] static Dom create_section();
    [[nodiscard]] static Dom create_nav();
    [[nodiscard]] static Dom create_aside();
    [[nodiscard]] static Dom create_header();
    [[nodiscard]] static Dom create_footer();
    [[nodiscard]] static Dom create_main();
    [[nodiscard]] static Dom create_figure();
    [[nodiscard]] static Dom create_figcaption();
    [[nodiscard]] static Dom create_details(SmallAriaInfo aria);
    [[nodiscard]] static Dom create_details_no_a11y();
    [[nodiscard]] static Dom create_summary(SmallAriaInfo aria);
    [[nodiscard]] static Dom create_summary_no_a11y();
    [[nodiscard]] static Dom create_summary_with_text(String text, SmallAriaInfo aria);
    [[nodiscard]] static Dom create_summary_with_text_no_a11y(String text);
    [[nodiscard]] static Dom create_dialog(DialogAriaInfo aria);
    [[nodiscard]] static Dom create_dialog_no_a11y();
    [[nodiscard]] static Dom create_p();
    [[nodiscard]] static Dom create_h1();
    [[nodiscard]] static Dom create_h1_with_text(String text);
    [[nodiscard]] static Dom create_h2();
    [[nodiscard]] static Dom create_h2_with_text(String text);
    [[nodiscard]] static Dom create_h3();
    [[nodiscard]] static Dom create_h3_with_text(String text);
    [[nodiscard]] static Dom create_h4();
    [[nodiscard]] static Dom create_h4_with_text(String text);
    [[nodiscard]] static Dom create_h5();
    [[nodiscard]] static Dom create_h5_with_text(String text);
    [[nodiscard]] static Dom create_h6();
    [[nodiscard]] static Dom create_h6_with_text(String text);
    [[nodiscard]] static Dom create_span();
    [[nodiscard]] static Dom create_span_with_text(String text);
    [[nodiscard]] static Dom create_strong();
    [[nodiscard]] static Dom create_strong_with_text(String text);
    [[nodiscard]] static Dom create_em();
    [[nodiscard]] static Dom create_em_with_text(String text);
    [[nodiscard]] static Dom create_code();
    [[nodiscard]] static Dom create_code_with_text(String code);
    [[nodiscard]] static Dom create_pre();
    [[nodiscard]] static Dom create_pre_with_text(String text);
    [[nodiscard]] static Dom create_blockquote();
    [[nodiscard]] static Dom create_blockquote_with_text(String text);
    [[nodiscard]] static Dom create_cite();
    [[nodiscard]] static Dom create_cite_with_text(String text);
    [[nodiscard]] static Dom create_abbr();
    [[nodiscard]] static Dom create_abbr_with_title(String abbr_text, String title);
    [[nodiscard]] static Dom create_kbd();
    [[nodiscard]] static Dom create_kbd_with_text(String text);
    [[nodiscard]] static Dom create_samp();
    [[nodiscard]] static Dom create_samp_with_text(String text);
    [[nodiscard]] static Dom create_var();
    [[nodiscard]] static Dom create_var_with_text(String text);
    [[nodiscard]] static Dom create_sub();
    [[nodiscard]] static Dom create_sub_with_text(String text);
    [[nodiscard]] static Dom create_sup();
    [[nodiscard]] static Dom create_sup_with_text(String text);
    [[nodiscard]] static Dom create_u();
    [[nodiscard]] static Dom create_u_with_text(String text);
    [[nodiscard]] static Dom create_s();
    [[nodiscard]] static Dom create_s_with_text(String text);
    [[nodiscard]] static Dom create_mark();
    [[nodiscard]] static Dom create_mark_with_text(String text);
    [[nodiscard]] static Dom create_del();
    [[nodiscard]] static Dom create_del_with_text(String text);
    [[nodiscard]] static Dom create_ins();
    [[nodiscard]] static Dom create_ins_with_text(String text);
    [[nodiscard]] static Dom create_dfn();
    [[nodiscard]] static Dom create_dfn_with_text(String text);
    [[nodiscard]] static Dom create_time(String text, OptionString datetime);
    [[nodiscard]] static Dom create_bdo();
    [[nodiscard]] static Dom create_bdo_with_text(String text);
    [[nodiscard]] static Dom create_a(String href, String text, SmallAriaInfo aria);
    [[nodiscard]] static Dom create_a_no_a11y(String href, OptionString label);
    [[nodiscard]] static Dom create_button(String text, SmallAriaInfo aria);
    [[nodiscard]] static Dom create_button_no_a11y(String text);
    [[nodiscard]] static Dom create_label(String for_id, String text, SmallAriaInfo aria);
    [[nodiscard]] static Dom create_label_no_a11y(String for_id, String text);
    [[nodiscard]] static Dom create_input(String input_type, String name, String label, SmallAriaInfo aria);
    [[nodiscard]] static Dom create_input_no_a11y(String input_type, String name, String label);
    [[nodiscard]] static Dom create_textarea(String name, String label, SmallAriaInfo aria);
    [[nodiscard]] static Dom create_textarea_no_a11y(String name, String label);
    [[nodiscard]] static Dom create_select(String name, String label, SmallAriaInfo aria);
    [[nodiscard]] static Dom create_select_no_a11y(String name, String label);
    [[nodiscard]] static Dom create_option(String value, String text, SmallAriaInfo aria);
    [[nodiscard]] static Dom create_option_no_a11y(String value, String text);
    [[nodiscard]] static Dom create_ul();
    [[nodiscard]] static Dom create_ol();
    [[nodiscard]] static Dom create_li();
    [[nodiscard]] static Dom create_table(String caption, SmallAriaInfo aria);
    [[nodiscard]] static Dom create_table_no_a11y();
    [[nodiscard]] static Dom create_caption();
    [[nodiscard]] static Dom create_thead();
    [[nodiscard]] static Dom create_tbody();
    [[nodiscard]] static Dom create_tfoot();
    [[nodiscard]] static Dom create_tr();
    [[nodiscard]] static Dom create_th();
    [[nodiscard]] static Dom create_td();
    [[nodiscard]] static Dom create_form(SmallAriaInfo aria);
    [[nodiscard]] static Dom create_form_no_a11y();
    [[nodiscard]] static Dom create_fieldset(SmallAriaInfo aria);
    [[nodiscard]] static Dom create_fieldset_no_a11y();
    [[nodiscard]] static Dom create_legend(SmallAriaInfo aria);
    [[nodiscard]] static Dom create_legend_no_a11y();
    [[nodiscard]] static Dom create_hr();
    [[nodiscard]] static Dom create_address();
    [[nodiscard]] static Dom create_dl();
    [[nodiscard]] static Dom create_dt();
    [[nodiscard]] static Dom create_dd();
    [[nodiscard]] static Dom create_colgroup();
    [[nodiscard]] static Dom create_col(int32_t span);
    [[nodiscard]] static Dom create_optgroup(String label, SmallAriaInfo aria);
    [[nodiscard]] static Dom create_optgroup_no_a11y(String label);
    [[nodiscard]] static Dom create_q();
    [[nodiscard]] static Dom create_acronym();
    [[nodiscard]] static Dom create_acronym_with_text(String text);
    [[nodiscard]] static Dom create_menu(SmallAriaInfo aria);
    [[nodiscard]] static Dom create_menu_no_a11y();
    [[nodiscard]] static Dom create_menuitem(SmallAriaInfo aria);
    [[nodiscard]] static Dom create_menuitem_no_a11y();
    [[nodiscard]] static Dom create_menuitem_with_text(String text, SmallAriaInfo aria);
    [[nodiscard]] static Dom create_menuitem_with_text_no_a11y(String text);
    [[nodiscard]] static Dom create_output(SmallAriaInfo aria);
    [[nodiscard]] static Dom create_output_no_a11y();
    [[nodiscard]] static Dom create_progress(ProgressAriaInfo aria);
    [[nodiscard]] static Dom create_progress_no_a11y(float value, float max);
    [[nodiscard]] static Dom create_meter(MeterAriaInfo aria);
    [[nodiscard]] static Dom create_meter_no_a11y(float value, float min, float max);
    [[nodiscard]] static Dom create_datalist(SmallAriaInfo aria);
    [[nodiscard]] static Dom create_datalist_no_a11y();
    [[nodiscard]] static Dom create_canvas(SmallAriaInfo aria);
    [[nodiscard]] static Dom create_canvas_no_a11y();
    [[nodiscard]] static Dom create_object();
    [[nodiscard]] static Dom create_param(String name, String value);
    [[nodiscard]] static Dom create_embed();
    [[nodiscard]] static Dom create_audio(SmallAriaInfo aria);
    [[nodiscard]] static Dom create_audio_no_a11y();
    [[nodiscard]] static Dom create_video(SmallAriaInfo aria);
    [[nodiscard]] static Dom create_video_no_a11y();
    [[nodiscard]] static Dom create_source(String src, String media_type);
    [[nodiscard]] static Dom create_track(String src, String kind);
    [[nodiscard]] static Dom create_map();
    [[nodiscard]] static Dom create_area(SmallAriaInfo aria);
    [[nodiscard]] static Dom create_area_no_a11y();
    [[nodiscard]] static Dom create_title();
    [[nodiscard]] static Dom create_title_with_text(String text);
    [[nodiscard]] static Dom create_meta();
    [[nodiscard]] static Dom create_link();
    [[nodiscard]] static Dom create_script();
    [[nodiscard]] static Dom create_style();
    [[nodiscard]] static Dom create_style_with_text(String text);
    [[nodiscard]] static Dom create_base(String href);
    [[nodiscard]] static Dom create_b();
    [[nodiscard]] static Dom create_b_with_text(String text);
    [[nodiscard]] static Dom create_i();
    [[nodiscard]] static Dom create_i_with_text(String text);
    [[nodiscard]] static Dom create_small();
    [[nodiscard]] static Dom create_small_with_text(String text);
    [[nodiscard]] static Dom create_big();
    [[nodiscard]] static Dom create_big_with_text(String text);
    [[nodiscard]] static Dom create_bdi();
    [[nodiscard]] static Dom create_bdi_with_text(String text);
    [[nodiscard]] static Dom create_wbr();
    [[nodiscard]] static Dom create_ruby();
    [[nodiscard]] static Dom create_rt();
    [[nodiscard]] static Dom create_rt_with_text(String text);
    [[nodiscard]] static Dom create_rtc();
    [[nodiscard]] static Dom create_rp();
    [[nodiscard]] static Dom create_rp_with_text(String text);
    [[nodiscard]] static Dom create_data(String value);
    [[nodiscard]] static Dom create_data_with_text(String value, String text);
    [[nodiscard]] static Dom create_dir();
    [[nodiscard]] static Dom create_svg();
    [[nodiscard]] static Dom create_th_with_scope(String scope, String text);
    [[nodiscard]] static Dom create_td_with_text(String text);
    [[nodiscard]] static Dom create_th_with_text(String text);
    [[nodiscard]] static Dom create_li_with_text(String text);
    [[nodiscard]] static Dom create_p_with_text(String text);
    [[nodiscard]] static Dom create_geolocation_probe(GeolocationProbeConfig config);
    [[nodiscard]] static Dom default_();

    Dom with_dataset(OptionRefAny data) const;
    Dom with_ids_and_classes(IdOrClassVec ids_and_classes) const;
    Dom with_callbacks(CoreCallbackDataVec callbacks) const;
    Dom with_callback(AzEventFilter event, RefAny data, AzCallbackType callback) const;
    void add_child(Dom child);
    Dom with_child(Dom child) const;
    void set_children(DomVec children);
    Dom with_children(DomVec children) const;
    Dom with_id(String id) const;
    Dom with_class(String class_) const;
    void add_css_property(CssPropertyWithConditions prop);
    Dom with_css_property(CssPropertyWithConditions prop) const;
    Dom with_clip_mask(ImageMask clip_mask) const;
    Dom with_tab_index(AzTabIndex tab_index) const;
    Dom with_contenteditable(bool contenteditable) const;
    Dom with_accessibility_info(AccessibilityInfo accessibility_info) const;
    void set_menu_bar(Menu menu_bar);
    Dom with_menu_bar(Menu menu_bar) const;
    void set_context_menu(Menu context_menu);
    Dom with_context_menu(Menu context_menu) const;
    size_t node_count() const;
    Dom with_component_css(Css css) const;
    void add_component_css(Css css);
    void set_component_css(CssVec css);
    Dom swap_with_default();
    Dom copy_except_for_root();
    Dom with_attribute(AzAttributeType attr) const;
    Dom with_attributes(AttributeTypeVec attributes) const;
    size_t fixup_children_estimated();
    Dom with_merge_callback(AzDatasetMergeCallbackType callback) const;
    Dom with_css(String style) const;
    Dom with_css_props(CssPropertyWithConditionsVec css_props) const;
    Dom with_node_type(AzNodeType node_type) const;
    void set_css(String style);
    void add_class(String class_);
    void add_callback(AzEventFilter event, RefAny data, AzCallbackType callback);
    void set_tab_index(AzTabIndex tab_index);
    void set_contenteditable(bool contenteditable);
    void delete_();
    Dom clone() const;
    bool partialEq(const Dom& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const Dom& b) const;
    uint8_t cmp(const Dom& b) const;
    String toDbgString() const;

    const AzDom& inner() const { return inner_; }
    AzDom& inner() { return inner_; }
    const AzDom* ptr() const { return &inner_; }
    AzDom* ptr() { return &inner_; }
    AzDom release() { AzDom result = inner_; inner_ = {}; return result; }
    operator AzDom() && noexcept { AzDom result = inner_; inner_ = {}; return result; }
};

class SystemStyle {
private:
    AzSystemStyle inner_;

    SystemStyle(const SystemStyle&) = delete;
    SystemStyle& operator=(const SystemStyle&) = delete;

public:
    explicit SystemStyle(AzSystemStyle inner) noexcept : inner_(inner) {}

    SystemStyle(SystemStyle&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    SystemStyle& operator=(SystemStyle&& other) noexcept {
        if (this != &other) {
            AzSystemStyle_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~SystemStyle() { AzSystemStyle_delete(&inner_); }

    [[nodiscard]] static SystemStyle detect();
    [[nodiscard]] static SystemStyle default_();

    Css create_csd_stylesheet() const;
    void delete_();
    SystemStyle clone() const;
    bool partialEq(const SystemStyle& b) const;
    String toDbgString() const;

    const AzSystemStyle& inner() const { return inner_; }
    AzSystemStyle& inner() { return inner_; }
    const AzSystemStyle* ptr() const { return &inner_; }
    AzSystemStyle* ptr() { return &inner_; }
    AzSystemStyle release() { AzSystemStyle result = inner_; inner_ = {}; return result; }
    operator AzSystemStyle() && noexcept { AzSystemStyle result = inner_; inner_ = {}; return result; }
};

class CssStyleBorderRadiusParseErrorOwned {
private:
    AzCssStyleBorderRadiusParseErrorOwned inner_;

    CssStyleBorderRadiusParseErrorOwned(const CssStyleBorderRadiusParseErrorOwned&) = delete;
    CssStyleBorderRadiusParseErrorOwned& operator=(const CssStyleBorderRadiusParseErrorOwned&) = delete;

public:
    explicit CssStyleBorderRadiusParseErrorOwned(AzCssStyleBorderRadiusParseErrorOwned inner) noexcept : inner_(inner) {}

    CssStyleBorderRadiusParseErrorOwned(CssStyleBorderRadiusParseErrorOwned&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssStyleBorderRadiusParseErrorOwned& operator=(CssStyleBorderRadiusParseErrorOwned&& other) noexcept {
        if (this != &other) {
            AzCssStyleBorderRadiusParseErrorOwned_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssStyleBorderRadiusParseErrorOwned() { AzCssStyleBorderRadiusParseErrorOwned_delete(&inner_); }

    void delete_();
    CssStyleBorderRadiusParseErrorOwned clone() const;
    bool partialEq(const CssStyleBorderRadiusParseErrorOwned& b) const;
    String toDbgString() const;

    const AzCssStyleBorderRadiusParseErrorOwned& inner() const { return inner_; }
    AzCssStyleBorderRadiusParseErrorOwned& inner() { return inner_; }
    const AzCssStyleBorderRadiusParseErrorOwned* ptr() const { return &inner_; }
    AzCssStyleBorderRadiusParseErrorOwned* ptr() { return &inner_; }
    AzCssStyleBorderRadiusParseErrorOwned release() { AzCssStyleBorderRadiusParseErrorOwned result = inner_; inner_ = {}; return result; }
    operator AzCssStyleBorderRadiusParseErrorOwned() && noexcept { AzCssStyleBorderRadiusParseErrorOwned result = inner_; inner_ = {}; return result; }
};

class FileInput {
private:
    AzFileInput inner_;

    FileInput(const FileInput&) = delete;
    FileInput& operator=(const FileInput&) = delete;

public:
    explicit FileInput(AzFileInput inner) noexcept : inner_(inner) {}

    FileInput(FileInput&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FileInput& operator=(FileInput&& other) noexcept {
        if (this != &other) {
            AzFileInput_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FileInput() { AzFileInput_delete(&inner_); }

    [[nodiscard]] static FileInput create(OptionString path);
    [[nodiscard]] static FileInput default_();

    void set_default_text(String default_text);
    FileInput with_default_text(String default_text) const;
    void set_on_path_change(RefAny data, AzFileInputOnPathChangeCallbackType callback);
    FileInput with_on_path_change(RefAny data, AzFileInputOnPathChangeCallbackType callback) const;
    Dom dom() const;
    void delete_();
    FileInput clone() const;
    bool partialEq(const FileInput& b) const;
    String toDbgString() const;

    const AzFileInput& inner() const { return inner_; }
    AzFileInput& inner() { return inner_; }
    const AzFileInput* ptr() const { return &inner_; }
    AzFileInput* ptr() { return &inner_; }
    AzFileInput release() { AzFileInput result = inner_; inner_ = {}; return result; }
    operator AzFileInput() && noexcept { AzFileInput result = inner_; inner_ = {}; return result; }
};

class CheckBox {
private:
    AzCheckBox inner_;

    CheckBox(const CheckBox&) = delete;
    CheckBox& operator=(const CheckBox&) = delete;

public:
    explicit CheckBox(AzCheckBox inner) noexcept : inner_(inner) {}

    CheckBox(CheckBox&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CheckBox& operator=(CheckBox&& other) noexcept {
        if (this != &other) {
            AzCheckBox_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CheckBox() { AzCheckBox_delete(&inner_); }

    [[nodiscard]] static CheckBox create(bool checked);

    void set_on_toggle(RefAny data, AzCheckBoxOnToggleCallbackType callback);
    CheckBox with_on_toggle(RefAny data, AzCheckBoxOnToggleCallbackType callback) const;
    Dom dom() const;
    void delete_();
    CheckBox clone() const;
    bool partialEq(const CheckBox& b) const;
    String toDbgString() const;

    const AzCheckBox& inner() const { return inner_; }
    AzCheckBox& inner() { return inner_; }
    const AzCheckBox* ptr() const { return &inner_; }
    AzCheckBox* ptr() { return &inner_; }
    AzCheckBox release() { AzCheckBox result = inner_; inner_ = {}; return result; }
    operator AzCheckBox() && noexcept { AzCheckBox result = inner_; inner_ = {}; return result; }
};

class ColorInput {
private:
    AzColorInput inner_;

    ColorInput(const ColorInput&) = delete;
    ColorInput& operator=(const ColorInput&) = delete;

public:
    explicit ColorInput(AzColorInput inner) noexcept : inner_(inner) {}

    ColorInput(ColorInput&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ColorInput& operator=(ColorInput&& other) noexcept {
        if (this != &other) {
            AzColorInput_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ColorInput() { AzColorInput_delete(&inner_); }

    [[nodiscard]] static ColorInput create(ColorU color);
    [[nodiscard]] static ColorInput default_();

    void set_on_value_change(RefAny data, AzColorInputOnValueChangeCallbackType callback);
    ColorInput with_on_value_change(RefAny data, AzColorInputOnValueChangeCallbackType callback) const;
    Dom dom() const;
    void delete_();
    ColorInput clone() const;
    bool partialEq(const ColorInput& b) const;
    String toDbgString() const;

    const AzColorInput& inner() const { return inner_; }
    AzColorInput& inner() { return inner_; }
    const AzColorInput* ptr() const { return &inner_; }
    AzColorInput* ptr() { return &inner_; }
    AzColorInput release() { AzColorInput result = inner_; inner_ = {}; return result; }
    operator AzColorInput() && noexcept { AzColorInput result = inner_; inner_ = {}; return result; }
};

class TextInput {
private:
    AzTextInput inner_;

    TextInput(const TextInput&) = delete;
    TextInput& operator=(const TextInput&) = delete;

public:
    explicit TextInput(AzTextInput inner) noexcept : inner_(inner) {}

    TextInput(TextInput&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    TextInput& operator=(TextInput&& other) noexcept {
        if (this != &other) {
            AzTextInput_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~TextInput() { AzTextInput_delete(&inner_); }

    [[nodiscard]] static TextInput create();
    [[nodiscard]] static TextInput default_();

    void set_text(String text);
    TextInput with_text(String text) const;
    void set_placeholder(String text);
    TextInput with_placeholder(String text) const;
    void set_on_text_input(RefAny data, AzTextInputOnTextInputCallbackType callback);
    TextInput with_on_text_input(RefAny data, AzTextInputOnTextInputCallbackType callback) const;
    void set_on_virtual_key_down(RefAny data, AzTextInputOnVirtualKeyDownCallbackType callback);
    TextInput with_on_virtual_key_down(RefAny data, AzTextInputOnVirtualKeyDownCallbackType callback) const;
    void set_on_focus_lost(RefAny data, AzTextInputOnFocusLostCallbackType callback);
    TextInput with_on_focus_lost(RefAny data, AzTextInputOnFocusLostCallbackType callback) const;
    Dom dom() const;
    void delete_();
    TextInput clone() const;
    bool partialEq(const TextInput& b) const;
    String toDbgString() const;

    const AzTextInput& inner() const { return inner_; }
    AzTextInput& inner() { return inner_; }
    const AzTextInput* ptr() const { return &inner_; }
    AzTextInput* ptr() { return &inner_; }
    AzTextInput release() { AzTextInput result = inner_; inner_ = {}; return result; }
    operator AzTextInput() && noexcept { AzTextInput result = inner_; inner_ = {}; return result; }
};

class ComponentDataField {
private:
    AzComponentDataField inner_;

    ComponentDataField(const ComponentDataField&) = delete;
    ComponentDataField& operator=(const ComponentDataField&) = delete;

public:
    explicit ComponentDataField(AzComponentDataField inner) noexcept : inner_(inner) {}

    ComponentDataField(ComponentDataField&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ComponentDataField& operator=(ComponentDataField&& other) noexcept {
        if (this != &other) {
            AzComponentDataField_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ComponentDataField() { AzComponentDataField_delete(&inner_); }

    void delete_();
    ComponentDataField clone() const;
    bool partialEq(const ComponentDataField& b) const;
    String toDbgString() const;

    const AzComponentDataField& inner() const { return inner_; }
    AzComponentDataField& inner() { return inner_; }
    const AzComponentDataField* ptr() const { return &inner_; }
    AzComponentDataField* ptr() { return &inner_; }
    AzComponentDataField release() { AzComponentDataField result = inner_; inner_ = {}; return result; }
    operator AzComponentDataField() && noexcept { AzComponentDataField result = inner_; inner_ = {}; return result; }
};

class FullWindowState {
private:
    AzFullWindowState inner_;

    FullWindowState(const FullWindowState&) = delete;
    FullWindowState& operator=(const FullWindowState&) = delete;

public:
    explicit FullWindowState(AzFullWindowState inner) noexcept : inner_(inner) {}

    FullWindowState(FullWindowState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    FullWindowState& operator=(FullWindowState&& other) noexcept {
        if (this != &other) {
            AzFullWindowState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~FullWindowState() { AzFullWindowState_delete(&inner_); }

    [[nodiscard]] static FullWindowState default_();

    void delete_();
    FullWindowState clone() const;
    bool partialEq(const FullWindowState& b) const;
    String toDbgString() const;

    const AzFullWindowState& inner() const { return inner_; }
    AzFullWindowState& inner() { return inner_; }
    const AzFullWindowState* ptr() const { return &inner_; }
    AzFullWindowState* ptr() { return &inner_; }
    AzFullWindowState release() { AzFullWindowState result = inner_; inner_ = {}; return result; }
    operator AzFullWindowState() && noexcept { AzFullWindowState result = inner_; inner_ = {}; return result; }
};

class UndoableOperation {
private:
    AzUndoableOperation inner_;

    UndoableOperation(const UndoableOperation&) = delete;
    UndoableOperation& operator=(const UndoableOperation&) = delete;

public:
    explicit UndoableOperation(AzUndoableOperation inner) noexcept : inner_(inner) {}

    UndoableOperation(UndoableOperation&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    UndoableOperation& operator=(UndoableOperation&& other) noexcept {
        if (this != &other) {
            AzUndoableOperation_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~UndoableOperation() { AzUndoableOperation_delete(&inner_); }

    void delete_();
    UndoableOperation clone() const;
    String toDbgString() const;

    const AzUndoableOperation& inner() const { return inner_; }
    AzUndoableOperation& inner() { return inner_; }
    const AzUndoableOperation* ptr() const { return &inner_; }
    AzUndoableOperation* ptr() { return &inner_; }
    AzUndoableOperation release() { AzUndoableOperation result = inner_; inner_ = {}; return result; }
    operator AzUndoableOperation() && noexcept { AzUndoableOperation result = inner_; inner_ = {}; return result; }
};

class NumberInput {
private:
    AzNumberInput inner_;

    NumberInput(const NumberInput&) = delete;
    NumberInput& operator=(const NumberInput&) = delete;

public:
    explicit NumberInput(AzNumberInput inner) noexcept : inner_(inner) {}

    NumberInput(NumberInput&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    NumberInput& operator=(NumberInput&& other) noexcept {
        if (this != &other) {
            AzNumberInput_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~NumberInput() { AzNumberInput_delete(&inner_); }

    [[nodiscard]] static NumberInput create(float number);
    [[nodiscard]] static NumberInput default_();

    void set_on_text_input(RefAny data, AzTextInputOnTextInputCallbackType callback);
    NumberInput with_on_text_input(RefAny data, AzTextInputOnTextInputCallbackType callback) const;
    void set_on_virtual_key_down(RefAny data, AzTextInputOnVirtualKeyDownCallbackType callback);
    NumberInput with_on_virtual_key_down(RefAny data, AzTextInputOnVirtualKeyDownCallbackType callback) const;
    void set_on_focus_lost(RefAny data, AzNumberInputOnFocusLostCallbackType callback);
    NumberInput with_on_focus_lost(RefAny data, AzNumberInputOnFocusLostCallbackType callback) const;
    void set_on_value_change(RefAny data, AzNumberInputOnValueChangeCallbackType callback);
    NumberInput with_on_value_change(RefAny data, AzNumberInputOnValueChangeCallbackType callback) const;
    Dom dom() const;
    void delete_();
    NumberInput clone() const;
    bool partialEq(const NumberInput& b) const;
    String toDbgString() const;

    const AzNumberInput& inner() const { return inner_; }
    AzNumberInput& inner() { return inner_; }
    const AzNumberInput* ptr() const { return &inner_; }
    AzNumberInput* ptr() { return &inner_; }
    AzNumberInput release() { AzNumberInput result = inner_; inner_ = {}; return result; }
    operator AzNumberInput() && noexcept { AzNumberInput result = inner_; inner_ = {}; return result; }
};

class Frame {
private:
    AzFrame inner_;

    Frame(const Frame&) = delete;
    Frame& operator=(const Frame&) = delete;

public:
    explicit Frame(AzFrame inner) noexcept : inner_(inner) {}

    Frame(Frame&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Frame& operator=(Frame&& other) noexcept {
        if (this != &other) {
            AzFrame_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Frame() { AzFrame_delete(&inner_); }

    [[nodiscard]] static Frame create(String title, Dom dom);

    void set_flex_grow(float flex_grow);
    Frame with_flex_grow(float flex_grow) const;
    Dom dom() const;
    void delete_();
    Frame clone() const;
    String toDbgString() const;

    const AzFrame& inner() const { return inner_; }
    AzFrame& inner() { return inner_; }
    const AzFrame* ptr() const { return &inner_; }
    AzFrame* ptr() { return &inner_; }
    AzFrame release() { AzFrame result = inner_; inner_ = {}; return result; }
    operator AzFrame() && noexcept { AzFrame result = inner_; inner_ = {}; return result; }
};

class RibbonSection {
private:
    AzRibbonSection inner_;

    RibbonSection(const RibbonSection&) = delete;
    RibbonSection& operator=(const RibbonSection&) = delete;

public:
    explicit RibbonSection(AzRibbonSection inner) noexcept : inner_(inner) {}

    RibbonSection(RibbonSection&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    RibbonSection& operator=(RibbonSection&& other) noexcept {
        if (this != &other) {
            AzRibbonSection_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~RibbonSection() { AzRibbonSection_delete(&inner_); }

    [[nodiscard]] static RibbonSection new_(String title, Dom content);

    void delete_();
    RibbonSection clone() const;
    String toDbgString() const;

    const AzRibbonSection& inner() const { return inner_; }
    AzRibbonSection& inner() { return inner_; }
    const AzRibbonSection* ptr() const { return &inner_; }
    AzRibbonSection* ptr() { return &inner_; }
    AzRibbonSection release() { AzRibbonSection result = inner_; inner_ = {}; return result; }
    operator AzRibbonSection() && noexcept { AzRibbonSection result = inner_; inner_ = {}; return result; }
};

class AppConfig {
private:
    AzAppConfig inner_;

    AppConfig(const AppConfig&) = delete;
    AppConfig& operator=(const AppConfig&) = delete;

public:
    explicit AppConfig(AzAppConfig inner) noexcept : inner_(inner) {}

    AppConfig(AppConfig&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    AppConfig& operator=(AppConfig&& other) noexcept {
        if (this != &other) {
            AzAppConfig_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~AppConfig() { AzAppConfig_delete(&inner_); }

    [[nodiscard]] static AppConfig create();
    [[nodiscard]] static AppConfig default_();

    void delete_();
    AppConfig clone() const;
    String toDbgString() const;

    const AzAppConfig& inner() const { return inner_; }
    AzAppConfig& inner() { return inner_; }
    const AzAppConfig* ptr() const { return &inner_; }
    AzAppConfig* ptr() { return &inner_; }
    AzAppConfig release() { AzAppConfig result = inner_; inner_ = {}; return result; }
    operator AzAppConfig() && noexcept { AzAppConfig result = inner_; inner_ = {}; return result; }
};

class WindowCreateOptions {
private:
    AzWindowCreateOptions inner_;

    WindowCreateOptions(const WindowCreateOptions&) = delete;
    WindowCreateOptions& operator=(const WindowCreateOptions&) = delete;

public:
    explicit WindowCreateOptions(AzWindowCreateOptions inner) noexcept : inner_(inner) {}

    WindowCreateOptions(WindowCreateOptions&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    WindowCreateOptions& operator=(WindowCreateOptions&& other) noexcept {
        if (this != &other) {
            AzWindowCreateOptions_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~WindowCreateOptions() { AzWindowCreateOptions_delete(&inner_); }

    [[nodiscard]] static WindowCreateOptions create(AzLayoutCallbackType layout_callback);
    [[nodiscard]] static WindowCreateOptions default_();

    void delete_();
    WindowCreateOptions clone() const;
    bool partialEq(const WindowCreateOptions& b) const;
    String toDbgString() const;

    const AzWindowCreateOptions& inner() const { return inner_; }
    AzWindowCreateOptions& inner() { return inner_; }
    const AzWindowCreateOptions* ptr() const { return &inner_; }
    AzWindowCreateOptions* ptr() { return &inner_; }
    AzWindowCreateOptions release() { AzWindowCreateOptions result = inner_; inner_ = {}; return result; }
    operator AzWindowCreateOptions() && noexcept { AzWindowCreateOptions result = inner_; inner_ = {}; return result; }
};

class VirtualViewReturn {
private:
    AzVirtualViewReturn inner_;

    VirtualViewReturn(const VirtualViewReturn&) = delete;
    VirtualViewReturn& operator=(const VirtualViewReturn&) = delete;

public:
    explicit VirtualViewReturn(AzVirtualViewReturn inner) noexcept : inner_(inner) {}

    VirtualViewReturn(VirtualViewReturn&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    VirtualViewReturn& operator=(VirtualViewReturn&& other) noexcept {
        if (this != &other) {
            AzVirtualViewReturn_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~VirtualViewReturn() { AzVirtualViewReturn_delete(&inner_); }

    [[nodiscard]] static VirtualViewReturn with_dom(Dom dom, LogicalSize scroll_size, LogicalPosition scroll_offset, LogicalSize virtual_scroll_size, LogicalPosition virtual_scroll_offset);
    [[nodiscard]] static VirtualViewReturn keep_current(LogicalSize scroll_size, LogicalPosition scroll_offset, LogicalSize virtual_scroll_size, LogicalPosition virtual_scroll_offset);
    [[nodiscard]] static VirtualViewReturn default_();

    void delete_();
    VirtualViewReturn clone() const;
    bool partialEq(const VirtualViewReturn& b) const;
    String toDbgString() const;

    const AzVirtualViewReturn& inner() const { return inner_; }
    AzVirtualViewReturn& inner() { return inner_; }
    const AzVirtualViewReturn* ptr() const { return &inner_; }
    AzVirtualViewReturn* ptr() { return &inner_; }
    AzVirtualViewReturn release() { AzVirtualViewReturn result = inner_; inner_ = {}; return result; }
    operator AzVirtualViewReturn() && noexcept { AzVirtualViewReturn result = inner_; inner_ = {}; return result; }
};

class DynamicCssProperty {
private:
    AzDynamicCssProperty inner_;

    DynamicCssProperty(const DynamicCssProperty&) = delete;
    DynamicCssProperty& operator=(const DynamicCssProperty&) = delete;

public:
    explicit DynamicCssProperty(AzDynamicCssProperty inner) noexcept : inner_(inner) {}

    DynamicCssProperty(DynamicCssProperty&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    DynamicCssProperty& operator=(DynamicCssProperty&& other) noexcept {
        if (this != &other) {
            AzDynamicCssProperty_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~DynamicCssProperty() { AzDynamicCssProperty_delete(&inner_); }

    void delete_();
    DynamicCssProperty clone() const;
    bool partialEq(const DynamicCssProperty& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const DynamicCssProperty& b) const;
    uint8_t cmp(const DynamicCssProperty& b) const;
    String toDbgString() const;

    const AzDynamicCssProperty& inner() const { return inner_; }
    AzDynamicCssProperty& inner() { return inner_; }
    const AzDynamicCssProperty* ptr() const { return &inner_; }
    AzDynamicCssProperty* ptr() { return &inner_; }
    AzDynamicCssProperty release() { AzDynamicCssProperty result = inner_; inner_ = {}; return result; }
    operator AzDynamicCssProperty() && noexcept { AzDynamicCssProperty result = inner_; inner_ = {}; return result; }
};

class CssPropertyWithConditions {
private:
    AzCssPropertyWithConditions inner_;

    CssPropertyWithConditions(const CssPropertyWithConditions&) = delete;
    CssPropertyWithConditions& operator=(const CssPropertyWithConditions&) = delete;

public:
    explicit CssPropertyWithConditions(AzCssPropertyWithConditions inner) noexcept : inner_(inner) {}

    CssPropertyWithConditions(CssPropertyWithConditions&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssPropertyWithConditions& operator=(CssPropertyWithConditions&& other) noexcept {
        if (this != &other) {
            AzCssPropertyWithConditions_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssPropertyWithConditions() { AzCssPropertyWithConditions_delete(&inner_); }

    [[nodiscard]] static CssPropertyWithConditions simple(AzCssProperty property);
    [[nodiscard]] static CssPropertyWithConditions with_condition(AzCssProperty property, AzDynamicSelector condition);
    [[nodiscard]] static CssPropertyWithConditions with_conditions(AzCssProperty property, DynamicSelectorVec conditions);
    [[nodiscard]] static CssPropertyWithConditions on_hover(AzCssProperty property);
    [[nodiscard]] static CssPropertyWithConditions on_active(AzCssProperty property);
    [[nodiscard]] static CssPropertyWithConditions on_focus(AzCssProperty property);
    [[nodiscard]] static CssPropertyWithConditions when_disabled(AzCssProperty property);
    [[nodiscard]] static CssPropertyWithConditions on_os(AzCssProperty property, AzOsCondition os);
    [[nodiscard]] static CssPropertyWithConditions dark_theme(AzCssProperty property);
    [[nodiscard]] static CssPropertyWithConditions light_theme(AzCssProperty property);
    [[nodiscard]] static CssPropertyWithConditions on_windows(AzCssProperty property);
    [[nodiscard]] static CssPropertyWithConditions on_macos(AzCssProperty property);
    [[nodiscard]] static CssPropertyWithConditions on_linux(AzCssProperty property);

    bool is_conditional() const;
    bool is_pseudo_state_only() const;
    bool is_layout_affecting() const;
    void delete_();
    CssPropertyWithConditions clone() const;
    bool partialEq(const CssPropertyWithConditions& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const CssPropertyWithConditions& b) const;
    uint8_t cmp(const CssPropertyWithConditions& b) const;
    String toDbgString() const;

    const AzCssPropertyWithConditions& inner() const { return inner_; }
    AzCssPropertyWithConditions& inner() { return inner_; }
    const AzCssPropertyWithConditions* ptr() const { return &inner_; }
    AzCssPropertyWithConditions* ptr() { return &inner_; }
    AzCssPropertyWithConditions release() { AzCssPropertyWithConditions result = inner_; inner_ = {}; return result; }
    operator AzCssPropertyWithConditions() && noexcept { AzCssPropertyWithConditions result = inner_; inner_ = {}; return result; }
};

class CssBorderParseErrorOwned {
private:
    AzCssBorderParseErrorOwned inner_;

    CssBorderParseErrorOwned(const CssBorderParseErrorOwned&) = delete;
    CssBorderParseErrorOwned& operator=(const CssBorderParseErrorOwned&) = delete;

public:
    explicit CssBorderParseErrorOwned(AzCssBorderParseErrorOwned inner) noexcept : inner_(inner) {}

    CssBorderParseErrorOwned(CssBorderParseErrorOwned&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssBorderParseErrorOwned& operator=(CssBorderParseErrorOwned&& other) noexcept {
        if (this != &other) {
            AzCssBorderParseErrorOwned_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssBorderParseErrorOwned() { AzCssBorderParseErrorOwned_delete(&inner_); }

    void delete_();
    CssBorderParseErrorOwned clone() const;
    bool partialEq(const CssBorderParseErrorOwned& b) const;
    String toDbgString() const;

    const AzCssBorderParseErrorOwned& inner() const { return inner_; }
    AzCssBorderParseErrorOwned& inner() { return inner_; }
    const AzCssBorderParseErrorOwned* ptr() const { return &inner_; }
    AzCssBorderParseErrorOwned* ptr() { return &inner_; }
    AzCssBorderParseErrorOwned release() { AzCssBorderParseErrorOwned result = inner_; inner_ = {}; return result; }
    operator AzCssBorderParseErrorOwned() && noexcept { AzCssBorderParseErrorOwned result = inner_; inner_ = {}; return result; }
};

class CssParseErrorOwned {
private:
    AzCssParseErrorOwned inner_;

    CssParseErrorOwned(const CssParseErrorOwned&) = delete;
    CssParseErrorOwned& operator=(const CssParseErrorOwned&) = delete;

public:
    explicit CssParseErrorOwned(AzCssParseErrorOwned inner) noexcept : inner_(inner) {}

    CssParseErrorOwned(CssParseErrorOwned&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    CssParseErrorOwned& operator=(CssParseErrorOwned&& other) noexcept {
        if (this != &other) {
            AzCssParseErrorOwned_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~CssParseErrorOwned() { AzCssParseErrorOwned_delete(&inner_); }

    void delete_();
    CssParseErrorOwned clone() const;
    bool partialEq(const CssParseErrorOwned& b) const;
    String toDbgString() const;

    const AzCssParseErrorOwned& inner() const { return inner_; }
    AzCssParseErrorOwned& inner() { return inner_; }
    const AzCssParseErrorOwned* ptr() const { return &inner_; }
    AzCssParseErrorOwned* ptr() { return &inner_; }
    AzCssParseErrorOwned release() { AzCssParseErrorOwned result = inner_; inner_ = {}; return result; }
    operator AzCssParseErrorOwned() && noexcept { AzCssParseErrorOwned result = inner_; inner_ = {}; return result; }
};

class OptionI16 {
private:
    AzOptionI16 inner_;

public:
    OptionI16(AzOptionI16 inner) noexcept : inner_(inner) {}
    OptionI16(const OptionI16& other) noexcept : inner_(other.inner_) {}
    OptionI16& operator=(const OptionI16& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionI16() {}

    static OptionI16 none();
    static OptionI16 some(int16_t payload);
    bool partialEq(const OptionI16& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionI16& b) const;
    uint8_t cmp(const OptionI16& b) const;
    String toDbgString() const;

    const AzOptionI16& inner() const { return inner_; }
    AzOptionI16& inner() { return inner_; }
    const AzOptionI16* ptr() const { return &inner_; }
    AzOptionI16* ptr() { return &inner_; }
    AzOptionI16 release() { AzOptionI16 result = inner_; inner_ = {}; return result; }
    operator AzOptionI16() && noexcept { AzOptionI16 result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionI16_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionI16_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const int16_t& unwrap() const { return inner_.Some.payload; }
    int16_t& unwrap() { return inner_.Some.payload; }
    int16_t unwrapOr(const int16_t& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<int16_t> toStdOptional() const { return isSome() ? std::optional<int16_t>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<int16_t>() const { return toStdOptional(); }
};

class OptionU16 {
private:
    AzOptionU16 inner_;

public:
    OptionU16(AzOptionU16 inner) noexcept : inner_(inner) {}
    OptionU16(const OptionU16& other) noexcept : inner_(other.inner_) {}
    OptionU16& operator=(const OptionU16& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionU16() {}

    static OptionU16 none();
    static OptionU16 some(uint16_t payload);
    bool partialEq(const OptionU16& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionU16& b) const;
    uint8_t cmp(const OptionU16& b) const;
    String toDbgString() const;

    const AzOptionU16& inner() const { return inner_; }
    AzOptionU16& inner() { return inner_; }
    const AzOptionU16* ptr() const { return &inner_; }
    AzOptionU16* ptr() { return &inner_; }
    AzOptionU16 release() { AzOptionU16 result = inner_; inner_ = {}; return result; }
    operator AzOptionU16() && noexcept { AzOptionU16 result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionU16_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionU16_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const uint16_t& unwrap() const { return inner_.Some.payload; }
    uint16_t& unwrap() { return inner_.Some.payload; }
    uint16_t unwrapOr(const uint16_t& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<uint16_t> toStdOptional() const { return isSome() ? std::optional<uint16_t>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<uint16_t>() const { return toStdOptional(); }
};

class OptionU32 {
private:
    AzOptionU32 inner_;

public:
    OptionU32(AzOptionU32 inner) noexcept : inner_(inner) {}
    OptionU32(const OptionU32& other) noexcept : inner_(other.inner_) {}
    OptionU32& operator=(const OptionU32& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionU32() {}

    static OptionU32 none();
    static OptionU32 some(uint32_t payload);
    bool partialEq(const OptionU32& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionU32& b) const;
    uint8_t cmp(const OptionU32& b) const;
    String toDbgString() const;

    const AzOptionU32& inner() const { return inner_; }
    AzOptionU32& inner() { return inner_; }
    const AzOptionU32* ptr() const { return &inner_; }
    AzOptionU32* ptr() { return &inner_; }
    AzOptionU32 release() { AzOptionU32 result = inner_; inner_ = {}; return result; }
    operator AzOptionU32() && noexcept { AzOptionU32 result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionU32_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionU32_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const uint32_t& unwrap() const { return inner_.Some.payload; }
    uint32_t& unwrap() { return inner_.Some.payload; }
    uint32_t unwrapOr(const uint32_t& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<uint32_t> toStdOptional() const { return isSome() ? std::optional<uint32_t>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<uint32_t>() const { return toStdOptional(); }
};

class OptionUsize {
private:
    AzOptionUsize inner_;

public:
    OptionUsize(AzOptionUsize inner) noexcept : inner_(inner) {}
    OptionUsize(const OptionUsize& other) noexcept : inner_(other.inner_) {}
    OptionUsize& operator=(const OptionUsize& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionUsize() {}

    static OptionUsize none();
    static OptionUsize some(size_t payload);
    bool partialEq(const OptionUsize& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionUsize& b) const;
    uint8_t cmp(const OptionUsize& b) const;
    String toDbgString() const;

    const AzOptionUsize& inner() const { return inner_; }
    AzOptionUsize& inner() { return inner_; }
    const AzOptionUsize* ptr() const { return &inner_; }
    AzOptionUsize* ptr() { return &inner_; }
    AzOptionUsize release() { AzOptionUsize result = inner_; inner_ = {}; return result; }
    operator AzOptionUsize() && noexcept { AzOptionUsize result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionUsize_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionUsize_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const size_t& unwrap() const { return inner_.Some.payload; }
    size_t& unwrap() { return inner_.Some.payload; }
    size_t unwrapOr(const size_t& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<size_t> toStdOptional() const { return isSome() ? std::optional<size_t>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<size_t>() const { return toStdOptional(); }
};

class OptionF32 {
private:
    AzOptionF32 inner_;

public:
    OptionF32(AzOptionF32 inner) noexcept : inner_(inner) {}
    OptionF32(const OptionF32& other) noexcept : inner_(other.inner_) {}
    OptionF32& operator=(const OptionF32& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionF32() {}

    static OptionF32 none();
    static OptionF32 some(float payload);
    bool partialEq(const OptionF32& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionF32& b) const;
    uint8_t cmp(const OptionF32& b) const;
    String toDbgString() const;

    const AzOptionF32& inner() const { return inner_; }
    AzOptionF32& inner() { return inner_; }
    const AzOptionF32* ptr() const { return &inner_; }
    AzOptionF32* ptr() { return &inner_; }
    AzOptionF32 release() { AzOptionF32 result = inner_; inner_ = {}; return result; }
    operator AzOptionF32() && noexcept { AzOptionF32 result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionF32_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionF32_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const float& unwrap() const { return inner_.Some.payload; }
    float& unwrap() { return inner_.Some.payload; }
    float unwrapOr(const float& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<float> toStdOptional() const { return isSome() ? std::optional<float>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<float>() const { return toStdOptional(); }
};

class OptionF64 {
private:
    AzOptionF64 inner_;

public:
    OptionF64(AzOptionF64 inner) noexcept : inner_(inner) {}
    OptionF64(const OptionF64& other) noexcept : inner_(other.inner_) {}
    OptionF64& operator=(const OptionF64& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionF64() {}

    static OptionF64 none();
    static OptionF64 some(double payload);
    bool partialEq(const OptionF64& b) const;
    uint8_t partialCmp(const OptionF64& b) const;
    String toDbgString() const;

    const AzOptionF64& inner() const { return inner_; }
    AzOptionF64& inner() { return inner_; }
    const AzOptionF64* ptr() const { return &inner_; }
    AzOptionF64* ptr() { return &inner_; }
    AzOptionF64 release() { AzOptionF64 result = inner_; inner_ = {}; return result; }
    operator AzOptionF64() && noexcept { AzOptionF64 result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionF64_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionF64_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const double& unwrap() const { return inner_.Some.payload; }
    double& unwrap() { return inner_.Some.payload; }
    double unwrapOr(const double& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<double> toStdOptional() const { return isSome() ? std::optional<double>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<double>() const { return toStdOptional(); }
};

class OptionBool {
private:
    AzOptionBool inner_;

public:
    OptionBool(AzOptionBool inner) noexcept : inner_(inner) {}
    OptionBool(const OptionBool& other) noexcept : inner_(other.inner_) {}
    OptionBool& operator=(const OptionBool& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionBool() {}

    static OptionBool none();
    static OptionBool some(bool payload);
    bool partialEq(const OptionBool& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionBool& b) const;
    uint8_t cmp(const OptionBool& b) const;
    String toDbgString() const;

    const AzOptionBool& inner() const { return inner_; }
    AzOptionBool& inner() { return inner_; }
    const AzOptionBool* ptr() const { return &inner_; }
    AzOptionBool* ptr() { return &inner_; }
    AzOptionBool release() { AzOptionBool result = inner_; inner_ = {}; return result; }
    operator AzOptionBool() && noexcept { AzOptionBool result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionBool_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionBool_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const bool& unwrap() const { return inner_.Some.payload; }
    bool& unwrap() { return inner_.Some.payload; }
    bool unwrapOr(const bool& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<bool> toStdOptional() const { return isSome() ? std::optional<bool>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<bool>() const { return toStdOptional(); }
};

class OptionI64 {
private:
    AzOptionI64 inner_;

public:
    OptionI64(AzOptionI64 inner) noexcept : inner_(inner) {}
    OptionI64(const OptionI64& other) noexcept : inner_(other.inner_) {}
    OptionI64& operator=(const OptionI64& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionI64() {}

    static OptionI64 none();
    static OptionI64 some(int64_t payload);
    bool partialEq(const OptionI64& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionI64& b) const;
    uint8_t cmp(const OptionI64& b) const;
    String toDbgString() const;

    const AzOptionI64& inner() const { return inner_; }
    AzOptionI64& inner() { return inner_; }
    const AzOptionI64* ptr() const { return &inner_; }
    AzOptionI64* ptr() { return &inner_; }
    AzOptionI64 release() { AzOptionI64 result = inner_; inner_ = {}; return result; }
    operator AzOptionI64() && noexcept { AzOptionI64 result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionI64_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionI64_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const int64_t& unwrap() const { return inner_.Some.payload; }
    int64_t& unwrap() { return inner_.Some.payload; }
    int64_t unwrapOr(const int64_t& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<int64_t> toStdOptional() const { return isSome() ? std::optional<int64_t>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<int64_t>() const { return toStdOptional(); }
};

class OptionI32 {
private:
    AzOptionI32 inner_;

public:
    OptionI32(AzOptionI32 inner) noexcept : inner_(inner) {}
    OptionI32(const OptionI32& other) noexcept : inner_(other.inner_) {}
    OptionI32& operator=(const OptionI32& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionI32() {}

    static OptionI32 none();
    static OptionI32 some(int32_t payload);
    bool partialEq(const OptionI32& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionI32& b) const;
    uint8_t cmp(const OptionI32& b) const;
    String toDbgString() const;

    const AzOptionI32& inner() const { return inner_; }
    AzOptionI32& inner() { return inner_; }
    const AzOptionI32* ptr() const { return &inner_; }
    AzOptionI32* ptr() { return &inner_; }
    AzOptionI32 release() { AzOptionI32 result = inner_; inner_ = {}; return result; }
    operator AzOptionI32() && noexcept { AzOptionI32 result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionI32_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionI32_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const int32_t& unwrap() const { return inner_.Some.payload; }
    int32_t& unwrap() { return inner_.Some.payload; }
    int32_t unwrapOr(const int32_t& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<int32_t> toStdOptional() const { return isSome() ? std::optional<int32_t>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<int32_t>() const { return toStdOptional(); }
};

class OptionU64 {
private:
    AzOptionU64 inner_;

public:
    OptionU64(AzOptionU64 inner) noexcept : inner_(inner) {}
    OptionU64(const OptionU64& other) noexcept : inner_(other.inner_) {}
    OptionU64& operator=(const OptionU64& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionU64() {}

    static OptionU64 none();
    static OptionU64 some(uint64_t payload);
    bool partialEq(const OptionU64& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionU64& b) const;
    uint8_t cmp(const OptionU64& b) const;
    String toDbgString() const;

    const AzOptionU64& inner() const { return inner_; }
    AzOptionU64& inner() { return inner_; }
    const AzOptionU64* ptr() const { return &inner_; }
    AzOptionU64* ptr() { return &inner_; }
    AzOptionU64 release() { AzOptionU64 result = inner_; inner_ = {}; return result; }
    operator AzOptionU64() && noexcept { AzOptionU64 result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionU64_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionU64_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const uint64_t& unwrap() const { return inner_.Some.payload; }
    uint64_t& unwrap() { return inner_.Some.payload; }
    uint64_t unwrapOr(const uint64_t& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<uint64_t> toStdOptional() const { return isSome() ? std::optional<uint64_t>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<uint64_t>() const { return toStdOptional(); }
};

class OptionU8 {
private:
    AzOptionU8 inner_;

public:
    OptionU8(AzOptionU8 inner) noexcept : inner_(inner) {}
    OptionU8(const OptionU8& other) noexcept : inner_(other.inner_) {}
    OptionU8& operator=(const OptionU8& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionU8() {}

    static OptionU8 none();
    static OptionU8 some(uint8_t payload);
    bool partialEq(const OptionU8& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionU8& b) const;
    uint8_t cmp(const OptionU8& b) const;
    String toDbgString() const;

    const AzOptionU8& inner() const { return inner_; }
    AzOptionU8& inner() { return inner_; }
    const AzOptionU8* ptr() const { return &inner_; }
    AzOptionU8* ptr() { return &inner_; }
    AzOptionU8 release() { AzOptionU8 result = inner_; inner_ = {}; return result; }
    operator AzOptionU8() && noexcept { AzOptionU8 result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionU8_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionU8_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const uint8_t& unwrap() const { return inner_.Some.payload; }
    uint8_t& unwrap() { return inner_.Some.payload; }
    uint8_t unwrapOr(const uint8_t& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<uint8_t> toStdOptional() const { return isSome() ? std::optional<uint8_t>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<uint8_t>() const { return toStdOptional(); }
};

class OptionTimerId {
private:
    AzOptionTimerId inner_;

public:
    OptionTimerId(AzOptionTimerId inner) noexcept : inner_(inner) {}
    OptionTimerId(const OptionTimerId& other) noexcept : inner_(other.inner_) {}
    OptionTimerId& operator=(const OptionTimerId& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionTimerId() {}

    static OptionTimerId none();
    static OptionTimerId some(TimerId payload);
    bool partialEq(const OptionTimerId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionTimerId& b) const;
    uint8_t cmp(const OptionTimerId& b) const;
    String toDbgString() const;

    const AzOptionTimerId& inner() const { return inner_; }
    AzOptionTimerId& inner() { return inner_; }
    const AzOptionTimerId* ptr() const { return &inner_; }
    AzOptionTimerId* ptr() { return &inner_; }
    AzOptionTimerId release() { AzOptionTimerId result = inner_; inner_ = {}; return result; }
    operator AzOptionTimerId() && noexcept { AzOptionTimerId result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTimerId_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTimerId_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTimerId& unwrap() const { return inner_.Some.payload; }
    AzTimerId& unwrap() { return inner_.Some.payload; }
    AzTimerId unwrapOr(const AzTimerId& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTimerId> toStdOptional() const { return isSome() ? std::optional<AzTimerId>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTimerId>() const { return toStdOptional(); }
};

class OptionThread {
private:
    AzOptionThread inner_;

    OptionThread(const OptionThread&) = delete;
    OptionThread& operator=(const OptionThread&) = delete;

public:
    explicit OptionThread(AzOptionThread inner) noexcept : inner_(inner) {}

    OptionThread(OptionThread&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionThread& operator=(OptionThread&& other) noexcept {
        if (this != &other) {
            AzOptionThread_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionThread() { AzOptionThread_delete(&inner_); }

    static OptionThread none();
    static OptionThread some(Thread payload);
    void delete_();
    OptionThread clone() const;
    String toDbgString() const;

    const AzOptionThread& inner() const { return inner_; }
    AzOptionThread& inner() { return inner_; }
    const AzOptionThread* ptr() const { return &inner_; }
    AzOptionThread* ptr() { return &inner_; }
    AzOptionThread release() { AzOptionThread result = inner_; inner_ = {}; return result; }
    operator AzOptionThread() && noexcept { AzOptionThread result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionThread_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionThread_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzThread& unwrap() const { return inner_.Some.payload; }
    AzThread& unwrap() { return inner_.Some.payload; }
    AzThread unwrapOr(const AzThread& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzThread> toStdOptional() const { return isSome() ? std::optional<AzThread>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzThread>() const { return toStdOptional(); }
};

class OptionImageRef {
private:
    AzOptionImageRef inner_;

    OptionImageRef(const OptionImageRef&) = delete;
    OptionImageRef& operator=(const OptionImageRef&) = delete;

public:
    explicit OptionImageRef(AzOptionImageRef inner) noexcept : inner_(inner) {}

    OptionImageRef(OptionImageRef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionImageRef& operator=(OptionImageRef&& other) noexcept {
        if (this != &other) {
            AzOptionImageRef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionImageRef() { AzOptionImageRef_delete(&inner_); }

    static OptionImageRef none();
    static OptionImageRef some(ImageRef payload);
    void delete_();
    OptionImageRef clone() const;
    bool partialEq(const OptionImageRef& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionImageRef& b) const;
    uint8_t cmp(const OptionImageRef& b) const;
    String toDbgString() const;

    const AzOptionImageRef& inner() const { return inner_; }
    AzOptionImageRef& inner() { return inner_; }
    const AzOptionImageRef* ptr() const { return &inner_; }
    AzOptionImageRef* ptr() { return &inner_; }
    AzOptionImageRef release() { AzOptionImageRef result = inner_; inner_ = {}; return result; }
    operator AzOptionImageRef() && noexcept { AzOptionImageRef result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionImageRef_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionImageRef_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzImageRef& unwrap() const { return inner_.Some.payload; }
    AzImageRef& unwrap() { return inner_.Some.payload; }
    AzImageRef unwrapOr(const AzImageRef& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzImageRef> toStdOptional() const { return isSome() ? std::optional<AzImageRef>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzImageRef>() const { return toStdOptional(); }
};

class OptionLayoutSize {
private:
    AzOptionLayoutSize inner_;

public:
    OptionLayoutSize(AzOptionLayoutSize inner) noexcept : inner_(inner) {}
    OptionLayoutSize(const OptionLayoutSize& other) noexcept : inner_(other.inner_) {}
    OptionLayoutSize& operator=(const OptionLayoutSize& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionLayoutSize() {}

    static OptionLayoutSize none();
    static OptionLayoutSize some(LayoutSize payload);
    bool partialEq(const OptionLayoutSize& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionLayoutSize& b) const;
    uint8_t cmp(const OptionLayoutSize& b) const;
    String toDbgString() const;

    const AzOptionLayoutSize& inner() const { return inner_; }
    AzOptionLayoutSize& inner() { return inner_; }
    const AzOptionLayoutSize* ptr() const { return &inner_; }
    AzOptionLayoutSize* ptr() { return &inner_; }
    AzOptionLayoutSize release() { AzOptionLayoutSize result = inner_; inner_ = {}; return result; }
    operator AzOptionLayoutSize() && noexcept { AzOptionLayoutSize result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionLayoutSize_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionLayoutSize_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzLayoutSize& unwrap() const { return inner_.Some.payload; }
    AzLayoutSize& unwrap() { return inner_.Some.payload; }
    AzLayoutSize unwrapOr(const AzLayoutSize& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzLayoutSize> toStdOptional() const { return isSome() ? std::optional<AzLayoutSize>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzLayoutSize>() const { return toStdOptional(); }
};

class OptionColorU {
private:
    AzOptionColorU inner_;

public:
    OptionColorU(AzOptionColorU inner) noexcept : inner_(inner) {}
    OptionColorU(const OptionColorU& other) noexcept : inner_(other.inner_) {}
    OptionColorU& operator=(const OptionColorU& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionColorU() {}

    static OptionColorU none();
    static OptionColorU some(ColorU payload);
    bool partialEq(const OptionColorU& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionColorU& b) const;
    uint8_t cmp(const OptionColorU& b) const;
    String toDbgString() const;

    const AzOptionColorU& inner() const { return inner_; }
    AzOptionColorU& inner() { return inner_; }
    const AzOptionColorU* ptr() const { return &inner_; }
    AzOptionColorU* ptr() { return &inner_; }
    AzOptionColorU release() { AzOptionColorU result = inner_; inner_ = {}; return result; }
    operator AzOptionColorU() && noexcept { AzOptionColorU result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionColorU_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionColorU_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzColorU& unwrap() const { return inner_.Some.payload; }
    AzColorU& unwrap() { return inner_.Some.payload; }
    AzColorU unwrapOr(const AzColorU& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzColorU> toStdOptional() const { return isSome() ? std::optional<AzColorU>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzColorU>() const { return toStdOptional(); }
};

class OptionTabIndex {
private:
    AzOptionTabIndex inner_;

public:
    OptionTabIndex(AzOptionTabIndex inner) noexcept : inner_(inner) {}
    OptionTabIndex(const OptionTabIndex& other) noexcept : inner_(other.inner_) {}
    OptionTabIndex& operator=(const OptionTabIndex& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionTabIndex() {}

    static OptionTabIndex none();
    static OptionTabIndex some(AzTabIndex payload);
    bool partialEq(const OptionTabIndex& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionTabIndex& b) const;
    uint8_t cmp(const OptionTabIndex& b) const;
    String toDbgString() const;

    const AzOptionTabIndex& inner() const { return inner_; }
    AzOptionTabIndex& inner() { return inner_; }
    const AzOptionTabIndex* ptr() const { return &inner_; }
    AzOptionTabIndex* ptr() { return &inner_; }
    AzOptionTabIndex release() { AzOptionTabIndex result = inner_; inner_ = {}; return result; }
    operator AzOptionTabIndex() && noexcept { AzOptionTabIndex result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTabIndex_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTabIndex_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTabIndex& unwrap() const { return inner_.Some.payload; }
    AzTabIndex& unwrap() { return inner_.Some.payload; }
    AzTabIndex unwrapOr(const AzTabIndex& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTabIndex> toStdOptional() const { return isSome() ? std::optional<AzTabIndex>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTabIndex>() const { return toStdOptional(); }
};

class OptionLogicalPosition {
private:
    AzOptionLogicalPosition inner_;

public:
    OptionLogicalPosition(AzOptionLogicalPosition inner) noexcept : inner_(inner) {}
    OptionLogicalPosition(const OptionLogicalPosition& other) noexcept : inner_(other.inner_) {}
    OptionLogicalPosition& operator=(const OptionLogicalPosition& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionLogicalPosition() {}

    static OptionLogicalPosition none();
    static OptionLogicalPosition some(LogicalPosition payload);
    bool partialEq(const OptionLogicalPosition& b) const;
    uint8_t partialCmp(const OptionLogicalPosition& b) const;
    String toDbgString() const;

    const AzOptionLogicalPosition& inner() const { return inner_; }
    AzOptionLogicalPosition& inner() { return inner_; }
    const AzOptionLogicalPosition* ptr() const { return &inner_; }
    AzOptionLogicalPosition* ptr() { return &inner_; }
    AzOptionLogicalPosition release() { AzOptionLogicalPosition result = inner_; inner_ = {}; return result; }
    operator AzOptionLogicalPosition() && noexcept { AzOptionLogicalPosition result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionLogicalPosition_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionLogicalPosition_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzLogicalPosition& unwrap() const { return inner_.Some.payload; }
    AzLogicalPosition& unwrap() { return inner_.Some.payload; }
    AzLogicalPosition unwrapOr(const AzLogicalPosition& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzLogicalPosition> toStdOptional() const { return isSome() ? std::optional<AzLogicalPosition>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzLogicalPosition>() const { return toStdOptional(); }
};

class OptionScreenPosition {
private:
    AzOptionScreenPosition inner_;

public:
    OptionScreenPosition(AzOptionScreenPosition inner) noexcept : inner_(inner) {}
    OptionScreenPosition(const OptionScreenPosition& other) noexcept : inner_(other.inner_) {}
    OptionScreenPosition& operator=(const OptionScreenPosition& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionScreenPosition() {}

    static OptionScreenPosition none();
    static OptionScreenPosition some(ScreenPosition payload);
    bool partialEq(const OptionScreenPosition& b) const;
    uint8_t partialCmp(const OptionScreenPosition& b) const;
    String toDbgString() const;

    const AzOptionScreenPosition& inner() const { return inner_; }
    AzOptionScreenPosition& inner() { return inner_; }
    const AzOptionScreenPosition* ptr() const { return &inner_; }
    AzOptionScreenPosition* ptr() { return &inner_; }
    AzOptionScreenPosition release() { AzOptionScreenPosition result = inner_; inner_ = {}; return result; }
    operator AzOptionScreenPosition() && noexcept { AzOptionScreenPosition result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionScreenPosition_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionScreenPosition_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzScreenPosition& unwrap() const { return inner_.Some.payload; }
    AzScreenPosition& unwrap() { return inner_.Some.payload; }
    AzScreenPosition unwrapOr(const AzScreenPosition& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzScreenPosition> toStdOptional() const { return isSome() ? std::optional<AzScreenPosition>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzScreenPosition>() const { return toStdOptional(); }
};

class OptionCursorNodePosition {
private:
    AzOptionCursorNodePosition inner_;

public:
    OptionCursorNodePosition(AzOptionCursorNodePosition inner) noexcept : inner_(inner) {}
    OptionCursorNodePosition(const OptionCursorNodePosition& other) noexcept : inner_(other.inner_) {}
    OptionCursorNodePosition& operator=(const OptionCursorNodePosition& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionCursorNodePosition() {}

    static OptionCursorNodePosition none();
    static OptionCursorNodePosition some(CursorNodePosition payload);
    bool partialEq(const OptionCursorNodePosition& b) const;
    uint8_t partialCmp(const OptionCursorNodePosition& b) const;
    String toDbgString() const;

    const AzOptionCursorNodePosition& inner() const { return inner_; }
    AzOptionCursorNodePosition& inner() { return inner_; }
    const AzOptionCursorNodePosition* ptr() const { return &inner_; }
    AzOptionCursorNodePosition* ptr() { return &inner_; }
    AzOptionCursorNodePosition release() { AzOptionCursorNodePosition result = inner_; inner_ = {}; return result; }
    operator AzOptionCursorNodePosition() && noexcept { AzOptionCursorNodePosition result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCursorNodePosition_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCursorNodePosition_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCursorNodePosition& unwrap() const { return inner_.Some.payload; }
    AzCursorNodePosition& unwrap() { return inner_.Some.payload; }
    AzCursorNodePosition unwrapOr(const AzCursorNodePosition& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCursorNodePosition> toStdOptional() const { return isSome() ? std::optional<AzCursorNodePosition>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCursorNodePosition>() const { return toStdOptional(); }
};

class OptionDragDelta {
private:
    AzOptionDragDelta inner_;

public:
    OptionDragDelta(AzOptionDragDelta inner) noexcept : inner_(inner) {}
    OptionDragDelta(const OptionDragDelta& other) noexcept : inner_(other.inner_) {}
    OptionDragDelta& operator=(const OptionDragDelta& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionDragDelta() {}

    static OptionDragDelta none();
    static OptionDragDelta some(DragDelta payload);
    bool partialEq(const OptionDragDelta& b) const;
    uint8_t partialCmp(const OptionDragDelta& b) const;
    String toDbgString() const;

    const AzOptionDragDelta& inner() const { return inner_; }
    AzOptionDragDelta& inner() { return inner_; }
    const AzOptionDragDelta* ptr() const { return &inner_; }
    AzOptionDragDelta* ptr() { return &inner_; }
    AzOptionDragDelta release() { AzOptionDragDelta result = inner_; inner_ = {}; return result; }
    operator AzOptionDragDelta() && noexcept { AzOptionDragDelta result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDragDelta_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDragDelta_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDragDelta& unwrap() const { return inner_.Some.payload; }
    AzDragDelta& unwrap() { return inner_.Some.payload; }
    AzDragDelta unwrapOr(const AzDragDelta& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDragDelta> toStdOptional() const { return isSome() ? std::optional<AzDragDelta>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDragDelta>() const { return toStdOptional(); }
};

class OptionMouseCursorType {
private:
    AzOptionMouseCursorType inner_;

public:
    OptionMouseCursorType(AzOptionMouseCursorType inner) noexcept : inner_(inner) {}
    OptionMouseCursorType(const OptionMouseCursorType& other) noexcept : inner_(other.inner_) {}
    OptionMouseCursorType& operator=(const OptionMouseCursorType& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionMouseCursorType() {}

    static OptionMouseCursorType none();
    static OptionMouseCursorType some(AzMouseCursorType payload);
    bool partialEq(const OptionMouseCursorType& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionMouseCursorType& b) const;
    uint8_t cmp(const OptionMouseCursorType& b) const;
    String toDbgString() const;

    const AzOptionMouseCursorType& inner() const { return inner_; }
    AzOptionMouseCursorType& inner() { return inner_; }
    const AzOptionMouseCursorType* ptr() const { return &inner_; }
    AzOptionMouseCursorType* ptr() { return &inner_; }
    AzOptionMouseCursorType release() { AzOptionMouseCursorType result = inner_; inner_ = {}; return result; }
    operator AzOptionMouseCursorType() && noexcept { AzOptionMouseCursorType result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionMouseCursorType_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionMouseCursorType_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzMouseCursorType& unwrap() const { return inner_.Some.payload; }
    AzMouseCursorType& unwrap() { return inner_.Some.payload; }
    AzMouseCursorType unwrapOr(const AzMouseCursorType& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzMouseCursorType> toStdOptional() const { return isSome() ? std::optional<AzMouseCursorType>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzMouseCursorType>() const { return toStdOptional(); }
};

class OptionHwndHandle {
private:
    AzOptionHwndHandle inner_;

    OptionHwndHandle(const OptionHwndHandle&) = delete;
    OptionHwndHandle& operator=(const OptionHwndHandle&) = delete;

public:
    explicit OptionHwndHandle(AzOptionHwndHandle inner) noexcept : inner_(inner) {}

    OptionHwndHandle(OptionHwndHandle&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionHwndHandle& operator=(OptionHwndHandle&& other) noexcept {
        if (this != &other) {
            AzOptionHwndHandle_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionHwndHandle() { AzOptionHwndHandle_delete(&inner_); }

    static OptionHwndHandle none();
    static OptionHwndHandle some(AzHwndHandle payload);
    void delete_();
    OptionHwndHandle clone() const;
    bool partialEq(const OptionHwndHandle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionHwndHandle& b) const;
    uint8_t cmp(const OptionHwndHandle& b) const;
    String toDbgString() const;

    const AzOptionHwndHandle& inner() const { return inner_; }
    AzOptionHwndHandle& inner() { return inner_; }
    const AzOptionHwndHandle* ptr() const { return &inner_; }
    AzOptionHwndHandle* ptr() { return &inner_; }
    AzOptionHwndHandle release() { AzOptionHwndHandle result = inner_; inner_ = {}; return result; }
    operator AzOptionHwndHandle() && noexcept { AzOptionHwndHandle result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionHwndHandle_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionHwndHandle_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzHwndHandle& unwrap() const { return inner_.Some.payload; }
    AzHwndHandle& unwrap() { return inner_.Some.payload; }
    AzHwndHandle unwrapOr(const AzHwndHandle& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzHwndHandle> toStdOptional() const { return isSome() ? std::optional<AzHwndHandle>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzHwndHandle>() const { return toStdOptional(); }
};

class OptionLinuxDecorationsState {
private:
    AzOptionLinuxDecorationsState inner_;

public:
    OptionLinuxDecorationsState(AzOptionLinuxDecorationsState inner) noexcept : inner_(inner) {}
    OptionLinuxDecorationsState(const OptionLinuxDecorationsState& other) noexcept : inner_(other.inner_) {}
    OptionLinuxDecorationsState& operator=(const OptionLinuxDecorationsState& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionLinuxDecorationsState() {}

    static OptionLinuxDecorationsState none();
    static OptionLinuxDecorationsState some(LinuxDecorationsState payload);
    bool partialEq(const OptionLinuxDecorationsState& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionLinuxDecorationsState& b) const;
    uint8_t cmp(const OptionLinuxDecorationsState& b) const;
    String toDbgString() const;

    const AzOptionLinuxDecorationsState& inner() const { return inner_; }
    AzOptionLinuxDecorationsState& inner() { return inner_; }
    const AzOptionLinuxDecorationsState* ptr() const { return &inner_; }
    AzOptionLinuxDecorationsState* ptr() { return &inner_; }
    AzOptionLinuxDecorationsState release() { AzOptionLinuxDecorationsState result = inner_; inner_ = {}; return result; }
    operator AzOptionLinuxDecorationsState() && noexcept { AzOptionLinuxDecorationsState result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionLinuxDecorationsState_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionLinuxDecorationsState_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzLinuxDecorationsState& unwrap() const { return inner_.Some.payload; }
    AzLinuxDecorationsState& unwrap() { return inner_.Some.payload; }
    AzLinuxDecorationsState unwrapOr(const AzLinuxDecorationsState& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzLinuxDecorationsState> toStdOptional() const { return isSome() ? std::optional<AzLinuxDecorationsState>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzLinuxDecorationsState>() const { return toStdOptional(); }
};

class OptionLogicalSize {
private:
    AzOptionLogicalSize inner_;

public:
    OptionLogicalSize(AzOptionLogicalSize inner) noexcept : inner_(inner) {}
    OptionLogicalSize(const OptionLogicalSize& other) noexcept : inner_(other.inner_) {}
    OptionLogicalSize& operator=(const OptionLogicalSize& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionLogicalSize() {}

    static OptionLogicalSize none();
    static OptionLogicalSize some(LogicalSize payload);
    bool partialEq(const OptionLogicalSize& b) const;
    uint8_t partialCmp(const OptionLogicalSize& b) const;
    String toDbgString() const;

    const AzOptionLogicalSize& inner() const { return inner_; }
    AzOptionLogicalSize& inner() { return inner_; }
    const AzOptionLogicalSize* ptr() const { return &inner_; }
    AzOptionLogicalSize* ptr() { return &inner_; }
    AzOptionLogicalSize release() { AzOptionLogicalSize result = inner_; inner_ = {}; return result; }
    operator AzOptionLogicalSize() && noexcept { AzOptionLogicalSize result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionLogicalSize_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionLogicalSize_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzLogicalSize& unwrap() const { return inner_.Some.payload; }
    AzLogicalSize& unwrap() { return inner_.Some.payload; }
    AzLogicalSize unwrapOr(const AzLogicalSize& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzLogicalSize> toStdOptional() const { return isSome() ? std::optional<AzLogicalSize>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzLogicalSize>() const { return toStdOptional(); }
};

class OptionVirtualKeyCode {
private:
    AzOptionVirtualKeyCode inner_;

public:
    OptionVirtualKeyCode(AzOptionVirtualKeyCode inner) noexcept : inner_(inner) {}
    OptionVirtualKeyCode(const OptionVirtualKeyCode& other) noexcept : inner_(other.inner_) {}
    OptionVirtualKeyCode& operator=(const OptionVirtualKeyCode& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionVirtualKeyCode() {}

    static OptionVirtualKeyCode none();
    static OptionVirtualKeyCode some(AzVirtualKeyCode payload);
    bool partialEq(const OptionVirtualKeyCode& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionVirtualKeyCode& b) const;
    uint8_t cmp(const OptionVirtualKeyCode& b) const;
    String toDbgString() const;

    const AzOptionVirtualKeyCode& inner() const { return inner_; }
    AzOptionVirtualKeyCode& inner() { return inner_; }
    const AzOptionVirtualKeyCode* ptr() const { return &inner_; }
    AzOptionVirtualKeyCode* ptr() { return &inner_; }
    AzOptionVirtualKeyCode release() { AzOptionVirtualKeyCode result = inner_; inner_ = {}; return result; }
    operator AzOptionVirtualKeyCode() && noexcept { AzOptionVirtualKeyCode result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionVirtualKeyCode_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionVirtualKeyCode_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzVirtualKeyCode& unwrap() const { return inner_.Some.payload; }
    AzVirtualKeyCode& unwrap() { return inner_.Some.payload; }
    AzVirtualKeyCode unwrapOr(const AzVirtualKeyCode& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzVirtualKeyCode> toStdOptional() const { return isSome() ? std::optional<AzVirtualKeyCode>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzVirtualKeyCode>() const { return toStdOptional(); }
};

class OptionX11Visual {
private:
    AzOptionX11Visual inner_;

public:
    OptionX11Visual(AzOptionX11Visual inner) noexcept : inner_(inner) {}
    OptionX11Visual(const OptionX11Visual& other) noexcept : inner_(other.inner_) {}
    OptionX11Visual& operator=(const OptionX11Visual& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionX11Visual() {}

    static OptionX11Visual none();
    static OptionX11Visual some(AzX11Visual payload);
    bool partialEq(const OptionX11Visual& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionX11Visual& b) const;
    uint8_t cmp(const OptionX11Visual& b) const;
    String toDbgString() const;

    const AzOptionX11Visual& inner() const { return inner_; }
    AzOptionX11Visual& inner() { return inner_; }
    const AzOptionX11Visual* ptr() const { return &inner_; }
    AzOptionX11Visual* ptr() { return &inner_; }
    AzOptionX11Visual release() { AzOptionX11Visual result = inner_; inner_ = {}; return result; }
    operator AzOptionX11Visual() && noexcept { AzOptionX11Visual result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionX11Visual_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionX11Visual_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzX11Visual& unwrap() const { return inner_.Some.payload; }
    AzX11Visual& unwrap() { return inner_.Some.payload; }
    AzX11Visual unwrapOr(const AzX11Visual& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzX11Visual> toStdOptional() const { return isSome() ? std::optional<AzX11Visual>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzX11Visual>() const { return toStdOptional(); }
};

class OptionWindowTheme {
private:
    AzOptionWindowTheme inner_;

public:
    OptionWindowTheme(AzOptionWindowTheme inner) noexcept : inner_(inner) {}
    OptionWindowTheme(const OptionWindowTheme& other) noexcept : inner_(other.inner_) {}
    OptionWindowTheme& operator=(const OptionWindowTheme& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionWindowTheme() {}

    static OptionWindowTheme none();
    static OptionWindowTheme some(AzWindowTheme payload);
    bool partialEq(const OptionWindowTheme& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionWindowTheme& b) const;
    uint8_t cmp(const OptionWindowTheme& b) const;
    String toDbgString() const;

    const AzOptionWindowTheme& inner() const { return inner_; }
    AzOptionWindowTheme& inner() { return inner_; }
    const AzOptionWindowTheme* ptr() const { return &inner_; }
    AzOptionWindowTheme* ptr() { return &inner_; }
    AzOptionWindowTheme release() { AzOptionWindowTheme result = inner_; inner_ = {}; return result; }
    operator AzOptionWindowTheme() && noexcept { AzOptionWindowTheme result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionWindowTheme_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionWindowTheme_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzWindowTheme& unwrap() const { return inner_.Some.payload; }
    AzWindowTheme& unwrap() { return inner_.Some.payload; }
    AzWindowTheme unwrapOr(const AzWindowTheme& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzWindowTheme> toStdOptional() const { return isSome() ? std::optional<AzWindowTheme>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzWindowTheme>() const { return toStdOptional(); }
};

class OptionAccessibilityRole {
private:
    AzOptionAccessibilityRole inner_;

public:
    OptionAccessibilityRole(AzOptionAccessibilityRole inner) noexcept : inner_(inner) {}
    OptionAccessibilityRole(const OptionAccessibilityRole& other) noexcept : inner_(other.inner_) {}
    OptionAccessibilityRole& operator=(const OptionAccessibilityRole& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionAccessibilityRole() {}

    static OptionAccessibilityRole none();
    static OptionAccessibilityRole some(AzAccessibilityRole payload);
    bool partialEq(const OptionAccessibilityRole& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionAccessibilityRole& b) const;
    uint8_t cmp(const OptionAccessibilityRole& b) const;
    String toDbgString() const;

    const AzOptionAccessibilityRole& inner() const { return inner_; }
    AzOptionAccessibilityRole& inner() { return inner_; }
    const AzOptionAccessibilityRole* ptr() const { return &inner_; }
    AzOptionAccessibilityRole* ptr() { return &inner_; }
    AzOptionAccessibilityRole release() { AzOptionAccessibilityRole result = inner_; inner_ = {}; return result; }
    operator AzOptionAccessibilityRole() && noexcept { AzOptionAccessibilityRole result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionAccessibilityRole_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionAccessibilityRole_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzAccessibilityRole& unwrap() const { return inner_.Some.payload; }
    AzAccessibilityRole& unwrap() { return inner_.Some.payload; }
    AzAccessibilityRole unwrapOr(const AzAccessibilityRole& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzAccessibilityRole> toStdOptional() const { return isSome() ? std::optional<AzAccessibilityRole>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzAccessibilityRole>() const { return toStdOptional(); }
};

class OptionPenTilt {
private:
    AzOptionPenTilt inner_;

public:
    OptionPenTilt(AzOptionPenTilt inner) noexcept : inner_(inner) {}
    OptionPenTilt(const OptionPenTilt& other) noexcept : inner_(other.inner_) {}
    OptionPenTilt& operator=(const OptionPenTilt& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionPenTilt() {}

    static OptionPenTilt none();
    static OptionPenTilt some(PenTilt payload);
    bool partialEq(const OptionPenTilt& b) const;
    uint8_t partialCmp(const OptionPenTilt& b) const;
    String toDbgString() const;

    const AzOptionPenTilt& inner() const { return inner_; }
    AzOptionPenTilt& inner() { return inner_; }
    const AzOptionPenTilt* ptr() const { return &inner_; }
    AzOptionPenTilt* ptr() { return &inner_; }
    AzOptionPenTilt release() { AzOptionPenTilt result = inner_; inner_ = {}; return result; }
    operator AzOptionPenTilt() && noexcept { AzOptionPenTilt result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionPenTilt_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionPenTilt_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzPenTilt& unwrap() const { return inner_.Some.payload; }
    AzPenTilt& unwrap() { return inner_.Some.payload; }
    AzPenTilt unwrapOr(const AzPenTilt& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzPenTilt> toStdOptional() const { return isSome() ? std::optional<AzPenTilt>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzPenTilt>() const { return toStdOptional(); }
};

class OptionGestureDirection {
private:
    AzOptionGestureDirection inner_;

public:
    OptionGestureDirection(AzOptionGestureDirection inner) noexcept : inner_(inner) {}
    OptionGestureDirection(const OptionGestureDirection& other) noexcept : inner_(other.inner_) {}
    OptionGestureDirection& operator=(const OptionGestureDirection& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionGestureDirection() {}

    static OptionGestureDirection none();
    static OptionGestureDirection some(AzGestureDirection payload);
    bool partialEq(const OptionGestureDirection& b) const;
    String toDbgString() const;

    const AzOptionGestureDirection& inner() const { return inner_; }
    AzOptionGestureDirection& inner() { return inner_; }
    const AzOptionGestureDirection* ptr() const { return &inner_; }
    AzOptionGestureDirection* ptr() { return &inner_; }
    AzOptionGestureDirection release() { AzOptionGestureDirection result = inner_; inner_ = {}; return result; }
    operator AzOptionGestureDirection() && noexcept { AzOptionGestureDirection result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionGestureDirection_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionGestureDirection_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzGestureDirection& unwrap() const { return inner_.Some.payload; }
    AzGestureDirection& unwrap() { return inner_.Some.payload; }
    AzGestureDirection unwrapOr(const AzGestureDirection& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzGestureDirection> toStdOptional() const { return isSome() ? std::optional<AzGestureDirection>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzGestureDirection>() const { return toStdOptional(); }
};

class OptionThreadId {
private:
    AzOptionThreadId inner_;

public:
    OptionThreadId(AzOptionThreadId inner) noexcept : inner_(inner) {}
    OptionThreadId(const OptionThreadId& other) noexcept : inner_(other.inner_) {}
    OptionThreadId& operator=(const OptionThreadId& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionThreadId() {}

    static OptionThreadId none();
    static OptionThreadId some(ThreadId payload);
    bool partialEq(const OptionThreadId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionThreadId& b) const;
    uint8_t cmp(const OptionThreadId& b) const;
    String toDbgString() const;

    const AzOptionThreadId& inner() const { return inner_; }
    AzOptionThreadId& inner() { return inner_; }
    const AzOptionThreadId* ptr() const { return &inner_; }
    AzOptionThreadId* ptr() { return &inner_; }
    AzOptionThreadId release() { AzOptionThreadId result = inner_; inner_ = {}; return result; }
    operator AzOptionThreadId() && noexcept { AzOptionThreadId result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionThreadId_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionThreadId_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzThreadId& unwrap() const { return inner_.Some.payload; }
    AzThreadId& unwrap() { return inner_.Some.payload; }
    AzThreadId unwrapOr(const AzThreadId& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzThreadId> toStdOptional() const { return isSome() ? std::optional<AzThreadId>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzThreadId>() const { return toStdOptional(); }
};

class OptionDomId {
private:
    AzOptionDomId inner_;

public:
    OptionDomId(AzOptionDomId inner) noexcept : inner_(inner) {}
    OptionDomId(const OptionDomId& other) noexcept : inner_(other.inner_) {}
    OptionDomId& operator=(const OptionDomId& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionDomId() {}

    static OptionDomId none();
    static OptionDomId some(DomId payload);
    bool partialEq(const OptionDomId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionDomId& b) const;
    uint8_t cmp(const OptionDomId& b) const;
    String toDbgString() const;

    const AzOptionDomId& inner() const { return inner_; }
    AzOptionDomId& inner() { return inner_; }
    const AzOptionDomId* ptr() const { return &inner_; }
    AzOptionDomId* ptr() { return &inner_; }
    AzOptionDomId release() { AzOptionDomId result = inner_; inner_ = {}; return result; }
    operator AzOptionDomId() && noexcept { AzOptionDomId result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDomId_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDomId_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDomId& unwrap() const { return inner_.Some.payload; }
    AzDomId& unwrap() { return inner_.Some.payload; }
    AzDomId unwrapOr(const AzDomId& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDomId> toStdOptional() const { return isSome() ? std::optional<AzDomId>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDomId>() const { return toStdOptional(); }
};

class OptionAccessibilityState {
private:
    AzOptionAccessibilityState inner_;

public:
    OptionAccessibilityState(AzOptionAccessibilityState inner) noexcept : inner_(inner) {}
    OptionAccessibilityState(const OptionAccessibilityState& other) noexcept : inner_(other.inner_) {}
    OptionAccessibilityState& operator=(const OptionAccessibilityState& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionAccessibilityState() {}

    static OptionAccessibilityState none();
    static OptionAccessibilityState some(AzAccessibilityState payload);
    bool partialEq(const OptionAccessibilityState& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionAccessibilityState& b) const;
    uint8_t cmp(const OptionAccessibilityState& b) const;
    String toDbgString() const;

    const AzOptionAccessibilityState& inner() const { return inner_; }
    AzOptionAccessibilityState& inner() { return inner_; }
    const AzOptionAccessibilityState* ptr() const { return &inner_; }
    AzOptionAccessibilityState* ptr() { return &inner_; }
    AzOptionAccessibilityState release() { AzOptionAccessibilityState result = inner_; inner_ = {}; return result; }
    operator AzOptionAccessibilityState() && noexcept { AzOptionAccessibilityState result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionAccessibilityState_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionAccessibilityState_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzAccessibilityState& unwrap() const { return inner_.Some.payload; }
    AzAccessibilityState& unwrap() { return inner_.Some.payload; }
    AzAccessibilityState unwrapOr(const AzAccessibilityState& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzAccessibilityState> toStdOptional() const { return isSome() ? std::optional<AzAccessibilityState>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzAccessibilityState>() const { return toStdOptional(); }
};

class OptionSvgVertex {
private:
    AzOptionSvgVertex inner_;

public:
    OptionSvgVertex(AzOptionSvgVertex inner) noexcept : inner_(inner) {}
    OptionSvgVertex(const OptionSvgVertex& other) noexcept : inner_(other.inner_) {}
    OptionSvgVertex& operator=(const OptionSvgVertex& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionSvgVertex() {}

    static OptionSvgVertex none();
    static OptionSvgVertex some(SvgVertex payload);
    bool partialEq(const OptionSvgVertex& b) const;
    uint8_t partialCmp(const OptionSvgVertex& b) const;
    String toDbgString() const;

    const AzOptionSvgVertex& inner() const { return inner_; }
    AzOptionSvgVertex& inner() { return inner_; }
    const AzOptionSvgVertex* ptr() const { return &inner_; }
    AzOptionSvgVertex* ptr() { return &inner_; }
    AzOptionSvgVertex release() { AzOptionSvgVertex result = inner_; inner_ = {}; return result; }
    operator AzOptionSvgVertex() && noexcept { AzOptionSvgVertex result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionSvgVertex_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionSvgVertex_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzSvgVertex& unwrap() const { return inner_.Some.payload; }
    AzSvgVertex& unwrap() { return inner_.Some.payload; }
    AzSvgVertex unwrapOr(const AzSvgVertex& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzSvgVertex> toStdOptional() const { return isSome() ? std::optional<AzSvgVertex>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzSvgVertex>() const { return toStdOptional(); }
};

class OptionCascadeInfo {
private:
    AzOptionCascadeInfo inner_;

public:
    OptionCascadeInfo(AzOptionCascadeInfo inner) noexcept : inner_(inner) {}
    OptionCascadeInfo(const OptionCascadeInfo& other) noexcept : inner_(other.inner_) {}
    OptionCascadeInfo& operator=(const OptionCascadeInfo& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionCascadeInfo() {}

    static OptionCascadeInfo none();
    static OptionCascadeInfo some(CascadeInfo payload);
    bool partialEq(const OptionCascadeInfo& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionCascadeInfo& b) const;
    uint8_t cmp(const OptionCascadeInfo& b) const;
    String toDbgString() const;

    const AzOptionCascadeInfo& inner() const { return inner_; }
    AzOptionCascadeInfo& inner() { return inner_; }
    const AzOptionCascadeInfo* ptr() const { return &inner_; }
    AzOptionCascadeInfo* ptr() { return &inner_; }
    AzOptionCascadeInfo release() { AzOptionCascadeInfo result = inner_; inner_ = {}; return result; }
    operator AzOptionCascadeInfo() && noexcept { AzOptionCascadeInfo result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCascadeInfo_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCascadeInfo_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCascadeInfo& unwrap() const { return inner_.Some.payload; }
    AzCascadeInfo& unwrap() { return inner_.Some.payload; }
    AzCascadeInfo unwrapOr(const AzCascadeInfo& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCascadeInfo> toStdOptional() const { return isSome() ? std::optional<AzCascadeInfo>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCascadeInfo>() const { return toStdOptional(); }
};

class OptionNodeHierarchyItem {
private:
    AzOptionNodeHierarchyItem inner_;

public:
    OptionNodeHierarchyItem(AzOptionNodeHierarchyItem inner) noexcept : inner_(inner) {}
    OptionNodeHierarchyItem(const OptionNodeHierarchyItem& other) noexcept : inner_(other.inner_) {}
    OptionNodeHierarchyItem& operator=(const OptionNodeHierarchyItem& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionNodeHierarchyItem() {}

    static OptionNodeHierarchyItem none();
    static OptionNodeHierarchyItem some(NodeHierarchyItem payload);
    bool partialEq(const OptionNodeHierarchyItem& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionNodeHierarchyItem& b) const;
    uint8_t cmp(const OptionNodeHierarchyItem& b) const;
    String toDbgString() const;

    const AzOptionNodeHierarchyItem& inner() const { return inner_; }
    AzOptionNodeHierarchyItem& inner() { return inner_; }
    const AzOptionNodeHierarchyItem* ptr() const { return &inner_; }
    AzOptionNodeHierarchyItem* ptr() { return &inner_; }
    AzOptionNodeHierarchyItem release() { AzOptionNodeHierarchyItem result = inner_; inner_ = {}; return result; }
    operator AzOptionNodeHierarchyItem() && noexcept { AzOptionNodeHierarchyItem result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionNodeHierarchyItem_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionNodeHierarchyItem_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzNodeHierarchyItem& unwrap() const { return inner_.Some.payload; }
    AzNodeHierarchyItem& unwrap() { return inner_.Some.payload; }
    AzNodeHierarchyItem unwrapOr(const AzNodeHierarchyItem& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzNodeHierarchyItem> toStdOptional() const { return isSome() ? std::optional<AzNodeHierarchyItem>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzNodeHierarchyItem>() const { return toStdOptional(); }
};

class OptionXWindowType {
private:
    AzOptionXWindowType inner_;

public:
    OptionXWindowType(AzOptionXWindowType inner) noexcept : inner_(inner) {}
    OptionXWindowType(const OptionXWindowType& other) noexcept : inner_(other.inner_) {}
    OptionXWindowType& operator=(const OptionXWindowType& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionXWindowType() {}

    static OptionXWindowType none();
    static OptionXWindowType some(AzXWindowType payload);
    bool partialEq(const OptionXWindowType& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionXWindowType& b) const;
    uint8_t cmp(const OptionXWindowType& b) const;
    String toDbgString() const;

    const AzOptionXWindowType& inner() const { return inner_; }
    AzOptionXWindowType& inner() { return inner_; }
    const AzOptionXWindowType* ptr() const { return &inner_; }
    AzOptionXWindowType* ptr() { return &inner_; }
    AzOptionXWindowType release() { AzOptionXWindowType result = inner_; inner_ = {}; return result; }
    operator AzOptionXWindowType() && noexcept { AzOptionXWindowType result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionXWindowType_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionXWindowType_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzXWindowType& unwrap() const { return inner_.Some.payload; }
    AzXWindowType& unwrap() { return inner_.Some.payload; }
    AzXWindowType unwrapOr(const AzXWindowType& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzXWindowType> toStdOptional() const { return isSome() ? std::optional<AzXWindowType>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzXWindowType>() const { return toStdOptional(); }
};

class OptionStyleBackgroundRepeat {
private:
    AzOptionStyleBackgroundRepeat inner_;

public:
    OptionStyleBackgroundRepeat(AzOptionStyleBackgroundRepeat inner) noexcept : inner_(inner) {}
    OptionStyleBackgroundRepeat(const OptionStyleBackgroundRepeat& other) noexcept : inner_(other.inner_) {}
    OptionStyleBackgroundRepeat& operator=(const OptionStyleBackgroundRepeat& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionStyleBackgroundRepeat() {}

    static OptionStyleBackgroundRepeat none();
    static OptionStyleBackgroundRepeat some(AzStyleBackgroundRepeat payload);
    bool partialEq(const OptionStyleBackgroundRepeat& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionStyleBackgroundRepeat& b) const;
    uint8_t cmp(const OptionStyleBackgroundRepeat& b) const;
    String toDbgString() const;

    const AzOptionStyleBackgroundRepeat& inner() const { return inner_; }
    AzOptionStyleBackgroundRepeat& inner() { return inner_; }
    const AzOptionStyleBackgroundRepeat* ptr() const { return &inner_; }
    AzOptionStyleBackgroundRepeat* ptr() { return &inner_; }
    AzOptionStyleBackgroundRepeat release() { AzOptionStyleBackgroundRepeat result = inner_; inner_ = {}; return result; }
    operator AzOptionStyleBackgroundRepeat() && noexcept { AzOptionStyleBackgroundRepeat result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionStyleBackgroundRepeat_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionStyleBackgroundRepeat_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzStyleBackgroundRepeat& unwrap() const { return inner_.Some.payload; }
    AzStyleBackgroundRepeat& unwrap() { return inner_.Some.payload; }
    AzStyleBackgroundRepeat unwrapOr(const AzStyleBackgroundRepeat& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzStyleBackgroundRepeat> toStdOptional() const { return isSome() ? std::optional<AzStyleBackgroundRepeat>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzStyleBackgroundRepeat>() const { return toStdOptional(); }
};

class OptionShapePoint {
private:
    AzOptionShapePoint inner_;

public:
    OptionShapePoint(AzOptionShapePoint inner) noexcept : inner_(inner) {}
    OptionShapePoint(const OptionShapePoint& other) noexcept : inner_(other.inner_) {}
    OptionShapePoint& operator=(const OptionShapePoint& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionShapePoint() {}

    static OptionShapePoint none();
    static OptionShapePoint some(ShapePoint payload);
    bool partialEq(const OptionShapePoint& b) const;
    uint8_t partialCmp(const OptionShapePoint& b) const;
    String toDbgString() const;

    const AzOptionShapePoint& inner() const { return inner_; }
    AzOptionShapePoint& inner() { return inner_; }
    const AzOptionShapePoint* ptr() const { return &inner_; }
    AzOptionShapePoint* ptr() { return &inner_; }
    AzOptionShapePoint release() { AzOptionShapePoint result = inner_; inner_ = {}; return result; }
    operator AzOptionShapePoint() && noexcept { AzOptionShapePoint result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionShapePoint_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionShapePoint_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzShapePoint& unwrap() const { return inner_.Some.payload; }
    AzShapePoint& unwrap() { return inner_.Some.payload; }
    AzShapePoint unwrapOr(const AzShapePoint& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzShapePoint> toStdOptional() const { return isSome() ? std::optional<AzShapePoint>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzShapePoint>() const { return toStdOptional(); }
};

class OptionU8VecRef {
private:
    AzOptionU8VecRef inner_;

    OptionU8VecRef(const OptionU8VecRef&) = delete;
    OptionU8VecRef& operator=(const OptionU8VecRef&) = delete;

public:
    explicit OptionU8VecRef(AzOptionU8VecRef inner) noexcept : inner_(inner) {}

    OptionU8VecRef(OptionU8VecRef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionU8VecRef& operator=(OptionU8VecRef&& other) noexcept {
        if (this != &other) {
            AzOptionU8VecRef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionU8VecRef() { AzOptionU8VecRef_delete(&inner_); }

    static OptionU8VecRef none();
    static OptionU8VecRef some(U8VecRef payload);
    void delete_();
    OptionU8VecRef clone() const;
    bool partialEq(const OptionU8VecRef& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionU8VecRef& b) const;
    uint8_t cmp(const OptionU8VecRef& b) const;
    String toDbgString() const;

    const AzOptionU8VecRef& inner() const { return inner_; }
    AzOptionU8VecRef& inner() { return inner_; }
    const AzOptionU8VecRef* ptr() const { return &inner_; }
    AzOptionU8VecRef* ptr() { return &inner_; }
    AzOptionU8VecRef release() { AzOptionU8VecRef result = inner_; inner_ = {}; return result; }
    operator AzOptionU8VecRef() && noexcept { AzOptionU8VecRef result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionU8VecRef_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionU8VecRef_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzU8VecRef& unwrap() const { return inner_.Some.payload; }
    AzU8VecRef& unwrap() { return inner_.Some.payload; }
    AzU8VecRef unwrapOr(const AzU8VecRef& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzU8VecRef> toStdOptional() const { return isSome() ? std::optional<AzU8VecRef>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzU8VecRef>() const { return toStdOptional(); }
};

class OptionNodeHierarchyItemId {
private:
    AzOptionNodeHierarchyItemId inner_;

public:
    OptionNodeHierarchyItemId(AzOptionNodeHierarchyItemId inner) noexcept : inner_(inner) {}
    OptionNodeHierarchyItemId(const OptionNodeHierarchyItemId& other) noexcept : inner_(other.inner_) {}
    OptionNodeHierarchyItemId& operator=(const OptionNodeHierarchyItemId& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionNodeHierarchyItemId() {}

    static OptionNodeHierarchyItemId none();
    static OptionNodeHierarchyItemId some(NodeHierarchyItemId payload);
    bool partialEq(const OptionNodeHierarchyItemId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionNodeHierarchyItemId& b) const;
    uint8_t cmp(const OptionNodeHierarchyItemId& b) const;
    String toDbgString() const;

    const AzOptionNodeHierarchyItemId& inner() const { return inner_; }
    AzOptionNodeHierarchyItemId& inner() { return inner_; }
    const AzOptionNodeHierarchyItemId* ptr() const { return &inner_; }
    AzOptionNodeHierarchyItemId* ptr() { return &inner_; }
    AzOptionNodeHierarchyItemId release() { AzOptionNodeHierarchyItemId result = inner_; inner_ = {}; return result; }
    operator AzOptionNodeHierarchyItemId() && noexcept { AzOptionNodeHierarchyItemId result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionNodeHierarchyItemId_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionNodeHierarchyItemId_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzNodeHierarchyItemId& unwrap() const { return inner_.Some.payload; }
    AzNodeHierarchyItemId& unwrap() { return inner_.Some.payload; }
    AzNodeHierarchyItemId unwrapOr(const AzNodeHierarchyItemId& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzNodeHierarchyItemId> toStdOptional() const { return isSome() ? std::optional<AzNodeHierarchyItemId>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzNodeHierarchyItemId>() const { return toStdOptional(); }
};

class OptionLinuxDesktopEnv {
private:
    AzOptionLinuxDesktopEnv inner_;

public:
    OptionLinuxDesktopEnv(AzOptionLinuxDesktopEnv inner) noexcept : inner_(inner) {}
    OptionLinuxDesktopEnv(const OptionLinuxDesktopEnv& other) noexcept : inner_(other.inner_) {}
    OptionLinuxDesktopEnv& operator=(const OptionLinuxDesktopEnv& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionLinuxDesktopEnv() {}

    static OptionLinuxDesktopEnv none();
    static OptionLinuxDesktopEnv some(AzLinuxDesktopEnv payload);
    bool partialEq(const OptionLinuxDesktopEnv& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzOptionLinuxDesktopEnv& inner() const { return inner_; }
    AzOptionLinuxDesktopEnv& inner() { return inner_; }
    const AzOptionLinuxDesktopEnv* ptr() const { return &inner_; }
    AzOptionLinuxDesktopEnv* ptr() { return &inner_; }
    AzOptionLinuxDesktopEnv release() { AzOptionLinuxDesktopEnv result = inner_; inner_ = {}; return result; }
    operator AzOptionLinuxDesktopEnv() && noexcept { AzOptionLinuxDesktopEnv result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionLinuxDesktopEnv_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionLinuxDesktopEnv_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzLinuxDesktopEnv& unwrap() const { return inner_.Some.payload; }
    AzLinuxDesktopEnv& unwrap() { return inner_.Some.payload; }
    AzLinuxDesktopEnv unwrapOr(const AzLinuxDesktopEnv& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzLinuxDesktopEnv> toStdOptional() const { return isSome() ? std::optional<AzLinuxDesktopEnv>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzLinuxDesktopEnv>() const { return toStdOptional(); }
};

class OptionOsCondition {
private:
    AzOptionOsCondition inner_;

public:
    OptionOsCondition(AzOptionOsCondition inner) noexcept : inner_(inner) {}
    OptionOsCondition(const OptionOsCondition& other) noexcept : inner_(other.inner_) {}
    OptionOsCondition& operator=(const OptionOsCondition& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionOsCondition() {}

    static OptionOsCondition none();
    static OptionOsCondition some(AzOsCondition payload);
    bool partialEq(const OptionOsCondition& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzOptionOsCondition& inner() const { return inner_; }
    AzOptionOsCondition& inner() { return inner_; }
    const AzOptionOsCondition* ptr() const { return &inner_; }
    AzOptionOsCondition* ptr() { return &inner_; }
    AzOptionOsCondition release() { AzOptionOsCondition result = inner_; inner_ = {}; return result; }
    operator AzOptionOsCondition() && noexcept { AzOptionOsCondition result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionOsCondition_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionOsCondition_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzOsCondition& unwrap() const { return inner_.Some.payload; }
    AzOsCondition& unwrap() { return inner_.Some.payload; }
    AzOsCondition unwrapOr(const AzOsCondition& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzOsCondition> toStdOptional() const { return isSome() ? std::optional<AzOsCondition>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzOsCondition>() const { return toStdOptional(); }
};

class OptionSvgDashPattern {
private:
    AzOptionSvgDashPattern inner_;

public:
    OptionSvgDashPattern(AzOptionSvgDashPattern inner) noexcept : inner_(inner) {}
    OptionSvgDashPattern(const OptionSvgDashPattern& other) noexcept : inner_(other.inner_) {}
    OptionSvgDashPattern& operator=(const OptionSvgDashPattern& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionSvgDashPattern() {}

    static OptionSvgDashPattern none();
    static OptionSvgDashPattern some(SvgDashPattern payload);
    bool partialEq(const OptionSvgDashPattern& b) const;
    uint8_t partialCmp(const OptionSvgDashPattern& b) const;
    String toDbgString() const;

    const AzOptionSvgDashPattern& inner() const { return inner_; }
    AzOptionSvgDashPattern& inner() { return inner_; }
    const AzOptionSvgDashPattern* ptr() const { return &inner_; }
    AzOptionSvgDashPattern* ptr() { return &inner_; }
    AzOptionSvgDashPattern release() { AzOptionSvgDashPattern result = inner_; inner_ = {}; return result; }
    operator AzOptionSvgDashPattern() && noexcept { AzOptionSvgDashPattern result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionSvgDashPattern_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionSvgDashPattern_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzSvgDashPattern& unwrap() const { return inner_.Some.payload; }
    AzSvgDashPattern& unwrap() { return inner_.Some.payload; }
    AzSvgDashPattern unwrapOr(const AzSvgDashPattern& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzSvgDashPattern> toStdOptional() const { return isSome() ? std::optional<AzSvgDashPattern>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzSvgDashPattern>() const { return toStdOptional(); }
};

class OptionSvgPoint {
private:
    AzOptionSvgPoint inner_;

    OptionSvgPoint(const OptionSvgPoint&) = delete;
    OptionSvgPoint& operator=(const OptionSvgPoint&) = delete;

public:
    explicit OptionSvgPoint(AzOptionSvgPoint inner) noexcept : inner_(inner) {}

    OptionSvgPoint(OptionSvgPoint&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionSvgPoint& operator=(OptionSvgPoint&& other) noexcept {
        if (this != &other) {
            AzOptionSvgPoint_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionSvgPoint() { AzOptionSvgPoint_delete(&inner_); }

    static OptionSvgPoint none();
    static OptionSvgPoint some(SvgPoint payload);
    void delete_();
    OptionSvgPoint clone() const;
    bool partialEq(const OptionSvgPoint& b) const;
    uint8_t partialCmp(const OptionSvgPoint& b) const;
    String toDbgString() const;

    const AzOptionSvgPoint& inner() const { return inner_; }
    AzOptionSvgPoint& inner() { return inner_; }
    const AzOptionSvgPoint* ptr() const { return &inner_; }
    AzOptionSvgPoint* ptr() { return &inner_; }
    AzOptionSvgPoint release() { AzOptionSvgPoint result = inner_; inner_ = {}; return result; }
    operator AzOptionSvgPoint() && noexcept { AzOptionSvgPoint result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionSvgPoint_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionSvgPoint_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzSvgPoint& unwrap() const { return inner_.Some.payload; }
    AzSvgPoint& unwrap() { return inner_.Some.payload; }
    AzSvgPoint unwrapOr(const AzSvgPoint& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzSvgPoint> toStdOptional() const { return isSome() ? std::optional<AzSvgPoint>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzSvgPoint>() const { return toStdOptional(); }
};

class OptionLocationFix {
private:
    AzOptionLocationFix inner_;

public:
    OptionLocationFix(AzOptionLocationFix inner) noexcept : inner_(inner) {}
    OptionLocationFix(const OptionLocationFix& other) noexcept : inner_(other.inner_) {}
    OptionLocationFix& operator=(const OptionLocationFix& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionLocationFix() {}

    static OptionLocationFix none();
    static OptionLocationFix some(LocationFix payload);
    bool partialEq(const OptionLocationFix& b) const;
    String toDbgString() const;

    const AzOptionLocationFix& inner() const { return inner_; }
    AzOptionLocationFix& inner() { return inner_; }
    const AzOptionLocationFix* ptr() const { return &inner_; }
    AzOptionLocationFix* ptr() { return &inner_; }
    AzOptionLocationFix release() { AzOptionLocationFix result = inner_; inner_ = {}; return result; }
    operator AzOptionLocationFix() && noexcept { AzOptionLocationFix result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionLocationFix_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionLocationFix_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzLocationFix& unwrap() const { return inner_.Some.payload; }
    AzLocationFix& unwrap() { return inner_.Some.payload; }
    AzLocationFix unwrapOr(const AzLocationFix& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzLocationFix> toStdOptional() const { return isSome() ? std::optional<AzLocationFix>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzLocationFix>() const { return toStdOptional(); }
};

class OptionBiometricResult {
private:
    AzOptionBiometricResult inner_;

public:
    OptionBiometricResult(AzOptionBiometricResult inner) noexcept : inner_(inner) {}
    OptionBiometricResult(const OptionBiometricResult& other) noexcept : inner_(other.inner_) {}
    OptionBiometricResult& operator=(const OptionBiometricResult& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionBiometricResult() {}

    static OptionBiometricResult none();
    static OptionBiometricResult some(AzBiometricResult payload);
    bool partialEq(const OptionBiometricResult& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionBiometricResult& b) const;
    uint8_t cmp(const OptionBiometricResult& b) const;
    String toDbgString() const;

    const AzOptionBiometricResult& inner() const { return inner_; }
    AzOptionBiometricResult& inner() { return inner_; }
    const AzOptionBiometricResult* ptr() const { return &inner_; }
    AzOptionBiometricResult* ptr() { return &inner_; }
    AzOptionBiometricResult release() { AzOptionBiometricResult result = inner_; inner_ = {}; return result; }
    operator AzOptionBiometricResult() && noexcept { AzOptionBiometricResult result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionBiometricResult_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionBiometricResult_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzBiometricResult& unwrap() const { return inner_.Some.payload; }
    AzBiometricResult& unwrap() { return inner_.Some.payload; }
    AzBiometricResult unwrapOr(const AzBiometricResult& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzBiometricResult> toStdOptional() const { return isSome() ? std::optional<AzBiometricResult>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzBiometricResult>() const { return toStdOptional(); }
};

class OptionWacomPadState {
private:
    AzOptionWacomPadState inner_;

public:
    OptionWacomPadState(AzOptionWacomPadState inner) noexcept : inner_(inner) {}
    OptionWacomPadState(const OptionWacomPadState& other) noexcept : inner_(other.inner_) {}
    OptionWacomPadState& operator=(const OptionWacomPadState& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionWacomPadState() {}

    static OptionWacomPadState none();
    static OptionWacomPadState some(WacomPadState payload);
    bool partialEq(const OptionWacomPadState& b) const;
    String toDbgString() const;

    const AzOptionWacomPadState& inner() const { return inner_; }
    AzOptionWacomPadState& inner() { return inner_; }
    const AzOptionWacomPadState* ptr() const { return &inner_; }
    AzOptionWacomPadState* ptr() { return &inner_; }
    AzOptionWacomPadState release() { AzOptionWacomPadState result = inner_; inner_ = {}; return result; }
    operator AzOptionWacomPadState() && noexcept { AzOptionWacomPadState result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionWacomPadState_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionWacomPadState_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzWacomPadState& unwrap() const { return inner_.Some.payload; }
    AzWacomPadState& unwrap() { return inner_.Some.payload; }
    AzWacomPadState unwrapOr(const AzWacomPadState& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzWacomPadState> toStdOptional() const { return isSome() ? std::optional<AzWacomPadState>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzWacomPadState>() const { return toStdOptional(); }
};

class OptionScrollState {
private:
    AzOptionScrollState inner_;

public:
    OptionScrollState(AzOptionScrollState inner) noexcept : inner_(inner) {}
    OptionScrollState(const OptionScrollState& other) noexcept : inner_(other.inner_) {}
    OptionScrollState& operator=(const OptionScrollState& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionScrollState() {}

    static OptionScrollState none();
    static OptionScrollState some(ScrollState payload);
    bool partialEq(const OptionScrollState& b) const;
    uint8_t partialCmp(const OptionScrollState& b) const;
    String toDbgString() const;

    const AzOptionScrollState& inner() const { return inner_; }
    AzOptionScrollState& inner() { return inner_; }
    const AzOptionScrollState* ptr() const { return &inner_; }
    AzOptionScrollState* ptr() { return &inner_; }
    AzOptionScrollState release() { AzOptionScrollState result = inner_; inner_ = {}; return result; }
    operator AzOptionScrollState() && noexcept { AzOptionScrollState result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionScrollState_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionScrollState_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzScrollState& unwrap() const { return inner_.Some.payload; }
    AzScrollState& unwrap() { return inner_.Some.payload; }
    AzScrollState unwrapOr(const AzScrollState& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzScrollState> toStdOptional() const { return isSome() ? std::optional<AzScrollState>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzScrollState>() const { return toStdOptional(); }
};

class OptionPixelValue {
private:
    AzOptionPixelValue inner_;

public:
    OptionPixelValue(AzOptionPixelValue inner) noexcept : inner_(inner) {}
    OptionPixelValue(const OptionPixelValue& other) noexcept : inner_(other.inner_) {}
    OptionPixelValue& operator=(const OptionPixelValue& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionPixelValue() {}

    static OptionPixelValue none();
    static OptionPixelValue some(PixelValue payload);
    bool partialEq(const OptionPixelValue& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionPixelValue& b) const;
    uint8_t cmp(const OptionPixelValue& b) const;
    String toDbgString() const;

    const AzOptionPixelValue& inner() const { return inner_; }
    AzOptionPixelValue& inner() { return inner_; }
    const AzOptionPixelValue* ptr() const { return &inner_; }
    AzOptionPixelValue* ptr() { return &inner_; }
    AzOptionPixelValue release() { AzOptionPixelValue result = inner_; inner_ = {}; return result; }
    operator AzOptionPixelValue() && noexcept { AzOptionPixelValue result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionPixelValue_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionPixelValue_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzPixelValue& unwrap() const { return inner_.Some.payload; }
    AzPixelValue& unwrap() { return inner_.Some.payload; }
    AzPixelValue unwrapOr(const AzPixelValue& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzPixelValue> toStdOptional() const { return isSome() ? std::optional<AzPixelValue>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzPixelValue>() const { return toStdOptional(); }
};

class OptionTextInputSelection {
private:
    AzOptionTextInputSelection inner_;

    OptionTextInputSelection(const OptionTextInputSelection&) = delete;
    OptionTextInputSelection& operator=(const OptionTextInputSelection&) = delete;

public:
    explicit OptionTextInputSelection(AzOptionTextInputSelection inner) noexcept : inner_(inner) {}

    OptionTextInputSelection(OptionTextInputSelection&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionTextInputSelection& operator=(OptionTextInputSelection&& other) noexcept {
        if (this != &other) {
            AzOptionTextInputSelection_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionTextInputSelection() { AzOptionTextInputSelection_delete(&inner_); }

    static OptionTextInputSelection none();
    static OptionTextInputSelection some(AzTextInputSelection payload);
    void delete_();
    OptionTextInputSelection clone() const;
    bool partialEq(const OptionTextInputSelection& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzOptionTextInputSelection& inner() const { return inner_; }
    AzOptionTextInputSelection& inner() { return inner_; }
    const AzOptionTextInputSelection* ptr() const { return &inner_; }
    AzOptionTextInputSelection* ptr() { return &inner_; }
    AzOptionTextInputSelection release() { AzOptionTextInputSelection result = inner_; inner_ = {}; return result; }
    operator AzOptionTextInputSelection() && noexcept { AzOptionTextInputSelection result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTextInputSelection_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTextInputSelection_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTextInputSelection& unwrap() const { return inner_.Some.payload; }
    AzTextInputSelection& unwrap() { return inner_.Some.payload; }
    AzTextInputSelection unwrapOr(const AzTextInputSelection& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTextInputSelection> toStdOptional() const { return isSome() ? std::optional<AzTextInputSelection>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTextInputSelection>() const { return toStdOptional(); }
};

class OptionMenuItemIcon {
private:
    AzOptionMenuItemIcon inner_;

    OptionMenuItemIcon(const OptionMenuItemIcon&) = delete;
    OptionMenuItemIcon& operator=(const OptionMenuItemIcon&) = delete;

public:
    explicit OptionMenuItemIcon(AzOptionMenuItemIcon inner) noexcept : inner_(inner) {}

    OptionMenuItemIcon(OptionMenuItemIcon&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionMenuItemIcon& operator=(OptionMenuItemIcon&& other) noexcept {
        if (this != &other) {
            AzOptionMenuItemIcon_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionMenuItemIcon() { AzOptionMenuItemIcon_delete(&inner_); }

    static OptionMenuItemIcon none();
    static OptionMenuItemIcon some(AzMenuItemIcon payload);
    void delete_();
    OptionMenuItemIcon clone() const;
    bool partialEq(const OptionMenuItemIcon& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionMenuItemIcon& b) const;
    uint8_t cmp(const OptionMenuItemIcon& b) const;
    String toDbgString() const;

    const AzOptionMenuItemIcon& inner() const { return inner_; }
    AzOptionMenuItemIcon& inner() { return inner_; }
    const AzOptionMenuItemIcon* ptr() const { return &inner_; }
    AzOptionMenuItemIcon* ptr() { return &inner_; }
    AzOptionMenuItemIcon release() { AzOptionMenuItemIcon result = inner_; inner_ = {}; return result; }
    operator AzOptionMenuItemIcon() && noexcept { AzOptionMenuItemIcon result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionMenuItemIcon_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionMenuItemIcon_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzMenuItemIcon& unwrap() const { return inner_.Some.payload; }
    AzMenuItemIcon& unwrap() { return inner_.Some.payload; }
    AzMenuItemIcon unwrapOr(const AzMenuItemIcon& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzMenuItemIcon> toStdOptional() const { return isSome() ? std::optional<AzMenuItemIcon>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzMenuItemIcon>() const { return toStdOptional(); }
};

class OptionFontRef {
private:
    AzOptionFontRef inner_;

    OptionFontRef(const OptionFontRef&) = delete;
    OptionFontRef& operator=(const OptionFontRef&) = delete;

public:
    explicit OptionFontRef(AzOptionFontRef inner) noexcept : inner_(inner) {}

    OptionFontRef(OptionFontRef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionFontRef& operator=(OptionFontRef&& other) noexcept {
        if (this != &other) {
            AzOptionFontRef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionFontRef() { AzOptionFontRef_delete(&inner_); }

    static OptionFontRef none();
    static OptionFontRef some(FontRef payload);
    void delete_();
    OptionFontRef clone() const;
    bool partialEq(const OptionFontRef& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzOptionFontRef& inner() const { return inner_; }
    AzOptionFontRef& inner() { return inner_; }
    const AzOptionFontRef* ptr() const { return &inner_; }
    AzOptionFontRef* ptr() { return &inner_; }
    AzOptionFontRef release() { AzOptionFontRef result = inner_; inner_ = {}; return result; }
    operator AzOptionFontRef() && noexcept { AzOptionFontRef result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionFontRef_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionFontRef_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzFontRef& unwrap() const { return inner_.Some.payload; }
    AzFontRef& unwrap() { return inner_.Some.payload; }
    AzFontRef unwrapOr(const AzFontRef& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzFontRef> toStdOptional() const { return isSome() ? std::optional<AzFontRef>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzFontRef>() const { return toStdOptional(); }
};

class OptionRefAny {
private:
    AzOptionRefAny inner_;

    OptionRefAny(const OptionRefAny&) = delete;
    OptionRefAny& operator=(const OptionRefAny&) = delete;

public:
    explicit OptionRefAny(AzOptionRefAny inner) noexcept : inner_(inner) {}

    OptionRefAny(OptionRefAny&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionRefAny& operator=(OptionRefAny&& other) noexcept {
        if (this != &other) {
            AzOptionRefAny_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionRefAny() { AzOptionRefAny_delete(&inner_); }

    static OptionRefAny none();
    static OptionRefAny some(RefAny payload);
    void delete_();
    OptionRefAny clone() const;
    bool partialEq(const OptionRefAny& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionRefAny& b) const;
    uint8_t cmp(const OptionRefAny& b) const;
    String toDbgString() const;

    const AzOptionRefAny& inner() const { return inner_; }
    AzOptionRefAny& inner() { return inner_; }
    const AzOptionRefAny* ptr() const { return &inner_; }
    AzOptionRefAny* ptr() { return &inner_; }
    AzOptionRefAny release() { AzOptionRefAny result = inner_; inner_ = {}; return result; }
    operator AzOptionRefAny() && noexcept { AzOptionRefAny result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionRefAny_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionRefAny_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzRefAny& unwrap() const { return inner_.Some.payload; }
    AzRefAny& unwrap() { return inner_.Some.payload; }
    AzRefAny unwrapOr(const AzRefAny& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzRefAny> toStdOptional() const { return isSome() ? std::optional<AzRefAny>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzRefAny>() const { return toStdOptional(); }
};

class OptionLayoutRect {
private:
    AzOptionLayoutRect inner_;

public:
    OptionLayoutRect(AzOptionLayoutRect inner) noexcept : inner_(inner) {}
    OptionLayoutRect(const OptionLayoutRect& other) noexcept : inner_(other.inner_) {}
    OptionLayoutRect& operator=(const OptionLayoutRect& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionLayoutRect() {}

    static OptionLayoutRect none();
    static OptionLayoutRect some(LayoutRect payload);
    bool partialEq(const OptionLayoutRect& b) const;
    uint8_t partialCmp(const OptionLayoutRect& b) const;
    String toDbgString() const;

    const AzOptionLayoutRect& inner() const { return inner_; }
    AzOptionLayoutRect& inner() { return inner_; }
    const AzOptionLayoutRect* ptr() const { return &inner_; }
    AzOptionLayoutRect* ptr() { return &inner_; }
    AzOptionLayoutRect release() { AzOptionLayoutRect result = inner_; inner_ = {}; return result; }
    operator AzOptionLayoutRect() && noexcept { AzOptionLayoutRect result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionLayoutRect_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionLayoutRect_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzLayoutRect& unwrap() const { return inner_.Some.payload; }
    AzLayoutRect& unwrap() { return inner_.Some.payload; }
    AzLayoutRect unwrapOr(const AzLayoutRect& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzLayoutRect> toStdOptional() const { return isSome() ? std::optional<AzLayoutRect>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzLayoutRect>() const { return toStdOptional(); }
};

class OptionDomNodeId {
private:
    AzOptionDomNodeId inner_;

public:
    OptionDomNodeId(AzOptionDomNodeId inner) noexcept : inner_(inner) {}
    OptionDomNodeId(const OptionDomNodeId& other) noexcept : inner_(other.inner_) {}
    OptionDomNodeId& operator=(const OptionDomNodeId& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionDomNodeId() {}

    static OptionDomNodeId none();
    static OptionDomNodeId some(DomNodeId payload);
    bool partialEq(const OptionDomNodeId& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionDomNodeId& b) const;
    uint8_t cmp(const OptionDomNodeId& b) const;
    String toDbgString() const;

    const AzOptionDomNodeId& inner() const { return inner_; }
    AzOptionDomNodeId& inner() { return inner_; }
    const AzOptionDomNodeId* ptr() const { return &inner_; }
    AzOptionDomNodeId* ptr() { return &inner_; }
    AzOptionDomNodeId release() { AzOptionDomNodeId result = inner_; inner_ = {}; return result; }
    operator AzOptionDomNodeId() && noexcept { AzOptionDomNodeId result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDomNodeId_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDomNodeId_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDomNodeId& unwrap() const { return inner_.Some.payload; }
    AzDomNodeId& unwrap() { return inner_.Some.payload; }
    AzDomNodeId unwrapOr(const AzDomNodeId& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDomNodeId> toStdOptional() const { return isSome() ? std::optional<AzDomNodeId>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDomNodeId>() const { return toStdOptional(); }
};

class OptionDuration {
private:
    AzOptionDuration inner_;

public:
    OptionDuration(AzOptionDuration inner) noexcept : inner_(inner) {}
    OptionDuration(const OptionDuration& other) noexcept : inner_(other.inner_) {}
    OptionDuration& operator=(const OptionDuration& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionDuration() {}

    static OptionDuration none();
    static OptionDuration some(AzDuration payload);
    bool partialEq(const OptionDuration& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionDuration& b) const;
    uint8_t cmp(const OptionDuration& b) const;
    String toDbgString() const;

    const AzOptionDuration& inner() const { return inner_; }
    AzOptionDuration& inner() { return inner_; }
    const AzOptionDuration* ptr() const { return &inner_; }
    AzOptionDuration* ptr() { return &inner_; }
    AzOptionDuration release() { AzOptionDuration result = inner_; inner_ = {}; return result; }
    operator AzOptionDuration() && noexcept { AzOptionDuration result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDuration_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDuration_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDuration& unwrap() const { return inner_.Some.payload; }
    AzDuration& unwrap() { return inner_.Some.payload; }
    AzDuration unwrapOr(const AzDuration& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDuration> toStdOptional() const { return isSome() ? std::optional<AzDuration>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDuration>() const { return toStdOptional(); }
};

class OptionLogicalRect {
private:
    AzOptionLogicalRect inner_;

public:
    OptionLogicalRect(AzOptionLogicalRect inner) noexcept : inner_(inner) {}
    OptionLogicalRect(const OptionLogicalRect& other) noexcept : inner_(other.inner_) {}
    OptionLogicalRect& operator=(const OptionLogicalRect& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionLogicalRect() {}

    static OptionLogicalRect none();
    static OptionLogicalRect some(LogicalRect payload);
    bool partialEq(const OptionLogicalRect& b) const;
    uint8_t partialCmp(const OptionLogicalRect& b) const;
    String toDbgString() const;

    const AzOptionLogicalRect& inner() const { return inner_; }
    AzOptionLogicalRect& inner() { return inner_; }
    const AzOptionLogicalRect* ptr() const { return &inner_; }
    AzOptionLogicalRect* ptr() { return &inner_; }
    AzOptionLogicalRect release() { AzOptionLogicalRect result = inner_; inner_ = {}; return result; }
    operator AzOptionLogicalRect() && noexcept { AzOptionLogicalRect result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionLogicalRect_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionLogicalRect_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzLogicalRect& unwrap() const { return inner_.Some.payload; }
    AzLogicalRect& unwrap() { return inner_.Some.payload; }
    AzLogicalRect unwrapOr(const AzLogicalRect& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzLogicalRect> toStdOptional() const { return isSome() ? std::optional<AzLogicalRect>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzLogicalRect>() const { return toStdOptional(); }
};

class OptionRendererOptions {
private:
    AzOptionRendererOptions inner_;

public:
    OptionRendererOptions(AzOptionRendererOptions inner) noexcept : inner_(inner) {}
    OptionRendererOptions(const OptionRendererOptions& other) noexcept : inner_(other.inner_) {}
    OptionRendererOptions& operator=(const OptionRendererOptions& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionRendererOptions() {}

    static OptionRendererOptions none();
    static OptionRendererOptions some(RendererOptions payload);
    bool partialEq(const OptionRendererOptions& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionRendererOptions& b) const;
    uint8_t cmp(const OptionRendererOptions& b) const;
    String toDbgString() const;

    const AzOptionRendererOptions& inner() const { return inner_; }
    AzOptionRendererOptions& inner() { return inner_; }
    const AzOptionRendererOptions* ptr() const { return &inner_; }
    AzOptionRendererOptions* ptr() { return &inner_; }
    AzOptionRendererOptions release() { AzOptionRendererOptions result = inner_; inner_ = {}; return result; }
    operator AzOptionRendererOptions() && noexcept { AzOptionRendererOptions result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionRendererOptions_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionRendererOptions_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzRendererOptions& unwrap() const { return inner_.Some.payload; }
    AzRendererOptions& unwrap() { return inner_.Some.payload; }
    AzRendererOptions unwrapOr(const AzRendererOptions& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzRendererOptions> toStdOptional() const { return isSome() ? std::optional<AzRendererOptions>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzRendererOptions>() const { return toStdOptional(); }
};

class OptionGlContextPtr {
private:
    AzOptionGlContextPtr inner_;

    OptionGlContextPtr(const OptionGlContextPtr&) = delete;
    OptionGlContextPtr& operator=(const OptionGlContextPtr&) = delete;

public:
    explicit OptionGlContextPtr(AzOptionGlContextPtr inner) noexcept : inner_(inner) {}

    OptionGlContextPtr(OptionGlContextPtr&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionGlContextPtr& operator=(OptionGlContextPtr&& other) noexcept {
        if (this != &other) {
            AzOptionGlContextPtr_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionGlContextPtr() { AzOptionGlContextPtr_delete(&inner_); }

    static OptionGlContextPtr none();
    static OptionGlContextPtr some(GlContextPtr payload);
    void delete_();
    OptionGlContextPtr clone() const;
    bool partialEq(const OptionGlContextPtr& b) const;
    uint8_t partialCmp(const OptionGlContextPtr& b) const;
    uint8_t cmp(const OptionGlContextPtr& b) const;
    String toDbgString() const;

    const AzOptionGlContextPtr& inner() const { return inner_; }
    AzOptionGlContextPtr& inner() { return inner_; }
    const AzOptionGlContextPtr* ptr() const { return &inner_; }
    AzOptionGlContextPtr* ptr() { return &inner_; }
    AzOptionGlContextPtr release() { AzOptionGlContextPtr result = inner_; inner_ = {}; return result; }
    operator AzOptionGlContextPtr() && noexcept { AzOptionGlContextPtr result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionGlContextPtr_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionGlContextPtr_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzGlContextPtr& unwrap() const { return inner_.Some.payload; }
    AzGlContextPtr& unwrap() { return inner_.Some.payload; }
    AzGlContextPtr unwrapOr(const AzGlContextPtr& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzGlContextPtr> toStdOptional() const { return isSome() ? std::optional<AzGlContextPtr>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzGlContextPtr>() const { return toStdOptional(); }
};

class OptionTextCursor {
private:
    AzOptionTextCursor inner_;

public:
    OptionTextCursor(AzOptionTextCursor inner) noexcept : inner_(inner) {}
    OptionTextCursor(const OptionTextCursor& other) noexcept : inner_(other.inner_) {}
    OptionTextCursor& operator=(const OptionTextCursor& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionTextCursor() {}

    static OptionTextCursor none();
    static OptionTextCursor some(TextCursor payload);
    bool partialEq(const OptionTextCursor& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionTextCursor& b) const;
    uint8_t cmp(const OptionTextCursor& b) const;
    String toDbgString() const;

    const AzOptionTextCursor& inner() const { return inner_; }
    AzOptionTextCursor& inner() { return inner_; }
    const AzOptionTextCursor* ptr() const { return &inner_; }
    AzOptionTextCursor* ptr() { return &inner_; }
    AzOptionTextCursor release() { AzOptionTextCursor result = inner_; inner_ = {}; return result; }
    operator AzOptionTextCursor() && noexcept { AzOptionTextCursor result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTextCursor_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTextCursor_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTextCursor& unwrap() const { return inner_.Some.payload; }
    AzTextCursor& unwrap() { return inner_.Some.payload; }
    AzTextCursor unwrapOr(const AzTextCursor& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTextCursor> toStdOptional() const { return isSome() ? std::optional<AzTextCursor>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTextCursor>() const { return toStdOptional(); }
};

class OptionWindowFlags {
private:
    AzOptionWindowFlags inner_;

    OptionWindowFlags(const OptionWindowFlags&) = delete;
    OptionWindowFlags& operator=(const OptionWindowFlags&) = delete;

public:
    explicit OptionWindowFlags(AzOptionWindowFlags inner) noexcept : inner_(inner) {}

    OptionWindowFlags(OptionWindowFlags&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionWindowFlags& operator=(OptionWindowFlags&& other) noexcept {
        if (this != &other) {
            AzOptionWindowFlags_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionWindowFlags() { AzOptionWindowFlags_delete(&inner_); }

    static OptionWindowFlags none();
    static OptionWindowFlags some(WindowFlags payload);
    void delete_();
    OptionWindowFlags clone() const;
    bool partialEq(const OptionWindowFlags& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionWindowFlags& b) const;
    uint8_t cmp(const OptionWindowFlags& b) const;
    String toDbgString() const;

    const AzOptionWindowFlags& inner() const { return inner_; }
    AzOptionWindowFlags& inner() { return inner_; }
    const AzOptionWindowFlags* ptr() const { return &inner_; }
    AzOptionWindowFlags* ptr() { return &inner_; }
    AzOptionWindowFlags release() { AzOptionWindowFlags result = inner_; inner_ = {}; return result; }
    operator AzOptionWindowFlags() && noexcept { AzOptionWindowFlags result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionWindowFlags_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionWindowFlags_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzWindowFlags& unwrap() const { return inner_.Some.payload; }
    AzWindowFlags& unwrap() { return inner_.Some.payload; }
    AzWindowFlags unwrapOr(const AzWindowFlags& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzWindowFlags> toStdOptional() const { return isSome() ? std::optional<AzWindowFlags>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzWindowFlags>() const { return toStdOptional(); }
};

class OptionDetectedPinch {
private:
    AzOptionDetectedPinch inner_;

public:
    OptionDetectedPinch(AzOptionDetectedPinch inner) noexcept : inner_(inner) {}
    OptionDetectedPinch(const OptionDetectedPinch& other) noexcept : inner_(other.inner_) {}
    OptionDetectedPinch& operator=(const OptionDetectedPinch& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionDetectedPinch() {}

    static OptionDetectedPinch none();
    static OptionDetectedPinch some(DetectedPinch payload);
    bool partialEq(const OptionDetectedPinch& b) const;
    String toDbgString() const;

    const AzOptionDetectedPinch& inner() const { return inner_; }
    AzOptionDetectedPinch& inner() { return inner_; }
    const AzOptionDetectedPinch* ptr() const { return &inner_; }
    AzOptionDetectedPinch* ptr() { return &inner_; }
    AzOptionDetectedPinch release() { AzOptionDetectedPinch result = inner_; inner_ = {}; return result; }
    operator AzOptionDetectedPinch() && noexcept { AzOptionDetectedPinch result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDetectedPinch_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDetectedPinch_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDetectedPinch& unwrap() const { return inner_.Some.payload; }
    AzDetectedPinch& unwrap() { return inner_.Some.payload; }
    AzDetectedPinch unwrapOr(const AzDetectedPinch& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDetectedPinch> toStdOptional() const { return isSome() ? std::optional<AzDetectedPinch>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDetectedPinch>() const { return toStdOptional(); }
};

class OptionDetectedRotation {
private:
    AzOptionDetectedRotation inner_;

public:
    OptionDetectedRotation(AzOptionDetectedRotation inner) noexcept : inner_(inner) {}
    OptionDetectedRotation(const OptionDetectedRotation& other) noexcept : inner_(other.inner_) {}
    OptionDetectedRotation& operator=(const OptionDetectedRotation& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionDetectedRotation() {}

    static OptionDetectedRotation none();
    static OptionDetectedRotation some(DetectedRotation payload);
    bool partialEq(const OptionDetectedRotation& b) const;
    String toDbgString() const;

    const AzOptionDetectedRotation& inner() const { return inner_; }
    AzOptionDetectedRotation& inner() { return inner_; }
    const AzOptionDetectedRotation* ptr() const { return &inner_; }
    AzOptionDetectedRotation* ptr() { return &inner_; }
    AzOptionDetectedRotation release() { AzOptionDetectedRotation result = inner_; inner_ = {}; return result; }
    operator AzOptionDetectedRotation() && noexcept { AzOptionDetectedRotation result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDetectedRotation_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDetectedRotation_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDetectedRotation& unwrap() const { return inner_.Some.payload; }
    AzDetectedRotation& unwrap() { return inner_.Some.payload; }
    AzDetectedRotation unwrapOr(const AzDetectedRotation& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDetectedRotation> toStdOptional() const { return isSome() ? std::optional<AzDetectedRotation>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDetectedRotation>() const { return toStdOptional(); }
};

class OptionDetectedLongPress {
private:
    AzOptionDetectedLongPress inner_;

public:
    OptionDetectedLongPress(AzOptionDetectedLongPress inner) noexcept : inner_(inner) {}
    OptionDetectedLongPress(const OptionDetectedLongPress& other) noexcept : inner_(other.inner_) {}
    OptionDetectedLongPress& operator=(const OptionDetectedLongPress& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionDetectedLongPress() {}

    static OptionDetectedLongPress none();
    static OptionDetectedLongPress some(DetectedLongPress payload);
    bool partialEq(const OptionDetectedLongPress& b) const;
    String toDbgString() const;

    const AzOptionDetectedLongPress& inner() const { return inner_; }
    AzOptionDetectedLongPress& inner() { return inner_; }
    const AzOptionDetectedLongPress* ptr() const { return &inner_; }
    AzOptionDetectedLongPress* ptr() { return &inner_; }
    AzOptionDetectedLongPress release() { AzOptionDetectedLongPress result = inner_; inner_ = {}; return result; }
    operator AzOptionDetectedLongPress() && noexcept { AzOptionDetectedLongPress result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDetectedLongPress_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDetectedLongPress_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDetectedLongPress& unwrap() const { return inner_.Some.payload; }
    AzDetectedLongPress& unwrap() { return inner_.Some.payload; }
    AzDetectedLongPress unwrapOr(const AzDetectedLongPress& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDetectedLongPress> toStdOptional() const { return isSome() ? std::optional<AzDetectedLongPress>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDetectedLongPress>() const { return toStdOptional(); }
};

class OptionPenState {
private:
    AzOptionPenState inner_;

public:
    OptionPenState(AzOptionPenState inner) noexcept : inner_(inner) {}
    OptionPenState(const OptionPenState& other) noexcept : inner_(other.inner_) {}
    OptionPenState& operator=(const OptionPenState& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionPenState() {}

    static OptionPenState none();
    static OptionPenState some(PenState payload);
    bool partialEq(const OptionPenState& b) const;
    String toDbgString() const;

    const AzOptionPenState& inner() const { return inner_; }
    AzOptionPenState& inner() { return inner_; }
    const AzOptionPenState* ptr() const { return &inner_; }
    AzOptionPenState* ptr() { return &inner_; }
    AzOptionPenState release() { AzOptionPenState result = inner_; inner_ = {}; return result; }
    operator AzOptionPenState() && noexcept { AzOptionPenState result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionPenState_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionPenState_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzPenState& unwrap() const { return inner_.Some.payload; }
    AzPenState& unwrap() { return inner_.Some.payload; }
    AzPenState unwrapOr(const AzPenState& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzPenState> toStdOptional() const { return isSome() ? std::optional<AzPenState>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzPenState>() const { return toStdOptional(); }
};

class OptionStyledNode {
private:
    AzOptionStyledNode inner_;

    OptionStyledNode(const OptionStyledNode&) = delete;
    OptionStyledNode& operator=(const OptionStyledNode&) = delete;

public:
    explicit OptionStyledNode(AzOptionStyledNode inner) noexcept : inner_(inner) {}

    OptionStyledNode(OptionStyledNode&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionStyledNode& operator=(OptionStyledNode&& other) noexcept {
        if (this != &other) {
            AzOptionStyledNode_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionStyledNode() { AzOptionStyledNode_delete(&inner_); }

    static OptionStyledNode none();
    static OptionStyledNode some(StyledNode payload);
    void delete_();
    OptionStyledNode clone() const;
    bool partialEq(const OptionStyledNode& b) const;
    uint8_t partialCmp(const OptionStyledNode& b) const;
    String toDbgString() const;

    const AzOptionStyledNode& inner() const { return inner_; }
    AzOptionStyledNode& inner() { return inner_; }
    const AzOptionStyledNode* ptr() const { return &inner_; }
    AzOptionStyledNode* ptr() { return &inner_; }
    AzOptionStyledNode release() { AzOptionStyledNode result = inner_; inner_ = {}; return result; }
    operator AzOptionStyledNode() && noexcept { AzOptionStyledNode result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionStyledNode_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionStyledNode_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzStyledNode& unwrap() const { return inner_.Some.payload; }
    AzStyledNode& unwrap() { return inner_.Some.payload; }
    AzStyledNode unwrapOr(const AzStyledNode& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzStyledNode> toStdOptional() const { return isSome() ? std::optional<AzStyledNode>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzStyledNode>() const { return toStdOptional(); }
};

class OptionParentWithNodeDepth {
private:
    AzOptionParentWithNodeDepth inner_;

public:
    OptionParentWithNodeDepth(AzOptionParentWithNodeDepth inner) noexcept : inner_(inner) {}
    OptionParentWithNodeDepth(const OptionParentWithNodeDepth& other) noexcept : inner_(other.inner_) {}
    OptionParentWithNodeDepth& operator=(const OptionParentWithNodeDepth& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionParentWithNodeDepth() {}

    static OptionParentWithNodeDepth none();
    static OptionParentWithNodeDepth some(ParentWithNodeDepth payload);
    bool partialEq(const OptionParentWithNodeDepth& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionParentWithNodeDepth& b) const;
    uint8_t cmp(const OptionParentWithNodeDepth& b) const;

    const AzOptionParentWithNodeDepth& inner() const { return inner_; }
    AzOptionParentWithNodeDepth& inner() { return inner_; }
    const AzOptionParentWithNodeDepth* ptr() const { return &inner_; }
    AzOptionParentWithNodeDepth* ptr() { return &inner_; }
    AzOptionParentWithNodeDepth release() { AzOptionParentWithNodeDepth result = inner_; inner_ = {}; return result; }
    operator AzOptionParentWithNodeDepth() && noexcept { AzOptionParentWithNodeDepth result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionParentWithNodeDepth_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionParentWithNodeDepth_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzParentWithNodeDepth& unwrap() const { return inner_.Some.payload; }
    AzParentWithNodeDepth& unwrap() { return inner_.Some.payload; }
    AzParentWithNodeDepth unwrapOr(const AzParentWithNodeDepth& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzParentWithNodeDepth> toStdOptional() const { return isSome() ? std::optional<AzParentWithNodeDepth>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzParentWithNodeDepth>() const { return toStdOptional(); }
};

class OptionVideoMode {
private:
    AzOptionVideoMode inner_;

public:
    OptionVideoMode(AzOptionVideoMode inner) noexcept : inner_(inner) {}
    OptionVideoMode(const OptionVideoMode& other) noexcept : inner_(other.inner_) {}
    OptionVideoMode& operator=(const OptionVideoMode& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionVideoMode() {}

    static OptionVideoMode none();
    static OptionVideoMode some(VideoMode payload);
    bool partialEq(const OptionVideoMode& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionVideoMode& b) const;
    uint8_t cmp(const OptionVideoMode& b) const;
    String toDbgString() const;

    const AzOptionVideoMode& inner() const { return inner_; }
    AzOptionVideoMode& inner() { return inner_; }
    const AzOptionVideoMode* ptr() const { return &inner_; }
    AzOptionVideoMode* ptr() { return &inner_; }
    AzOptionVideoMode release() { AzOptionVideoMode result = inner_; inner_ = {}; return result; }
    operator AzOptionVideoMode() && noexcept { AzOptionVideoMode result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionVideoMode_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionVideoMode_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzVideoMode& unwrap() const { return inner_.Some.payload; }
    AzVideoMode& unwrap() { return inner_.Some.payload; }
    AzVideoMode unwrapOr(const AzVideoMode& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzVideoMode> toStdOptional() const { return isSome() ? std::optional<AzVideoMode>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzVideoMode>() const { return toStdOptional(); }
};

class OptionOsVersion {
private:
    AzOptionOsVersion inner_;

public:
    OptionOsVersion(AzOptionOsVersion inner) noexcept : inner_(inner) {}
    OptionOsVersion(const OptionOsVersion& other) noexcept : inner_(other.inner_) {}
    OptionOsVersion& operator=(const OptionOsVersion& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionOsVersion() {}

    static OptionOsVersion none();
    static OptionOsVersion some(OsVersion payload);
    bool partialEq(const OptionOsVersion& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzOptionOsVersion& inner() const { return inner_; }
    AzOptionOsVersion& inner() { return inner_; }
    const AzOptionOsVersion* ptr() const { return &inner_; }
    AzOptionOsVersion* ptr() { return &inner_; }
    AzOptionOsVersion release() { AzOptionOsVersion result = inner_; inner_ = {}; return result; }
    operator AzOptionOsVersion() && noexcept { AzOptionOsVersion result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionOsVersion_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionOsVersion_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzOsVersion& unwrap() const { return inner_.Some.payload; }
    AzOsVersion& unwrap() { return inner_.Some.payload; }
    AzOsVersion unwrapOr(const AzOsVersion& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzOsVersion> toStdOptional() const { return isSome() ? std::optional<AzOsVersion>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzOsVersion>() const { return toStdOptional(); }
};

class OptionTouchPoint {
private:
    AzOptionTouchPoint inner_;

public:
    OptionTouchPoint(AzOptionTouchPoint inner) noexcept : inner_(inner) {}
    OptionTouchPoint(const OptionTouchPoint& other) noexcept : inner_(other.inner_) {}
    OptionTouchPoint& operator=(const OptionTouchPoint& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionTouchPoint() {}

    static OptionTouchPoint none();
    static OptionTouchPoint some(TouchPoint payload);
    bool partialEq(const OptionTouchPoint& b) const;
    uint8_t partialCmp(const OptionTouchPoint& b) const;
    String toDbgString() const;

    const AzOptionTouchPoint& inner() const { return inner_; }
    AzOptionTouchPoint& inner() { return inner_; }
    const AzOptionTouchPoint* ptr() const { return &inner_; }
    AzOptionTouchPoint* ptr() { return &inner_; }
    AzOptionTouchPoint release() { AzOptionTouchPoint result = inner_; inner_ = {}; return result; }
    operator AzOptionTouchPoint() && noexcept { AzOptionTouchPoint result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTouchPoint_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTouchPoint_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTouchPoint& unwrap() const { return inner_.Some.payload; }
    AzTouchPoint& unwrap() { return inner_.Some.payload; }
    AzTouchPoint unwrapOr(const AzTouchPoint& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTouchPoint> toStdOptional() const { return isSome() ? std::optional<AzTouchPoint>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTouchPoint>() const { return toStdOptional(); }
};

class OptionSensorReading {
private:
    AzOptionSensorReading inner_;

public:
    OptionSensorReading(AzOptionSensorReading inner) noexcept : inner_(inner) {}
    OptionSensorReading(const OptionSensorReading& other) noexcept : inner_(other.inner_) {}
    OptionSensorReading& operator=(const OptionSensorReading& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionSensorReading() {}

    static OptionSensorReading none();
    static OptionSensorReading some(SensorReading payload);
    bool partialEq(const OptionSensorReading& b) const;
    String toDbgString() const;

    const AzOptionSensorReading& inner() const { return inner_; }
    AzOptionSensorReading& inner() { return inner_; }
    const AzOptionSensorReading* ptr() const { return &inner_; }
    AzOptionSensorReading* ptr() { return &inner_; }
    AzOptionSensorReading release() { AzOptionSensorReading result = inner_; inner_ = {}; return result; }
    operator AzOptionSensorReading() && noexcept { AzOptionSensorReading result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionSensorReading_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionSensorReading_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzSensorReading& unwrap() const { return inner_.Some.payload; }
    AzSensorReading& unwrap() { return inner_.Some.payload; }
    AzSensorReading unwrapOr(const AzSensorReading& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzSensorReading> toStdOptional() const { return isSome() ? std::optional<AzSensorReading>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzSensorReading>() const { return toStdOptional(); }
};

class OptionGamepadState {
private:
    AzOptionGamepadState inner_;

public:
    OptionGamepadState(AzOptionGamepadState inner) noexcept : inner_(inner) {}
    OptionGamepadState(const OptionGamepadState& other) noexcept : inner_(other.inner_) {}
    OptionGamepadState& operator=(const OptionGamepadState& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionGamepadState() {}

    static OptionGamepadState none();
    static OptionGamepadState some(GamepadState payload);
    bool partialEq(const OptionGamepadState& b) const;
    String toDbgString() const;

    const AzOptionGamepadState& inner() const { return inner_; }
    AzOptionGamepadState& inner() { return inner_; }
    const AzOptionGamepadState* ptr() const { return &inner_; }
    AzOptionGamepadState* ptr() { return &inner_; }
    AzOptionGamepadState release() { AzOptionGamepadState result = inner_; inner_ = {}; return result; }
    operator AzOptionGamepadState() && noexcept { AzOptionGamepadState result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionGamepadState_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionGamepadState_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzGamepadState& unwrap() const { return inner_.Some.payload; }
    AzGamepadState& unwrap() { return inner_.Some.payload; }
    AzGamepadState unwrapOr(const AzGamepadState& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzGamepadState> toStdOptional() const { return isSome() ? std::optional<AzGamepadState>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzGamepadState>() const { return toStdOptional(); }
};

class OptionPixelValueNoPercent {
private:
    AzOptionPixelValueNoPercent inner_;

public:
    OptionPixelValueNoPercent(AzOptionPixelValueNoPercent inner) noexcept : inner_(inner) {}
    OptionPixelValueNoPercent(const OptionPixelValueNoPercent& other) noexcept : inner_(other.inner_) {}
    OptionPixelValueNoPercent& operator=(const OptionPixelValueNoPercent& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionPixelValueNoPercent() {}

    static OptionPixelValueNoPercent none();
    static OptionPixelValueNoPercent some(PixelValueNoPercent payload);
    bool partialEq(const OptionPixelValueNoPercent& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionPixelValueNoPercent& b) const;
    uint8_t cmp(const OptionPixelValueNoPercent& b) const;
    String toDbgString() const;

    const AzOptionPixelValueNoPercent& inner() const { return inner_; }
    AzOptionPixelValueNoPercent& inner() { return inner_; }
    const AzOptionPixelValueNoPercent* ptr() const { return &inner_; }
    AzOptionPixelValueNoPercent* ptr() { return &inner_; }
    AzOptionPixelValueNoPercent release() { AzOptionPixelValueNoPercent result = inner_; inner_ = {}; return result; }
    operator AzOptionPixelValueNoPercent() && noexcept { AzOptionPixelValueNoPercent result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionPixelValueNoPercent_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionPixelValueNoPercent_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzPixelValueNoPercent& unwrap() const { return inner_.Some.payload; }
    AzPixelValueNoPercent& unwrap() { return inner_.Some.payload; }
    AzPixelValueNoPercent unwrapOr(const AzPixelValueNoPercent& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzPixelValueNoPercent> toStdOptional() const { return isSome() ? std::optional<AzPixelValueNoPercent>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzPixelValueNoPercent>() const { return toStdOptional(); }
};

class OptionSelectionRange {
private:
    AzOptionSelectionRange inner_;

public:
    OptionSelectionRange(AzOptionSelectionRange inner) noexcept : inner_(inner) {}
    OptionSelectionRange(const OptionSelectionRange& other) noexcept : inner_(other.inner_) {}
    OptionSelectionRange& operator=(const OptionSelectionRange& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionSelectionRange() {}

    static OptionSelectionRange none();
    static OptionSelectionRange some(SelectionRange payload);
    bool partialEq(const OptionSelectionRange& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionSelectionRange& b) const;
    uint8_t cmp(const OptionSelectionRange& b) const;
    String toDbgString() const;

    const AzOptionSelectionRange& inner() const { return inner_; }
    AzOptionSelectionRange& inner() { return inner_; }
    const AzOptionSelectionRange* ptr() const { return &inner_; }
    AzOptionSelectionRange* ptr() { return &inner_; }
    AzOptionSelectionRange release() { AzOptionSelectionRange result = inner_; inner_ = {}; return result; }
    operator AzOptionSelectionRange() && noexcept { AzOptionSelectionRange result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionSelectionRange_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionSelectionRange_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzSelectionRange& unwrap() const { return inner_.Some.payload; }
    AzSelectionRange& unwrap() { return inner_.Some.payload; }
    AzSelectionRange unwrapOr(const AzSelectionRange& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzSelectionRange> toStdOptional() const { return isSome() ? std::optional<AzSelectionRange>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzSelectionRange>() const { return toStdOptional(); }
};

class OptionMouseState {
private:
    AzOptionMouseState inner_;

public:
    OptionMouseState(AzOptionMouseState inner) noexcept : inner_(inner) {}
    OptionMouseState(const OptionMouseState& other) noexcept : inner_(other.inner_) {}
    OptionMouseState& operator=(const OptionMouseState& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionMouseState() {}

    static OptionMouseState none();
    static OptionMouseState some(MouseState payload);
    bool partialEq(const OptionMouseState& b) const;
    uint8_t partialCmp(const OptionMouseState& b) const;
    String toDbgString() const;

    const AzOptionMouseState& inner() const { return inner_; }
    AzOptionMouseState& inner() { return inner_; }
    const AzOptionMouseState* ptr() const { return &inner_; }
    AzOptionMouseState* ptr() { return &inner_; }
    AzOptionMouseState release() { AzOptionMouseState result = inner_; inner_ = {}; return result; }
    operator AzOptionMouseState() && noexcept { AzOptionMouseState result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionMouseState_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionMouseState_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzMouseState& unwrap() const { return inner_.Some.payload; }
    AzMouseState& unwrap() { return inner_.Some.payload; }
    AzMouseState unwrapOr(const AzMouseState& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzMouseState> toStdOptional() const { return isSome() ? std::optional<AzMouseState>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzMouseState>() const { return toStdOptional(); }
};

class OptionThreadSendMsg {
private:
    AzOptionThreadSendMsg inner_;

    OptionThreadSendMsg(const OptionThreadSendMsg&) = delete;
    OptionThreadSendMsg& operator=(const OptionThreadSendMsg&) = delete;

public:
    explicit OptionThreadSendMsg(AzOptionThreadSendMsg inner) noexcept : inner_(inner) {}

    OptionThreadSendMsg(OptionThreadSendMsg&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionThreadSendMsg& operator=(OptionThreadSendMsg&& other) noexcept {
        if (this != &other) {
            AzOptionThreadSendMsg_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionThreadSendMsg() { AzOptionThreadSendMsg_delete(&inner_); }

    static OptionThreadSendMsg none();
    static OptionThreadSendMsg some(AzThreadSendMsg payload);
    void delete_();
    OptionThreadSendMsg clone() const;
    bool partialEq(const OptionThreadSendMsg& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionThreadSendMsg& b) const;
    uint8_t cmp(const OptionThreadSendMsg& b) const;
    String toDbgString() const;

    const AzOptionThreadSendMsg& inner() const { return inner_; }
    AzOptionThreadSendMsg& inner() { return inner_; }
    const AzOptionThreadSendMsg* ptr() const { return &inner_; }
    AzOptionThreadSendMsg* ptr() { return &inner_; }
    AzOptionThreadSendMsg release() { AzOptionThreadSendMsg result = inner_; inner_ = {}; return result; }
    operator AzOptionThreadSendMsg() && noexcept { AzOptionThreadSendMsg result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionThreadSendMsg_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionThreadSendMsg_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzThreadSendMsg& unwrap() const { return inner_.Some.payload; }
    AzThreadSendMsg& unwrap() { return inner_.Some.payload; }
    AzThreadSendMsg unwrapOr(const AzThreadSendMsg& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzThreadSendMsg> toStdOptional() const { return isSome() ? std::optional<AzThreadSendMsg>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzThreadSendMsg>() const { return toStdOptional(); }
};

class OptionTagIdToNodeIdMapping {
private:
    AzOptionTagIdToNodeIdMapping inner_;

    OptionTagIdToNodeIdMapping(const OptionTagIdToNodeIdMapping&) = delete;
    OptionTagIdToNodeIdMapping& operator=(const OptionTagIdToNodeIdMapping&) = delete;

public:
    explicit OptionTagIdToNodeIdMapping(AzOptionTagIdToNodeIdMapping inner) noexcept : inner_(inner) {}

    OptionTagIdToNodeIdMapping(OptionTagIdToNodeIdMapping&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionTagIdToNodeIdMapping& operator=(OptionTagIdToNodeIdMapping&& other) noexcept {
        if (this != &other) {
            AzOptionTagIdToNodeIdMapping_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionTagIdToNodeIdMapping() { AzOptionTagIdToNodeIdMapping_delete(&inner_); }

    static OptionTagIdToNodeIdMapping none();
    static OptionTagIdToNodeIdMapping some(TagIdToNodeIdMapping payload);
    void delete_();
    OptionTagIdToNodeIdMapping clone() const;
    bool partialEq(const OptionTagIdToNodeIdMapping& b) const;
    uint8_t partialCmp(const OptionTagIdToNodeIdMapping& b) const;
    uint8_t cmp(const OptionTagIdToNodeIdMapping& b) const;
    String toDbgString() const;

    const AzOptionTagIdToNodeIdMapping& inner() const { return inner_; }
    AzOptionTagIdToNodeIdMapping& inner() { return inner_; }
    const AzOptionTagIdToNodeIdMapping* ptr() const { return &inner_; }
    AzOptionTagIdToNodeIdMapping* ptr() { return &inner_; }
    AzOptionTagIdToNodeIdMapping release() { AzOptionTagIdToNodeIdMapping result = inner_; inner_ = {}; return result; }
    operator AzOptionTagIdToNodeIdMapping() && noexcept { AzOptionTagIdToNodeIdMapping result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTagIdToNodeIdMapping_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTagIdToNodeIdMapping_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTagIdToNodeIdMapping& unwrap() const { return inner_.Some.payload; }
    AzTagIdToNodeIdMapping& unwrap() { return inner_.Some.payload; }
    AzTagIdToNodeIdMapping unwrapOr(const AzTagIdToNodeIdMapping& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTagIdToNodeIdMapping> toStdOptional() const { return isSome() ? std::optional<AzTagIdToNodeIdMapping>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTagIdToNodeIdMapping>() const { return toStdOptional(); }
};

class OptionNormalizedRadialColorStop {
private:
    AzOptionNormalizedRadialColorStop inner_;

    OptionNormalizedRadialColorStop(const OptionNormalizedRadialColorStop&) = delete;
    OptionNormalizedRadialColorStop& operator=(const OptionNormalizedRadialColorStop&) = delete;

public:
    explicit OptionNormalizedRadialColorStop(AzOptionNormalizedRadialColorStop inner) noexcept : inner_(inner) {}

    OptionNormalizedRadialColorStop(OptionNormalizedRadialColorStop&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionNormalizedRadialColorStop& operator=(OptionNormalizedRadialColorStop&& other) noexcept {
        if (this != &other) {
            AzOptionNormalizedRadialColorStop_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionNormalizedRadialColorStop() { AzOptionNormalizedRadialColorStop_delete(&inner_); }

    static OptionNormalizedRadialColorStop none();
    static OptionNormalizedRadialColorStop some(NormalizedRadialColorStop payload);
    void delete_();
    OptionNormalizedRadialColorStop clone() const;
    bool partialEq(const OptionNormalizedRadialColorStop& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionNormalizedRadialColorStop& b) const;
    uint8_t cmp(const OptionNormalizedRadialColorStop& b) const;
    String toDbgString() const;

    const AzOptionNormalizedRadialColorStop& inner() const { return inner_; }
    AzOptionNormalizedRadialColorStop& inner() { return inner_; }
    const AzOptionNormalizedRadialColorStop* ptr() const { return &inner_; }
    AzOptionNormalizedRadialColorStop* ptr() { return &inner_; }
    AzOptionNormalizedRadialColorStop release() { AzOptionNormalizedRadialColorStop result = inner_; inner_ = {}; return result; }
    operator AzOptionNormalizedRadialColorStop() && noexcept { AzOptionNormalizedRadialColorStop result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionNormalizedRadialColorStop_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionNormalizedRadialColorStop_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzNormalizedRadialColorStop& unwrap() const { return inner_.Some.payload; }
    AzNormalizedRadialColorStop& unwrap() { return inner_.Some.payload; }
    AzNormalizedRadialColorStop unwrapOr(const AzNormalizedRadialColorStop& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzNormalizedRadialColorStop> toStdOptional() const { return isSome() ? std::optional<AzNormalizedRadialColorStop>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzNormalizedRadialColorStop>() const { return toStdOptional(); }
};

class OptionNormalizedLinearColorStop {
private:
    AzOptionNormalizedLinearColorStop inner_;

    OptionNormalizedLinearColorStop(const OptionNormalizedLinearColorStop&) = delete;
    OptionNormalizedLinearColorStop& operator=(const OptionNormalizedLinearColorStop&) = delete;

public:
    explicit OptionNormalizedLinearColorStop(AzOptionNormalizedLinearColorStop inner) noexcept : inner_(inner) {}

    OptionNormalizedLinearColorStop(OptionNormalizedLinearColorStop&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionNormalizedLinearColorStop& operator=(OptionNormalizedLinearColorStop&& other) noexcept {
        if (this != &other) {
            AzOptionNormalizedLinearColorStop_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionNormalizedLinearColorStop() { AzOptionNormalizedLinearColorStop_delete(&inner_); }

    static OptionNormalizedLinearColorStop none();
    static OptionNormalizedLinearColorStop some(NormalizedLinearColorStop payload);
    void delete_();
    OptionNormalizedLinearColorStop clone() const;
    bool partialEq(const OptionNormalizedLinearColorStop& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionNormalizedLinearColorStop& b) const;
    uint8_t cmp(const OptionNormalizedLinearColorStop& b) const;
    String toDbgString() const;

    const AzOptionNormalizedLinearColorStop& inner() const { return inner_; }
    AzOptionNormalizedLinearColorStop& inner() { return inner_; }
    const AzOptionNormalizedLinearColorStop* ptr() const { return &inner_; }
    AzOptionNormalizedLinearColorStop* ptr() { return &inner_; }
    AzOptionNormalizedLinearColorStop release() { AzOptionNormalizedLinearColorStop result = inner_; inner_ = {}; return result; }
    operator AzOptionNormalizedLinearColorStop() && noexcept { AzOptionNormalizedLinearColorStop result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionNormalizedLinearColorStop_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionNormalizedLinearColorStop_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzNormalizedLinearColorStop& unwrap() const { return inner_.Some.payload; }
    AzNormalizedLinearColorStop& unwrap() { return inner_.Some.payload; }
    AzNormalizedLinearColorStop unwrapOr(const AzNormalizedLinearColorStop& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzNormalizedLinearColorStop> toStdOptional() const { return isSome() ? std::optional<AzNormalizedLinearColorStop>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzNormalizedLinearColorStop>() const { return toStdOptional(); }
};

class OptionGridTrackSizing {
private:
    AzOptionGridTrackSizing inner_;

    OptionGridTrackSizing(const OptionGridTrackSizing&) = delete;
    OptionGridTrackSizing& operator=(const OptionGridTrackSizing&) = delete;

public:
    explicit OptionGridTrackSizing(AzOptionGridTrackSizing inner) noexcept : inner_(inner) {}

    OptionGridTrackSizing(OptionGridTrackSizing&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionGridTrackSizing& operator=(OptionGridTrackSizing&& other) noexcept {
        if (this != &other) {
            AzOptionGridTrackSizing_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionGridTrackSizing() { AzOptionGridTrackSizing_delete(&inner_); }

    static OptionGridTrackSizing none();
    static OptionGridTrackSizing some(AzGridTrackSizing payload);
    void delete_();
    OptionGridTrackSizing clone() const;
    bool partialEq(const OptionGridTrackSizing& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionGridTrackSizing& b) const;
    uint8_t cmp(const OptionGridTrackSizing& b) const;

    const AzOptionGridTrackSizing& inner() const { return inner_; }
    AzOptionGridTrackSizing& inner() { return inner_; }
    const AzOptionGridTrackSizing* ptr() const { return &inner_; }
    AzOptionGridTrackSizing* ptr() { return &inner_; }
    AzOptionGridTrackSizing release() { AzOptionGridTrackSizing result = inner_; inner_ = {}; return result; }
    operator AzOptionGridTrackSizing() && noexcept { AzOptionGridTrackSizing result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionGridTrackSizing_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionGridTrackSizing_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzGridTrackSizing& unwrap() const { return inner_.Some.payload; }
    AzGridTrackSizing& unwrap() { return inner_.Some.payload; }
    AzGridTrackSizing unwrapOr(const AzGridTrackSizing& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzGridTrackSizing> toStdOptional() const { return isSome() ? std::optional<AzGridTrackSizing>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzGridTrackSizing>() const { return toStdOptional(); }
};

class OptionStringVec {
private:
    AzOptionStringVec inner_;

    OptionStringVec(const OptionStringVec&) = delete;
    OptionStringVec& operator=(const OptionStringVec&) = delete;

public:
    explicit OptionStringVec(AzOptionStringVec inner) noexcept : inner_(inner) {}

    OptionStringVec(OptionStringVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionStringVec& operator=(OptionStringVec&& other) noexcept {
        if (this != &other) {
            AzOptionStringVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionStringVec() { AzOptionStringVec_delete(&inner_); }

    static OptionStringVec none();
    static OptionStringVec some(StringVec payload);
    void delete_();
    OptionStringVec clone() const;
    bool partialEq(const OptionStringVec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionStringVec& b) const;
    uint8_t cmp(const OptionStringVec& b) const;
    String toDbgString() const;

    const AzOptionStringVec& inner() const { return inner_; }
    AzOptionStringVec& inner() { return inner_; }
    const AzOptionStringVec* ptr() const { return &inner_; }
    AzOptionStringVec* ptr() { return &inner_; }
    AzOptionStringVec release() { AzOptionStringVec result = inner_; inner_ = {}; return result; }
    operator AzOptionStringVec() && noexcept { AzOptionStringVec result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionStringVec_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionStringVec_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzStringVec& unwrap() const { return inner_.Some.payload; }
    AzStringVec& unwrap() { return inner_.Some.payload; }
    AzStringVec unwrapOr(const AzStringVec& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzStringVec> toStdOptional() const { return isSome() ? std::optional<AzStringVec>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzStringVec>() const { return toStdOptional(); }
};

class OptionJsonVec {
private:
    AzOptionJsonVec inner_;

    OptionJsonVec(const OptionJsonVec&) = delete;
    OptionJsonVec& operator=(const OptionJsonVec&) = delete;

public:
    explicit OptionJsonVec(AzOptionJsonVec inner) noexcept : inner_(inner) {}

    OptionJsonVec(OptionJsonVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionJsonVec& operator=(OptionJsonVec&& other) noexcept {
        if (this != &other) {
            AzOptionJsonVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionJsonVec() { AzOptionJsonVec_delete(&inner_); }

    static OptionJsonVec none();
    static OptionJsonVec some(JsonVec payload);
    void delete_();
    OptionJsonVec clone() const;
    String toDbgString() const;

    const AzOptionJsonVec& inner() const { return inner_; }
    AzOptionJsonVec& inner() { return inner_; }
    const AzOptionJsonVec* ptr() const { return &inner_; }
    AzOptionJsonVec* ptr() { return &inner_; }
    AzOptionJsonVec release() { AzOptionJsonVec result = inner_; inner_ = {}; return result; }
    operator AzOptionJsonVec() && noexcept { AzOptionJsonVec result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionJsonVec_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionJsonVec_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzJsonVec& unwrap() const { return inner_.Some.payload; }
    AzJsonVec& unwrap() { return inner_.Some.payload; }
    AzJsonVec unwrapOr(const AzJsonVec& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzJsonVec> toStdOptional() const { return isSome() ? std::optional<AzJsonVec>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzJsonVec>() const { return toStdOptional(); }
};

class OptionJsonKeyValueVec {
private:
    AzOptionJsonKeyValueVec inner_;

    OptionJsonKeyValueVec(const OptionJsonKeyValueVec&) = delete;
    OptionJsonKeyValueVec& operator=(const OptionJsonKeyValueVec&) = delete;

public:
    explicit OptionJsonKeyValueVec(AzOptionJsonKeyValueVec inner) noexcept : inner_(inner) {}

    OptionJsonKeyValueVec(OptionJsonKeyValueVec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionJsonKeyValueVec& operator=(OptionJsonKeyValueVec&& other) noexcept {
        if (this != &other) {
            AzOptionJsonKeyValueVec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionJsonKeyValueVec() { AzOptionJsonKeyValueVec_delete(&inner_); }

    static OptionJsonKeyValueVec none();
    static OptionJsonKeyValueVec some(JsonKeyValueVec payload);
    void delete_();
    OptionJsonKeyValueVec clone() const;
    String toDbgString() const;

    const AzOptionJsonKeyValueVec& inner() const { return inner_; }
    AzOptionJsonKeyValueVec& inner() { return inner_; }
    const AzOptionJsonKeyValueVec* ptr() const { return &inner_; }
    AzOptionJsonKeyValueVec* ptr() { return &inner_; }
    AzOptionJsonKeyValueVec release() { AzOptionJsonKeyValueVec result = inner_; inner_ = {}; return result; }
    operator AzOptionJsonKeyValueVec() && noexcept { AzOptionJsonKeyValueVec result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionJsonKeyValueVec_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionJsonKeyValueVec_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzJsonKeyValueVec& unwrap() const { return inner_.Some.payload; }
    AzJsonKeyValueVec& unwrap() { return inner_.Some.payload; }
    AzJsonKeyValueVec unwrapOr(const AzJsonKeyValueVec& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzJsonKeyValueVec> toStdOptional() const { return isSome() ? std::optional<AzJsonKeyValueVec>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzJsonKeyValueVec>() const { return toStdOptional(); }
};

class OptionCalcAstItem {
private:
    AzOptionCalcAstItem inner_;

    OptionCalcAstItem(const OptionCalcAstItem&) = delete;
    OptionCalcAstItem& operator=(const OptionCalcAstItem&) = delete;

public:
    explicit OptionCalcAstItem(AzOptionCalcAstItem inner) noexcept : inner_(inner) {}

    OptionCalcAstItem(OptionCalcAstItem&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionCalcAstItem& operator=(OptionCalcAstItem&& other) noexcept {
        if (this != &other) {
            AzOptionCalcAstItem_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionCalcAstItem() { AzOptionCalcAstItem_delete(&inner_); }

    static OptionCalcAstItem none();
    static OptionCalcAstItem some(AzCalcAstItem payload);
    void delete_();
    OptionCalcAstItem clone() const;
    bool partialEq(const OptionCalcAstItem& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionCalcAstItem& b) const;
    uint8_t cmp(const OptionCalcAstItem& b) const;
    String toDbgString() const;

    const AzOptionCalcAstItem& inner() const { return inner_; }
    AzOptionCalcAstItem& inner() { return inner_; }
    const AzOptionCalcAstItem* ptr() const { return &inner_; }
    AzOptionCalcAstItem* ptr() { return &inner_; }
    AzOptionCalcAstItem release() { AzOptionCalcAstItem result = inner_; inner_ = {}; return result; }
    operator AzOptionCalcAstItem() && noexcept { AzOptionCalcAstItem result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCalcAstItem_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCalcAstItem_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCalcAstItem& unwrap() const { return inner_.Some.payload; }
    AzCalcAstItem& unwrap() { return inner_.Some.payload; }
    AzCalcAstItem unwrapOr(const AzCalcAstItem& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCalcAstItem> toStdOptional() const { return isSome() ? std::optional<AzCalcAstItem>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCalcAstItem>() const { return toStdOptional(); }
};

class OptionSvgPathElement {
private:
    AzOptionSvgPathElement inner_;

public:
    OptionSvgPathElement(AzOptionSvgPathElement inner) noexcept : inner_(inner) {}
    OptionSvgPathElement(const OptionSvgPathElement& other) noexcept : inner_(other.inner_) {}
    OptionSvgPathElement& operator=(const OptionSvgPathElement& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionSvgPathElement() {}

    static OptionSvgPathElement none();
    static OptionSvgPathElement some(AzSvgPathElement payload);
    bool partialEq(const OptionSvgPathElement& b) const;
    uint8_t partialCmp(const OptionSvgPathElement& b) const;
    String toDbgString() const;

    const AzOptionSvgPathElement& inner() const { return inner_; }
    AzOptionSvgPathElement& inner() { return inner_; }
    const AzOptionSvgPathElement* ptr() const { return &inner_; }
    AzOptionSvgPathElement* ptr() { return &inner_; }
    AzOptionSvgPathElement release() { AzOptionSvgPathElement result = inner_; inner_ = {}; return result; }
    operator AzOptionSvgPathElement() && noexcept { AzOptionSvgPathElement result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionSvgPathElement_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionSvgPathElement_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzSvgPathElement& unwrap() const { return inner_.Some.payload; }
    AzSvgPathElement& unwrap() { return inner_.Some.payload; }
    AzSvgPathElement unwrapOr(const AzSvgPathElement& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzSvgPathElement> toStdOptional() const { return isSome() ? std::optional<AzSvgPathElement>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzSvgPathElement>() const { return toStdOptional(); }
};

class OptionU8Vec {
private:
    AzOptionU8Vec inner_;

    OptionU8Vec(const OptionU8Vec&) = delete;
    OptionU8Vec& operator=(const OptionU8Vec&) = delete;

public:
    explicit OptionU8Vec(AzOptionU8Vec inner) noexcept : inner_(inner) {}

    OptionU8Vec(OptionU8Vec&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionU8Vec& operator=(OptionU8Vec&& other) noexcept {
        if (this != &other) {
            AzOptionU8Vec_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionU8Vec() { AzOptionU8Vec_delete(&inner_); }

    static OptionU8Vec none();
    static OptionU8Vec some(U8Vec payload);
    void delete_();
    OptionU8Vec clone() const;
    bool partialEq(const OptionU8Vec& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionU8Vec& b) const;
    uint8_t cmp(const OptionU8Vec& b) const;
    String toDbgString() const;

    const AzOptionU8Vec& inner() const { return inner_; }
    AzOptionU8Vec& inner() { return inner_; }
    const AzOptionU8Vec* ptr() const { return &inner_; }
    AzOptionU8Vec* ptr() { return &inner_; }
    AzOptionU8Vec release() { AzOptionU8Vec result = inner_; inner_ = {}; return result; }
    operator AzOptionU8Vec() && noexcept { AzOptionU8Vec result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionU8Vec_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionU8Vec_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzU8Vec& unwrap() const { return inner_.Some.payload; }
    AzU8Vec& unwrap() { return inner_.Some.payload; }
    AzU8Vec unwrapOr(const AzU8Vec& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzU8Vec> toStdOptional() const { return isSome() ? std::optional<AzU8Vec>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzU8Vec>() const { return toStdOptional(); }
};

class ResultU8VecEncodeImageError {
private:
    AzResultU8VecEncodeImageError inner_;

    ResultU8VecEncodeImageError(const ResultU8VecEncodeImageError&) = delete;
    ResultU8VecEncodeImageError& operator=(const ResultU8VecEncodeImageError&) = delete;

public:
    explicit ResultU8VecEncodeImageError(AzResultU8VecEncodeImageError inner) noexcept : inner_(inner) {}

    ResultU8VecEncodeImageError(ResultU8VecEncodeImageError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultU8VecEncodeImageError& operator=(ResultU8VecEncodeImageError&& other) noexcept {
        if (this != &other) {
            AzResultU8VecEncodeImageError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultU8VecEncodeImageError() { AzResultU8VecEncodeImageError_delete(&inner_); }

    static ResultU8VecEncodeImageError ok(U8Vec payload);
    static ResultU8VecEncodeImageError err(AzEncodeImageError payload);
    void delete_();
    ResultU8VecEncodeImageError clone() const;
    String toDbgString() const;

    const AzResultU8VecEncodeImageError& inner() const { return inner_; }
    AzResultU8VecEncodeImageError& inner() { return inner_; }
    const AzResultU8VecEncodeImageError* ptr() const { return &inner_; }
    AzResultU8VecEncodeImageError* ptr() { return &inner_; }
    AzResultU8VecEncodeImageError release() { AzResultU8VecEncodeImageError result = inner_; inner_ = {}; return result; }
    operator AzResultU8VecEncodeImageError() && noexcept { AzResultU8VecEncodeImageError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultU8VecEncodeImageError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultU8VecEncodeImageError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class OptionMenu {
private:
    AzOptionMenu inner_;

    OptionMenu(const OptionMenu&) = delete;
    OptionMenu& operator=(const OptionMenu&) = delete;

public:
    explicit OptionMenu(AzOptionMenu inner) noexcept : inner_(inner) {}

    OptionMenu(OptionMenu&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionMenu& operator=(OptionMenu&& other) noexcept {
        if (this != &other) {
            AzOptionMenu_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionMenu() { AzOptionMenu_delete(&inner_); }

    static OptionMenu none();
    static OptionMenu some(Menu payload);
    void delete_();
    OptionMenu clone() const;
    bool partialEq(const OptionMenu& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionMenu& b) const;
    uint8_t cmp(const OptionMenu& b) const;
    String toDbgString() const;

    const AzOptionMenu& inner() const { return inner_; }
    AzOptionMenu& inner() { return inner_; }
    const AzOptionMenu* ptr() const { return &inner_; }
    AzOptionMenu* ptr() { return &inner_; }
    AzOptionMenu release() { AzOptionMenu result = inner_; inner_ = {}; return result; }
    operator AzOptionMenu() && noexcept { AzOptionMenu result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionMenu_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionMenu_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzMenu& unwrap() const { return inner_.Some.payload; }
    AzMenu& unwrap() { return inner_.Some.payload; }
    AzMenu unwrapOr(const AzMenu& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzMenu> toStdOptional() const { return isSome() ? std::optional<AzMenu>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzMenu>() const { return toStdOptional(); }
};

class OptionVirtualKeyCodeCombo {
private:
    AzOptionVirtualKeyCodeCombo inner_;

    OptionVirtualKeyCodeCombo(const OptionVirtualKeyCodeCombo&) = delete;
    OptionVirtualKeyCodeCombo& operator=(const OptionVirtualKeyCodeCombo&) = delete;

public:
    explicit OptionVirtualKeyCodeCombo(AzOptionVirtualKeyCodeCombo inner) noexcept : inner_(inner) {}

    OptionVirtualKeyCodeCombo(OptionVirtualKeyCodeCombo&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionVirtualKeyCodeCombo& operator=(OptionVirtualKeyCodeCombo&& other) noexcept {
        if (this != &other) {
            AzOptionVirtualKeyCodeCombo_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionVirtualKeyCodeCombo() { AzOptionVirtualKeyCodeCombo_delete(&inner_); }

    static OptionVirtualKeyCodeCombo none();
    static OptionVirtualKeyCodeCombo some(VirtualKeyCodeCombo payload);
    void delete_();
    OptionVirtualKeyCodeCombo clone() const;
    bool partialEq(const OptionVirtualKeyCodeCombo& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionVirtualKeyCodeCombo& b) const;
    uint8_t cmp(const OptionVirtualKeyCodeCombo& b) const;
    String toDbgString() const;

    const AzOptionVirtualKeyCodeCombo& inner() const { return inner_; }
    AzOptionVirtualKeyCodeCombo& inner() { return inner_; }
    const AzOptionVirtualKeyCodeCombo* ptr() const { return &inner_; }
    AzOptionVirtualKeyCodeCombo* ptr() { return &inner_; }
    AzOptionVirtualKeyCodeCombo release() { AzOptionVirtualKeyCodeCombo result = inner_; inner_ = {}; return result; }
    operator AzOptionVirtualKeyCodeCombo() && noexcept { AzOptionVirtualKeyCodeCombo result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionVirtualKeyCodeCombo_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionVirtualKeyCodeCombo_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzVirtualKeyCodeCombo& unwrap() const { return inner_.Some.payload; }
    AzVirtualKeyCodeCombo& unwrap() { return inner_.Some.payload; }
    AzVirtualKeyCodeCombo unwrapOr(const AzVirtualKeyCodeCombo& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzVirtualKeyCodeCombo> toStdOptional() const { return isSome() ? std::optional<AzVirtualKeyCodeCombo>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzVirtualKeyCodeCombo>() const { return toStdOptional(); }
};

class OptionString {
private:
    AzOptionString inner_;

    OptionString(const OptionString&) = delete;
    OptionString& operator=(const OptionString&) = delete;

public:
    explicit OptionString(AzOptionString inner) noexcept : inner_(inner) {}

    OptionString(OptionString&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionString& operator=(OptionString&& other) noexcept {
        if (this != &other) {
            AzOptionString_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionString() { AzOptionString_delete(&inner_); }

    static OptionString none();
    static OptionString some(String payload);
    void delete_();
    OptionString clone() const;
    bool partialEq(const OptionString& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionString& b) const;
    uint8_t cmp(const OptionString& b) const;
    String toDbgString() const;

    const AzOptionString& inner() const { return inner_; }
    AzOptionString& inner() { return inner_; }
    const AzOptionString* ptr() const { return &inner_; }
    AzOptionString* ptr() { return &inner_; }
    AzOptionString release() { AzOptionString result = inner_; inner_ = {}; return result; }
    operator AzOptionString() && noexcept { AzOptionString result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionString_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionString_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzString& unwrap() const { return inner_.Some.payload; }
    AzString& unwrap() { return inner_.Some.payload; }
    AzString unwrapOr(const AzString& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzString> toStdOptional() const { return isSome() ? std::optional<AzString>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzString>() const { return toStdOptional(); }
};

class OptionCallback {
private:
    AzOptionCallback inner_;

    OptionCallback(const OptionCallback&) = delete;
    OptionCallback& operator=(const OptionCallback&) = delete;

public:
    explicit OptionCallback(AzOptionCallback inner) noexcept : inner_(inner) {}

    OptionCallback(OptionCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionCallback& operator=(OptionCallback&& other) noexcept {
        if (this != &other) {
            AzOptionCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionCallback() { AzOptionCallback_delete(&inner_); }

    static OptionCallback none();
    static OptionCallback some(Callback payload);
    void delete_();
    OptionCallback clone() const;
    bool partialEq(const OptionCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionCallback& b) const;
    uint8_t cmp(const OptionCallback& b) const;
    String toDbgString() const;

    const AzOptionCallback& inner() const { return inner_; }
    AzOptionCallback& inner() { return inner_; }
    const AzOptionCallback* ptr() const { return &inner_; }
    AzOptionCallback* ptr() { return &inner_; }
    AzOptionCallback release() { AzOptionCallback result = inner_; inner_ = {}; return result; }
    operator AzOptionCallback() && noexcept { AzOptionCallback result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCallback_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCallback_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCallback& unwrap() const { return inner_.Some.payload; }
    AzCallback& unwrap() { return inner_.Some.payload; }
    AzCallback unwrapOr(const AzCallback& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCallback> toStdOptional() const { return isSome() ? std::optional<AzCallback>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCallback>() const { return toStdOptional(); }
};

class OptionTaskBarIcon {
private:
    AzOptionTaskBarIcon inner_;

    OptionTaskBarIcon(const OptionTaskBarIcon&) = delete;
    OptionTaskBarIcon& operator=(const OptionTaskBarIcon&) = delete;

public:
    explicit OptionTaskBarIcon(AzOptionTaskBarIcon inner) noexcept : inner_(inner) {}

    OptionTaskBarIcon(OptionTaskBarIcon&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionTaskBarIcon& operator=(OptionTaskBarIcon&& other) noexcept {
        if (this != &other) {
            AzOptionTaskBarIcon_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionTaskBarIcon() { AzOptionTaskBarIcon_delete(&inner_); }

    static OptionTaskBarIcon none();
    static OptionTaskBarIcon some(TaskBarIcon payload);
    void delete_();
    OptionTaskBarIcon clone() const;
    bool partialEq(const OptionTaskBarIcon& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionTaskBarIcon& b) const;
    uint8_t cmp(const OptionTaskBarIcon& b) const;
    String toDbgString() const;

    const AzOptionTaskBarIcon& inner() const { return inner_; }
    AzOptionTaskBarIcon& inner() { return inner_; }
    const AzOptionTaskBarIcon* ptr() const { return &inner_; }
    AzOptionTaskBarIcon* ptr() { return &inner_; }
    AzOptionTaskBarIcon release() { AzOptionTaskBarIcon result = inner_; inner_ = {}; return result; }
    operator AzOptionTaskBarIcon() && noexcept { AzOptionTaskBarIcon result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTaskBarIcon_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTaskBarIcon_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTaskBarIcon& unwrap() const { return inner_.Some.payload; }
    AzTaskBarIcon& unwrap() { return inner_.Some.payload; }
    AzTaskBarIcon unwrapOr(const AzTaskBarIcon& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTaskBarIcon> toStdOptional() const { return isSome() ? std::optional<AzTaskBarIcon>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTaskBarIcon>() const { return toStdOptional(); }
};

class OptionInstant {
private:
    AzOptionInstant inner_;

    OptionInstant(const OptionInstant&) = delete;
    OptionInstant& operator=(const OptionInstant&) = delete;

public:
    explicit OptionInstant(AzOptionInstant inner) noexcept : inner_(inner) {}

    OptionInstant(OptionInstant&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionInstant& operator=(OptionInstant&& other) noexcept {
        if (this != &other) {
            AzOptionInstant_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionInstant() { AzOptionInstant_delete(&inner_); }

    static OptionInstant none();
    static OptionInstant some(AzInstant payload);
    void delete_();
    OptionInstant clone() const;
    bool partialEq(const OptionInstant& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionInstant& b) const;
    uint8_t cmp(const OptionInstant& b) const;
    String toDbgString() const;

    const AzOptionInstant& inner() const { return inner_; }
    AzOptionInstant& inner() { return inner_; }
    const AzOptionInstant* ptr() const { return &inner_; }
    AzOptionInstant* ptr() { return &inner_; }
    AzOptionInstant release() { AzOptionInstant result = inner_; inner_ = {}; return result; }
    operator AzOptionInstant() && noexcept { AzOptionInstant result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionInstant_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionInstant_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzInstant& unwrap() const { return inner_.Some.payload; }
    AzInstant& unwrap() { return inner_.Some.payload; }
    AzInstant unwrapOr(const AzInstant& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzInstant> toStdOptional() const { return isSome() ? std::optional<AzInstant>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzInstant>() const { return toStdOptional(); }
};

class OptionKeyboardState {
private:
    AzOptionKeyboardState inner_;

    OptionKeyboardState(const OptionKeyboardState&) = delete;
    OptionKeyboardState& operator=(const OptionKeyboardState&) = delete;

public:
    explicit OptionKeyboardState(AzOptionKeyboardState inner) noexcept : inner_(inner) {}

    OptionKeyboardState(OptionKeyboardState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionKeyboardState& operator=(OptionKeyboardState&& other) noexcept {
        if (this != &other) {
            AzOptionKeyboardState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionKeyboardState() { AzOptionKeyboardState_delete(&inner_); }

    static OptionKeyboardState none();
    static OptionKeyboardState some(KeyboardState payload);
    void delete_();
    OptionKeyboardState clone() const;
    bool partialEq(const OptionKeyboardState& b) const;
    String toDbgString() const;

    const AzOptionKeyboardState& inner() const { return inner_; }
    AzOptionKeyboardState& inner() { return inner_; }
    const AzOptionKeyboardState* ptr() const { return &inner_; }
    AzOptionKeyboardState* ptr() { return &inner_; }
    AzOptionKeyboardState release() { AzOptionKeyboardState result = inner_; inner_ = {}; return result; }
    operator AzOptionKeyboardState() && noexcept { AzOptionKeyboardState result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionKeyboardState_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionKeyboardState_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzKeyboardState& unwrap() const { return inner_.Some.payload; }
    AzKeyboardState& unwrap() { return inner_.Some.payload; }
    AzKeyboardState unwrapOr(const AzKeyboardState& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzKeyboardState> toStdOptional() const { return isSome() ? std::optional<AzKeyboardState>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzKeyboardState>() const { return toStdOptional(); }
};

class OptionSelectionState {
private:
    AzOptionSelectionState inner_;

    OptionSelectionState(const OptionSelectionState&) = delete;
    OptionSelectionState& operator=(const OptionSelectionState&) = delete;

public:
    explicit OptionSelectionState(AzOptionSelectionState inner) noexcept : inner_(inner) {}

    OptionSelectionState(OptionSelectionState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionSelectionState& operator=(OptionSelectionState&& other) noexcept {
        if (this != &other) {
            AzOptionSelectionState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionSelectionState() { AzOptionSelectionState_delete(&inner_); }

    static OptionSelectionState none();
    static OptionSelectionState some(SelectionState payload);
    void delete_();
    OptionSelectionState clone() const;
    bool partialEq(const OptionSelectionState& b) const;
    String toDbgString() const;

    const AzOptionSelectionState& inner() const { return inner_; }
    AzOptionSelectionState& inner() { return inner_; }
    const AzOptionSelectionState* ptr() const { return &inner_; }
    AzOptionSelectionState* ptr() { return &inner_; }
    AzOptionSelectionState release() { AzOptionSelectionState result = inner_; inner_ = {}; return result; }
    operator AzOptionSelectionState() && noexcept { AzOptionSelectionState result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionSelectionState_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionSelectionState_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzSelectionState& unwrap() const { return inner_.Some.payload; }
    AzSelectionState& unwrap() { return inner_.Some.payload; }
    AzSelectionState unwrapOr(const AzSelectionState& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzSelectionState> toStdOptional() const { return isSome() ? std::optional<AzSelectionState>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzSelectionState>() const { return toStdOptional(); }
};

class OptionDatasetMergeCallback {
private:
    AzOptionDatasetMergeCallback inner_;

    OptionDatasetMergeCallback(const OptionDatasetMergeCallback&) = delete;
    OptionDatasetMergeCallback& operator=(const OptionDatasetMergeCallback&) = delete;

public:
    explicit OptionDatasetMergeCallback(AzOptionDatasetMergeCallback inner) noexcept : inner_(inner) {}

    OptionDatasetMergeCallback(OptionDatasetMergeCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionDatasetMergeCallback& operator=(OptionDatasetMergeCallback&& other) noexcept {
        if (this != &other) {
            AzOptionDatasetMergeCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionDatasetMergeCallback() { AzOptionDatasetMergeCallback_delete(&inner_); }

    static OptionDatasetMergeCallback none();
    static OptionDatasetMergeCallback some(DatasetMergeCallback payload);
    void delete_();
    OptionDatasetMergeCallback clone() const;
    String toDbgString() const;

    const AzOptionDatasetMergeCallback& inner() const { return inner_; }
    AzOptionDatasetMergeCallback& inner() { return inner_; }
    const AzOptionDatasetMergeCallback* ptr() const { return &inner_; }
    AzOptionDatasetMergeCallback* ptr() { return &inner_; }
    AzOptionDatasetMergeCallback release() { AzOptionDatasetMergeCallback result = inner_; inner_ = {}; return result; }
    operator AzOptionDatasetMergeCallback() && noexcept { AzOptionDatasetMergeCallback result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDatasetMergeCallback_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDatasetMergeCallback_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDatasetMergeCallback& unwrap() const { return inner_.Some.payload; }
    AzDatasetMergeCallback& unwrap() { return inner_.Some.payload; }
    AzDatasetMergeCallback unwrapOr(const AzDatasetMergeCallback& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDatasetMergeCallback> toStdOptional() const { return isSome() ? std::optional<AzDatasetMergeCallback>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDatasetMergeCallback>() const { return toStdOptional(); }
};

class OptionStyleTransform {
private:
    AzOptionStyleTransform inner_;

public:
    OptionStyleTransform(AzOptionStyleTransform inner) noexcept : inner_(inner) {}
    OptionStyleTransform(const OptionStyleTransform& other) noexcept : inner_(other.inner_) {}
    OptionStyleTransform& operator=(const OptionStyleTransform& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionStyleTransform() {}

    static OptionStyleTransform none();
    static OptionStyleTransform some(AzStyleTransform payload);
    bool partialEq(const OptionStyleTransform& b) const;
    uint8_t partialCmp(const OptionStyleTransform& b) const;
    String toDbgString() const;

    const AzOptionStyleTransform& inner() const { return inner_; }
    AzOptionStyleTransform& inner() { return inner_; }
    const AzOptionStyleTransform* ptr() const { return &inner_; }
    AzOptionStyleTransform* ptr() { return &inner_; }
    AzOptionStyleTransform release() { AzOptionStyleTransform result = inner_; inner_ = {}; return result; }
    operator AzOptionStyleTransform() && noexcept { AzOptionStyleTransform result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionStyleTransform_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionStyleTransform_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzStyleTransform& unwrap() const { return inner_.Some.payload; }
    AzStyleTransform& unwrap() { return inner_.Some.payload; }
    AzStyleTransform unwrapOr(const AzStyleTransform& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzStyleTransform> toStdOptional() const { return isSome() ? std::optional<AzStyleTransform>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzStyleTransform>() const { return toStdOptional(); }
};

class OptionStyleBackgroundPosition {
private:
    AzOptionStyleBackgroundPosition inner_;

public:
    OptionStyleBackgroundPosition(AzOptionStyleBackgroundPosition inner) noexcept : inner_(inner) {}
    OptionStyleBackgroundPosition(const OptionStyleBackgroundPosition& other) noexcept : inner_(other.inner_) {}
    OptionStyleBackgroundPosition& operator=(const OptionStyleBackgroundPosition& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionStyleBackgroundPosition() {}

    static OptionStyleBackgroundPosition none();
    static OptionStyleBackgroundPosition some(StyleBackgroundPosition payload);
    bool partialEq(const OptionStyleBackgroundPosition& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionStyleBackgroundPosition& b) const;
    uint8_t cmp(const OptionStyleBackgroundPosition& b) const;
    String toDbgString() const;

    const AzOptionStyleBackgroundPosition& inner() const { return inner_; }
    AzOptionStyleBackgroundPosition& inner() { return inner_; }
    const AzOptionStyleBackgroundPosition* ptr() const { return &inner_; }
    AzOptionStyleBackgroundPosition* ptr() { return &inner_; }
    AzOptionStyleBackgroundPosition release() { AzOptionStyleBackgroundPosition result = inner_; inner_ = {}; return result; }
    operator AzOptionStyleBackgroundPosition() && noexcept { AzOptionStyleBackgroundPosition result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionStyleBackgroundPosition_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionStyleBackgroundPosition_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzStyleBackgroundPosition& unwrap() const { return inner_.Some.payload; }
    AzStyleBackgroundPosition& unwrap() { return inner_.Some.payload; }
    AzStyleBackgroundPosition unwrapOr(const AzStyleBackgroundPosition& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzStyleBackgroundPosition> toStdOptional() const { return isSome() ? std::optional<AzStyleBackgroundPosition>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzStyleBackgroundPosition>() const { return toStdOptional(); }
};

class OptionCss {
private:
    AzOptionCss inner_;

    OptionCss(const OptionCss&) = delete;
    OptionCss& operator=(const OptionCss&) = delete;

public:
    explicit OptionCss(AzOptionCss inner) noexcept : inner_(inner) {}

    OptionCss(OptionCss&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionCss& operator=(OptionCss&& other) noexcept {
        if (this != &other) {
            AzOptionCss_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionCss() { AzOptionCss_delete(&inner_); }

    static OptionCss none();
    static OptionCss some(Css payload);
    void delete_();
    OptionCss clone() const;
    bool partialEq(const OptionCss& b) const;
    uint8_t partialCmp(const OptionCss& b) const;
    String toDbgString() const;

    const AzOptionCss& inner() const { return inner_; }
    AzOptionCss& inner() { return inner_; }
    const AzOptionCss* ptr() const { return &inner_; }
    AzOptionCss* ptr() { return &inner_; }
    AzOptionCss release() { AzOptionCss result = inner_; inner_ = {}; return result; }
    operator AzOptionCss() && noexcept { AzOptionCss result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCss_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCss_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCss& unwrap() const { return inner_.Some.payload; }
    AzCss& unwrap() { return inner_.Some.payload; }
    AzCss unwrapOr(const AzCss& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCss> toStdOptional() const { return isSome() ? std::optional<AzCss>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCss>() const { return toStdOptional(); }
};

class OptionStyleBackgroundSize {
private:
    AzOptionStyleBackgroundSize inner_;

    OptionStyleBackgroundSize(const OptionStyleBackgroundSize&) = delete;
    OptionStyleBackgroundSize& operator=(const OptionStyleBackgroundSize&) = delete;

public:
    explicit OptionStyleBackgroundSize(AzOptionStyleBackgroundSize inner) noexcept : inner_(inner) {}

    OptionStyleBackgroundSize(OptionStyleBackgroundSize&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionStyleBackgroundSize& operator=(OptionStyleBackgroundSize&& other) noexcept {
        if (this != &other) {
            AzOptionStyleBackgroundSize_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionStyleBackgroundSize() { AzOptionStyleBackgroundSize_delete(&inner_); }

    static OptionStyleBackgroundSize none();
    static OptionStyleBackgroundSize some(AzStyleBackgroundSize payload);
    void delete_();
    OptionStyleBackgroundSize clone() const;
    bool partialEq(const OptionStyleBackgroundSize& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionStyleBackgroundSize& b) const;
    uint8_t cmp(const OptionStyleBackgroundSize& b) const;
    String toDbgString() const;

    const AzOptionStyleBackgroundSize& inner() const { return inner_; }
    AzOptionStyleBackgroundSize& inner() { return inner_; }
    const AzOptionStyleBackgroundSize* ptr() const { return &inner_; }
    AzOptionStyleBackgroundSize* ptr() { return &inner_; }
    AzOptionStyleBackgroundSize release() { AzOptionStyleBackgroundSize result = inner_; inner_ = {}; return result; }
    operator AzOptionStyleBackgroundSize() && noexcept { AzOptionStyleBackgroundSize result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionStyleBackgroundSize_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionStyleBackgroundSize_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzStyleBackgroundSize& unwrap() const { return inner_.Some.payload; }
    AzStyleBackgroundSize& unwrap() { return inner_.Some.payload; }
    AzStyleBackgroundSize unwrapOr(const AzStyleBackgroundSize& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzStyleBackgroundSize> toStdOptional() const { return isSome() ? std::optional<AzStyleBackgroundSize>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzStyleBackgroundSize>() const { return toStdOptional(); }
};

class OptionSelection {
private:
    AzOptionSelection inner_;

public:
    OptionSelection(AzOptionSelection inner) noexcept : inner_(inner) {}
    OptionSelection(const OptionSelection& other) noexcept : inner_(other.inner_) {}
    OptionSelection& operator=(const OptionSelection& other) noexcept { inner_ = other.inner_; return *this; }
    ~OptionSelection() {}

    static OptionSelection none();
    static OptionSelection some(AzSelection payload);
    bool partialEq(const OptionSelection& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionSelection& b) const;
    uint8_t cmp(const OptionSelection& b) const;
    String toDbgString() const;

    const AzOptionSelection& inner() const { return inner_; }
    AzOptionSelection& inner() { return inner_; }
    const AzOptionSelection* ptr() const { return &inner_; }
    AzOptionSelection* ptr() { return &inner_; }
    AzOptionSelection release() { AzOptionSelection result = inner_; inner_ = {}; return result; }
    operator AzOptionSelection() && noexcept { AzOptionSelection result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionSelection_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionSelection_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzSelection& unwrap() const { return inner_.Some.payload; }
    AzSelection& unwrap() { return inner_.Some.payload; }
    AzSelection unwrapOr(const AzSelection& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzSelection> toStdOptional() const { return isSome() ? std::optional<AzSelection>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzSelection>() const { return toStdOptional(); }
};

class OptionContentGroup {
private:
    AzOptionContentGroup inner_;

    OptionContentGroup(const OptionContentGroup&) = delete;
    OptionContentGroup& operator=(const OptionContentGroup&) = delete;

public:
    explicit OptionContentGroup(AzOptionContentGroup inner) noexcept : inner_(inner) {}

    OptionContentGroup(OptionContentGroup&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionContentGroup& operator=(OptionContentGroup&& other) noexcept {
        if (this != &other) {
            AzOptionContentGroup_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionContentGroup() { AzOptionContentGroup_delete(&inner_); }

    static OptionContentGroup none();
    static OptionContentGroup some(ContentGroup payload);
    void delete_();
    OptionContentGroup clone() const;
    bool partialEq(const OptionContentGroup& b) const;
    uint8_t partialCmp(const OptionContentGroup& b) const;
    String toDbgString() const;

    const AzOptionContentGroup& inner() const { return inner_; }
    AzOptionContentGroup& inner() { return inner_; }
    const AzOptionContentGroup* ptr() const { return &inner_; }
    AzOptionContentGroup* ptr() { return &inner_; }
    AzOptionContentGroup release() { AzOptionContentGroup result = inner_; inner_ = {}; return result; }
    operator AzOptionContentGroup() && noexcept { AzOptionContentGroup result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionContentGroup_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionContentGroup_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzContentGroup& unwrap() const { return inner_.Some.payload; }
    AzContentGroup& unwrap() { return inner_.Some.payload; }
    AzContentGroup unwrapOr(const AzContentGroup& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzContentGroup> toStdOptional() const { return isSome() ? std::optional<AzContentGroup>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzContentGroup>() const { return toStdOptional(); }
};

class OptionSvgPath {
private:
    AzOptionSvgPath inner_;

    OptionSvgPath(const OptionSvgPath&) = delete;
    OptionSvgPath& operator=(const OptionSvgPath&) = delete;

public:
    explicit OptionSvgPath(AzOptionSvgPath inner) noexcept : inner_(inner) {}

    OptionSvgPath(OptionSvgPath&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionSvgPath& operator=(OptionSvgPath&& other) noexcept {
        if (this != &other) {
            AzOptionSvgPath_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionSvgPath() { AzOptionSvgPath_delete(&inner_); }

    static OptionSvgPath none();
    static OptionSvgPath some(SvgPath payload);
    void delete_();
    OptionSvgPath clone() const;
    bool partialEq(const OptionSvgPath& b) const;
    uint8_t partialCmp(const OptionSvgPath& b) const;
    String toDbgString() const;

    const AzOptionSvgPath& inner() const { return inner_; }
    AzOptionSvgPath& inner() { return inner_; }
    const AzOptionSvgPath* ptr() const { return &inner_; }
    AzOptionSvgPath* ptr() { return &inner_; }
    AzOptionSvgPath release() { AzOptionSvgPath result = inner_; inner_ = {}; return result; }
    operator AzOptionSvgPath() && noexcept { AzOptionSvgPath result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionSvgPath_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionSvgPath_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzSvgPath& unwrap() const { return inner_.Some.payload; }
    AzSvgPath& unwrap() { return inner_.Some.payload; }
    AzSvgPath unwrapOr(const AzSvgPath& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzSvgPath> toStdOptional() const { return isSome() ? std::optional<AzSvgPath>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzSvgPath>() const { return toStdOptional(); }
};

class OptionVideoFrame {
private:
    AzOptionVideoFrame inner_;

    OptionVideoFrame(const OptionVideoFrame&) = delete;
    OptionVideoFrame& operator=(const OptionVideoFrame&) = delete;

public:
    explicit OptionVideoFrame(AzOptionVideoFrame inner) noexcept : inner_(inner) {}

    OptionVideoFrame(OptionVideoFrame&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionVideoFrame& operator=(OptionVideoFrame&& other) noexcept {
        if (this != &other) {
            AzOptionVideoFrame_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionVideoFrame() { AzOptionVideoFrame_delete(&inner_); }

    static OptionVideoFrame none();
    static OptionVideoFrame some(VideoFrame payload);
    void delete_();
    OptionVideoFrame clone() const;
    String toDbgString() const;

    const AzOptionVideoFrame& inner() const { return inner_; }
    AzOptionVideoFrame& inner() { return inner_; }
    const AzOptionVideoFrame* ptr() const { return &inner_; }
    AzOptionVideoFrame* ptr() { return &inner_; }
    AzOptionVideoFrame release() { AzOptionVideoFrame result = inner_; inner_ = {}; return result; }
    operator AzOptionVideoFrame() && noexcept { AzOptionVideoFrame result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionVideoFrame_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionVideoFrame_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzVideoFrame& unwrap() const { return inner_.Some.payload; }
    AzVideoFrame& unwrap() { return inner_.Some.payload; }
    AzVideoFrame unwrapOr(const AzVideoFrame& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzVideoFrame> toStdOptional() const { return isSome() ? std::optional<AzVideoFrame>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzVideoFrame>() const { return toStdOptional(); }
};

class ResultRefAnyString {
private:
    AzResultRefAnyString inner_;

    ResultRefAnyString(const ResultRefAnyString&) = delete;
    ResultRefAnyString& operator=(const ResultRefAnyString&) = delete;

public:
    explicit ResultRefAnyString(AzResultRefAnyString inner) noexcept : inner_(inner) {}

    ResultRefAnyString(ResultRefAnyString&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultRefAnyString& operator=(ResultRefAnyString&& other) noexcept {
        if (this != &other) {
            AzResultRefAnyString_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultRefAnyString() { AzResultRefAnyString_delete(&inner_); }

    static ResultRefAnyString ok(RefAny payload);
    static ResultRefAnyString err(String payload);
    void delete_();
    ResultRefAnyString clone() const;
    String toDbgString() const;

    const AzResultRefAnyString& inner() const { return inner_; }
    AzResultRefAnyString& inner() { return inner_; }
    const AzResultRefAnyString* ptr() const { return &inner_; }
    AzResultRefAnyString* ptr() { return &inner_; }
    AzResultRefAnyString release() { AzResultRefAnyString result = inner_; inner_ = {}; return result; }
    operator AzResultRefAnyString() && noexcept { AzResultRefAnyString result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultRefAnyString_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultRefAnyString_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultU8VecString {
private:
    AzResultU8VecString inner_;

    ResultU8VecString(const ResultU8VecString&) = delete;
    ResultU8VecString& operator=(const ResultU8VecString&) = delete;

public:
    explicit ResultU8VecString(AzResultU8VecString inner) noexcept : inner_(inner) {}

    ResultU8VecString(ResultU8VecString&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultU8VecString& operator=(ResultU8VecString&& other) noexcept {
        if (this != &other) {
            AzResultU8VecString_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultU8VecString() { AzResultU8VecString_delete(&inner_); }

    static ResultU8VecString ok(U8Vec payload);
    static ResultU8VecString err(String payload);
    void delete_();
    ResultU8VecString clone() const;
    String toDbgString() const;

    const AzResultU8VecString& inner() const { return inner_; }
    AzResultU8VecString& inner() { return inner_; }
    const AzResultU8VecString* ptr() const { return &inner_; }
    AzResultU8VecString* ptr() { return &inner_; }
    AzResultU8VecString release() { AzResultU8VecString result = inner_; inner_ = {}; return result; }
    operator AzResultU8VecString() && noexcept { AzResultU8VecString result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultU8VecString_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultU8VecString_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultVoidString {
private:
    AzResultVoidString inner_;

    ResultVoidString(const ResultVoidString&) = delete;
    ResultVoidString& operator=(const ResultVoidString&) = delete;

public:
    explicit ResultVoidString(AzResultVoidString inner) noexcept : inner_(inner) {}

    ResultVoidString(ResultVoidString&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultVoidString& operator=(ResultVoidString&& other) noexcept {
        if (this != &other) {
            AzResultVoidString_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultVoidString() { AzResultVoidString_delete(&inner_); }

    static ResultVoidString ok();
    static ResultVoidString err(String payload);
    void delete_();
    ResultVoidString clone() const;
    String toDbgString() const;

    const AzResultVoidString& inner() const { return inner_; }
    AzResultVoidString& inner() { return inner_; }
    const AzResultVoidString* ptr() const { return &inner_; }
    AzResultVoidString* ptr() { return &inner_; }
    AzResultVoidString release() { AzResultVoidString result = inner_; inner_ = {}; return result; }
    operator AzResultVoidString() && noexcept { AzResultVoidString result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultVoidString_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultVoidString_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultStringString {
private:
    AzResultStringString inner_;

    ResultStringString(const ResultStringString&) = delete;
    ResultStringString& operator=(const ResultStringString&) = delete;

public:
    explicit ResultStringString(AzResultStringString inner) noexcept : inner_(inner) {}

    ResultStringString(ResultStringString&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultStringString& operator=(ResultStringString&& other) noexcept {
        if (this != &other) {
            AzResultStringString_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultStringString() { AzResultStringString_delete(&inner_); }

    static ResultStringString ok(String payload);
    static ResultStringString err(String payload);
    void delete_();
    ResultStringString clone() const;
    String toDbgString() const;

    const AzResultStringString& inner() const { return inner_; }
    AzResultStringString& inner() { return inner_; }
    const AzResultStringString* ptr() const { return &inner_; }
    AzResultStringString* ptr() { return &inner_; }
    AzResultStringString release() { AzResultStringString result = inner_; inner_ = {}; return result; }
    operator AzResultStringString() && noexcept { AzResultStringString result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultStringString_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultStringString_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class OptionListViewOnRowClick {
private:
    AzOptionListViewOnRowClick inner_;

    OptionListViewOnRowClick(const OptionListViewOnRowClick&) = delete;
    OptionListViewOnRowClick& operator=(const OptionListViewOnRowClick&) = delete;

public:
    explicit OptionListViewOnRowClick(AzOptionListViewOnRowClick inner) noexcept : inner_(inner) {}

    OptionListViewOnRowClick(OptionListViewOnRowClick&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionListViewOnRowClick& operator=(OptionListViewOnRowClick&& other) noexcept {
        if (this != &other) {
            AzOptionListViewOnRowClick_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionListViewOnRowClick() { AzOptionListViewOnRowClick_delete(&inner_); }

    static OptionListViewOnRowClick none();
    static OptionListViewOnRowClick some(ListViewOnRowClick payload);
    void delete_();
    OptionListViewOnRowClick clone() const;
    bool partialEq(const OptionListViewOnRowClick& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionListViewOnRowClick& b) const;
    uint8_t cmp(const OptionListViewOnRowClick& b) const;
    String toDbgString() const;

    const AzOptionListViewOnRowClick& inner() const { return inner_; }
    AzOptionListViewOnRowClick& inner() { return inner_; }
    const AzOptionListViewOnRowClick* ptr() const { return &inner_; }
    AzOptionListViewOnRowClick* ptr() { return &inner_; }
    AzOptionListViewOnRowClick release() { AzOptionListViewOnRowClick result = inner_; inner_ = {}; return result; }
    operator AzOptionListViewOnRowClick() && noexcept { AzOptionListViewOnRowClick result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionListViewOnRowClick_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionListViewOnRowClick_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzListViewOnRowClick& unwrap() const { return inner_.Some.payload; }
    AzListViewOnRowClick& unwrap() { return inner_.Some.payload; }
    AzListViewOnRowClick unwrapOr(const AzListViewOnRowClick& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzListViewOnRowClick> toStdOptional() const { return isSome() ? std::optional<AzListViewOnRowClick>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzListViewOnRowClick>() const { return toStdOptional(); }
};

class OptionListViewOnColumnClick {
private:
    AzOptionListViewOnColumnClick inner_;

    OptionListViewOnColumnClick(const OptionListViewOnColumnClick&) = delete;
    OptionListViewOnColumnClick& operator=(const OptionListViewOnColumnClick&) = delete;

public:
    explicit OptionListViewOnColumnClick(AzOptionListViewOnColumnClick inner) noexcept : inner_(inner) {}

    OptionListViewOnColumnClick(OptionListViewOnColumnClick&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionListViewOnColumnClick& operator=(OptionListViewOnColumnClick&& other) noexcept {
        if (this != &other) {
            AzOptionListViewOnColumnClick_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionListViewOnColumnClick() { AzOptionListViewOnColumnClick_delete(&inner_); }

    static OptionListViewOnColumnClick none();
    static OptionListViewOnColumnClick some(ListViewOnColumnClick payload);
    void delete_();
    OptionListViewOnColumnClick clone() const;
    bool partialEq(const OptionListViewOnColumnClick& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionListViewOnColumnClick& b) const;
    uint8_t cmp(const OptionListViewOnColumnClick& b) const;
    String toDbgString() const;

    const AzOptionListViewOnColumnClick& inner() const { return inner_; }
    AzOptionListViewOnColumnClick& inner() { return inner_; }
    const AzOptionListViewOnColumnClick* ptr() const { return &inner_; }
    AzOptionListViewOnColumnClick* ptr() { return &inner_; }
    AzOptionListViewOnColumnClick release() { AzOptionListViewOnColumnClick result = inner_; inner_ = {}; return result; }
    operator AzOptionListViewOnColumnClick() && noexcept { AzOptionListViewOnColumnClick result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionListViewOnColumnClick_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionListViewOnColumnClick_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzListViewOnColumnClick& unwrap() const { return inner_.Some.payload; }
    AzListViewOnColumnClick& unwrap() { return inner_.Some.payload; }
    AzListViewOnColumnClick unwrapOr(const AzListViewOnColumnClick& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzListViewOnColumnClick> toStdOptional() const { return isSome() ? std::optional<AzListViewOnColumnClick>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzListViewOnColumnClick>() const { return toStdOptional(); }
};

class OptionListViewOnLazyLoadScroll {
private:
    AzOptionListViewOnLazyLoadScroll inner_;

    OptionListViewOnLazyLoadScroll(const OptionListViewOnLazyLoadScroll&) = delete;
    OptionListViewOnLazyLoadScroll& operator=(const OptionListViewOnLazyLoadScroll&) = delete;

public:
    explicit OptionListViewOnLazyLoadScroll(AzOptionListViewOnLazyLoadScroll inner) noexcept : inner_(inner) {}

    OptionListViewOnLazyLoadScroll(OptionListViewOnLazyLoadScroll&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionListViewOnLazyLoadScroll& operator=(OptionListViewOnLazyLoadScroll&& other) noexcept {
        if (this != &other) {
            AzOptionListViewOnLazyLoadScroll_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionListViewOnLazyLoadScroll() { AzOptionListViewOnLazyLoadScroll_delete(&inner_); }

    static OptionListViewOnLazyLoadScroll none();
    static OptionListViewOnLazyLoadScroll some(ListViewOnLazyLoadScroll payload);
    void delete_();
    OptionListViewOnLazyLoadScroll clone() const;
    bool partialEq(const OptionListViewOnLazyLoadScroll& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionListViewOnLazyLoadScroll& b) const;
    uint8_t cmp(const OptionListViewOnLazyLoadScroll& b) const;
    String toDbgString() const;

    const AzOptionListViewOnLazyLoadScroll& inner() const { return inner_; }
    AzOptionListViewOnLazyLoadScroll& inner() { return inner_; }
    const AzOptionListViewOnLazyLoadScroll* ptr() const { return &inner_; }
    AzOptionListViewOnLazyLoadScroll* ptr() { return &inner_; }
    AzOptionListViewOnLazyLoadScroll release() { AzOptionListViewOnLazyLoadScroll result = inner_; inner_ = {}; return result; }
    operator AzOptionListViewOnLazyLoadScroll() && noexcept { AzOptionListViewOnLazyLoadScroll result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionListViewOnLazyLoadScroll_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionListViewOnLazyLoadScroll_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzListViewOnLazyLoadScroll& unwrap() const { return inner_.Some.payload; }
    AzListViewOnLazyLoadScroll& unwrap() { return inner_.Some.payload; }
    AzListViewOnLazyLoadScroll unwrapOr(const AzListViewOnLazyLoadScroll& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzListViewOnLazyLoadScroll> toStdOptional() const { return isSome() ? std::optional<AzListViewOnLazyLoadScroll>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzListViewOnLazyLoadScroll>() const { return toStdOptional(); }
};

class OptionColorInputOnValueChange {
private:
    AzOptionColorInputOnValueChange inner_;

    OptionColorInputOnValueChange(const OptionColorInputOnValueChange&) = delete;
    OptionColorInputOnValueChange& operator=(const OptionColorInputOnValueChange&) = delete;

public:
    explicit OptionColorInputOnValueChange(AzOptionColorInputOnValueChange inner) noexcept : inner_(inner) {}

    OptionColorInputOnValueChange(OptionColorInputOnValueChange&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionColorInputOnValueChange& operator=(OptionColorInputOnValueChange&& other) noexcept {
        if (this != &other) {
            AzOptionColorInputOnValueChange_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionColorInputOnValueChange() { AzOptionColorInputOnValueChange_delete(&inner_); }

    static OptionColorInputOnValueChange none();
    static OptionColorInputOnValueChange some(ColorInputOnValueChange payload);
    void delete_();
    OptionColorInputOnValueChange clone() const;
    bool partialEq(const OptionColorInputOnValueChange& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionColorInputOnValueChange& b) const;
    uint8_t cmp(const OptionColorInputOnValueChange& b) const;
    String toDbgString() const;

    const AzOptionColorInputOnValueChange& inner() const { return inner_; }
    AzOptionColorInputOnValueChange& inner() { return inner_; }
    const AzOptionColorInputOnValueChange* ptr() const { return &inner_; }
    AzOptionColorInputOnValueChange* ptr() { return &inner_; }
    AzOptionColorInputOnValueChange release() { AzOptionColorInputOnValueChange result = inner_; inner_ = {}; return result; }
    operator AzOptionColorInputOnValueChange() && noexcept { AzOptionColorInputOnValueChange result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionColorInputOnValueChange_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionColorInputOnValueChange_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzColorInputOnValueChange& unwrap() const { return inner_.Some.payload; }
    AzColorInputOnValueChange& unwrap() { return inner_.Some.payload; }
    AzColorInputOnValueChange unwrapOr(const AzColorInputOnValueChange& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzColorInputOnValueChange> toStdOptional() const { return isSome() ? std::optional<AzColorInputOnValueChange>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzColorInputOnValueChange>() const { return toStdOptional(); }
};

class OptionButtonOnClick {
private:
    AzOptionButtonOnClick inner_;

    OptionButtonOnClick(const OptionButtonOnClick&) = delete;
    OptionButtonOnClick& operator=(const OptionButtonOnClick&) = delete;

public:
    explicit OptionButtonOnClick(AzOptionButtonOnClick inner) noexcept : inner_(inner) {}

    OptionButtonOnClick(OptionButtonOnClick&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionButtonOnClick& operator=(OptionButtonOnClick&& other) noexcept {
        if (this != &other) {
            AzOptionButtonOnClick_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionButtonOnClick() { AzOptionButtonOnClick_delete(&inner_); }

    static OptionButtonOnClick none();
    static OptionButtonOnClick some(ButtonOnClick payload);
    void delete_();
    OptionButtonOnClick clone() const;
    bool partialEq(const OptionButtonOnClick& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionButtonOnClick& b) const;
    uint8_t cmp(const OptionButtonOnClick& b) const;
    String toDbgString() const;

    const AzOptionButtonOnClick& inner() const { return inner_; }
    AzOptionButtonOnClick& inner() { return inner_; }
    const AzOptionButtonOnClick* ptr() const { return &inner_; }
    AzOptionButtonOnClick* ptr() { return &inner_; }
    AzOptionButtonOnClick release() { AzOptionButtonOnClick result = inner_; inner_ = {}; return result; }
    operator AzOptionButtonOnClick() && noexcept { AzOptionButtonOnClick result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionButtonOnClick_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionButtonOnClick_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzButtonOnClick& unwrap() const { return inner_.Some.payload; }
    AzButtonOnClick& unwrap() { return inner_.Some.payload; }
    AzButtonOnClick unwrapOr(const AzButtonOnClick& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzButtonOnClick> toStdOptional() const { return isSome() ? std::optional<AzButtonOnClick>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzButtonOnClick>() const { return toStdOptional(); }
};

class OptionTabOnClick {
private:
    AzOptionTabOnClick inner_;

    OptionTabOnClick(const OptionTabOnClick&) = delete;
    OptionTabOnClick& operator=(const OptionTabOnClick&) = delete;

public:
    explicit OptionTabOnClick(AzOptionTabOnClick inner) noexcept : inner_(inner) {}

    OptionTabOnClick(OptionTabOnClick&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionTabOnClick& operator=(OptionTabOnClick&& other) noexcept {
        if (this != &other) {
            AzOptionTabOnClick_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionTabOnClick() { AzOptionTabOnClick_delete(&inner_); }

    static OptionTabOnClick none();
    static OptionTabOnClick some(TabOnClick payload);
    void delete_();
    OptionTabOnClick clone() const;
    bool partialEq(const OptionTabOnClick& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionTabOnClick& b) const;
    uint8_t cmp(const OptionTabOnClick& b) const;
    String toDbgString() const;

    const AzOptionTabOnClick& inner() const { return inner_; }
    AzOptionTabOnClick& inner() { return inner_; }
    const AzOptionTabOnClick* ptr() const { return &inner_; }
    AzOptionTabOnClick* ptr() { return &inner_; }
    AzOptionTabOnClick release() { AzOptionTabOnClick result = inner_; inner_ = {}; return result; }
    operator AzOptionTabOnClick() && noexcept { AzOptionTabOnClick result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTabOnClick_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTabOnClick_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTabOnClick& unwrap() const { return inner_.Some.payload; }
    AzTabOnClick& unwrap() { return inner_.Some.payload; }
    AzTabOnClick unwrapOr(const AzTabOnClick& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTabOnClick> toStdOptional() const { return isSome() ? std::optional<AzTabOnClick>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTabOnClick>() const { return toStdOptional(); }
};

class OptionFileInputOnPathChange {
private:
    AzOptionFileInputOnPathChange inner_;

    OptionFileInputOnPathChange(const OptionFileInputOnPathChange&) = delete;
    OptionFileInputOnPathChange& operator=(const OptionFileInputOnPathChange&) = delete;

public:
    explicit OptionFileInputOnPathChange(AzOptionFileInputOnPathChange inner) noexcept : inner_(inner) {}

    OptionFileInputOnPathChange(OptionFileInputOnPathChange&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionFileInputOnPathChange& operator=(OptionFileInputOnPathChange&& other) noexcept {
        if (this != &other) {
            AzOptionFileInputOnPathChange_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionFileInputOnPathChange() { AzOptionFileInputOnPathChange_delete(&inner_); }

    static OptionFileInputOnPathChange none();
    static OptionFileInputOnPathChange some(FileInputOnPathChange payload);
    void delete_();
    OptionFileInputOnPathChange clone() const;
    bool partialEq(const OptionFileInputOnPathChange& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionFileInputOnPathChange& b) const;
    uint8_t cmp(const OptionFileInputOnPathChange& b) const;
    String toDbgString() const;

    const AzOptionFileInputOnPathChange& inner() const { return inner_; }
    AzOptionFileInputOnPathChange& inner() { return inner_; }
    const AzOptionFileInputOnPathChange* ptr() const { return &inner_; }
    AzOptionFileInputOnPathChange* ptr() { return &inner_; }
    AzOptionFileInputOnPathChange release() { AzOptionFileInputOnPathChange result = inner_; inner_ = {}; return result; }
    operator AzOptionFileInputOnPathChange() && noexcept { AzOptionFileInputOnPathChange result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionFileInputOnPathChange_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionFileInputOnPathChange_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzFileInputOnPathChange& unwrap() const { return inner_.Some.payload; }
    AzFileInputOnPathChange& unwrap() { return inner_.Some.payload; }
    AzFileInputOnPathChange unwrapOr(const AzFileInputOnPathChange& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzFileInputOnPathChange> toStdOptional() const { return isSome() ? std::optional<AzFileInputOnPathChange>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzFileInputOnPathChange>() const { return toStdOptional(); }
};

class OptionCheckBoxOnToggle {
private:
    AzOptionCheckBoxOnToggle inner_;

    OptionCheckBoxOnToggle(const OptionCheckBoxOnToggle&) = delete;
    OptionCheckBoxOnToggle& operator=(const OptionCheckBoxOnToggle&) = delete;

public:
    explicit OptionCheckBoxOnToggle(AzOptionCheckBoxOnToggle inner) noexcept : inner_(inner) {}

    OptionCheckBoxOnToggle(OptionCheckBoxOnToggle&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionCheckBoxOnToggle& operator=(OptionCheckBoxOnToggle&& other) noexcept {
        if (this != &other) {
            AzOptionCheckBoxOnToggle_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionCheckBoxOnToggle() { AzOptionCheckBoxOnToggle_delete(&inner_); }

    static OptionCheckBoxOnToggle none();
    static OptionCheckBoxOnToggle some(CheckBoxOnToggle payload);
    void delete_();
    OptionCheckBoxOnToggle clone() const;
    bool partialEq(const OptionCheckBoxOnToggle& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionCheckBoxOnToggle& b) const;
    uint8_t cmp(const OptionCheckBoxOnToggle& b) const;
    String toDbgString() const;

    const AzOptionCheckBoxOnToggle& inner() const { return inner_; }
    AzOptionCheckBoxOnToggle& inner() { return inner_; }
    const AzOptionCheckBoxOnToggle* ptr() const { return &inner_; }
    AzOptionCheckBoxOnToggle* ptr() { return &inner_; }
    AzOptionCheckBoxOnToggle release() { AzOptionCheckBoxOnToggle result = inner_; inner_ = {}; return result; }
    operator AzOptionCheckBoxOnToggle() && noexcept { AzOptionCheckBoxOnToggle result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCheckBoxOnToggle_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCheckBoxOnToggle_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCheckBoxOnToggle& unwrap() const { return inner_.Some.payload; }
    AzCheckBoxOnToggle& unwrap() { return inner_.Some.payload; }
    AzCheckBoxOnToggle unwrapOr(const AzCheckBoxOnToggle& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCheckBoxOnToggle> toStdOptional() const { return isSome() ? std::optional<AzCheckBoxOnToggle>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCheckBoxOnToggle>() const { return toStdOptional(); }
};

class OptionDropDownOnChoiceChange {
private:
    AzOptionDropDownOnChoiceChange inner_;

    OptionDropDownOnChoiceChange(const OptionDropDownOnChoiceChange&) = delete;
    OptionDropDownOnChoiceChange& operator=(const OptionDropDownOnChoiceChange&) = delete;

public:
    explicit OptionDropDownOnChoiceChange(AzOptionDropDownOnChoiceChange inner) noexcept : inner_(inner) {}

    OptionDropDownOnChoiceChange(OptionDropDownOnChoiceChange&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionDropDownOnChoiceChange& operator=(OptionDropDownOnChoiceChange&& other) noexcept {
        if (this != &other) {
            AzOptionDropDownOnChoiceChange_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionDropDownOnChoiceChange() { AzOptionDropDownOnChoiceChange_delete(&inner_); }

    static OptionDropDownOnChoiceChange none();
    static OptionDropDownOnChoiceChange some(DropDownOnChoiceChange payload);
    void delete_();
    OptionDropDownOnChoiceChange clone() const;
    bool partialEq(const OptionDropDownOnChoiceChange& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionDropDownOnChoiceChange& b) const;
    uint8_t cmp(const OptionDropDownOnChoiceChange& b) const;
    String toDbgString() const;

    const AzOptionDropDownOnChoiceChange& inner() const { return inner_; }
    AzOptionDropDownOnChoiceChange& inner() { return inner_; }
    const AzOptionDropDownOnChoiceChange* ptr() const { return &inner_; }
    AzOptionDropDownOnChoiceChange* ptr() { return &inner_; }
    AzOptionDropDownOnChoiceChange release() { AzOptionDropDownOnChoiceChange result = inner_; inner_ = {}; return result; }
    operator AzOptionDropDownOnChoiceChange() && noexcept { AzOptionDropDownOnChoiceChange result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDropDownOnChoiceChange_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDropDownOnChoiceChange_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDropDownOnChoiceChange& unwrap() const { return inner_.Some.payload; }
    AzDropDownOnChoiceChange& unwrap() { return inner_.Some.payload; }
    AzDropDownOnChoiceChange unwrapOr(const AzDropDownOnChoiceChange& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDropDownOnChoiceChange> toStdOptional() const { return isSome() ? std::optional<AzDropDownOnChoiceChange>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDropDownOnChoiceChange>() const { return toStdOptional(); }
};

class OptionTextInputOnTextInput {
private:
    AzOptionTextInputOnTextInput inner_;

    OptionTextInputOnTextInput(const OptionTextInputOnTextInput&) = delete;
    OptionTextInputOnTextInput& operator=(const OptionTextInputOnTextInput&) = delete;

public:
    explicit OptionTextInputOnTextInput(AzOptionTextInputOnTextInput inner) noexcept : inner_(inner) {}

    OptionTextInputOnTextInput(OptionTextInputOnTextInput&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionTextInputOnTextInput& operator=(OptionTextInputOnTextInput&& other) noexcept {
        if (this != &other) {
            AzOptionTextInputOnTextInput_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionTextInputOnTextInput() { AzOptionTextInputOnTextInput_delete(&inner_); }

    static OptionTextInputOnTextInput none();
    static OptionTextInputOnTextInput some(TextInputOnTextInput payload);
    void delete_();
    OptionTextInputOnTextInput clone() const;
    bool partialEq(const OptionTextInputOnTextInput& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionTextInputOnTextInput& b) const;
    uint8_t cmp(const OptionTextInputOnTextInput& b) const;
    String toDbgString() const;

    const AzOptionTextInputOnTextInput& inner() const { return inner_; }
    AzOptionTextInputOnTextInput& inner() { return inner_; }
    const AzOptionTextInputOnTextInput* ptr() const { return &inner_; }
    AzOptionTextInputOnTextInput* ptr() { return &inner_; }
    AzOptionTextInputOnTextInput release() { AzOptionTextInputOnTextInput result = inner_; inner_ = {}; return result; }
    operator AzOptionTextInputOnTextInput() && noexcept { AzOptionTextInputOnTextInput result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTextInputOnTextInput_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTextInputOnTextInput_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTextInputOnTextInput& unwrap() const { return inner_.Some.payload; }
    AzTextInputOnTextInput& unwrap() { return inner_.Some.payload; }
    AzTextInputOnTextInput unwrapOr(const AzTextInputOnTextInput& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTextInputOnTextInput> toStdOptional() const { return isSome() ? std::optional<AzTextInputOnTextInput>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTextInputOnTextInput>() const { return toStdOptional(); }
};

class OptionTextInputOnVirtualKeyDown {
private:
    AzOptionTextInputOnVirtualKeyDown inner_;

    OptionTextInputOnVirtualKeyDown(const OptionTextInputOnVirtualKeyDown&) = delete;
    OptionTextInputOnVirtualKeyDown& operator=(const OptionTextInputOnVirtualKeyDown&) = delete;

public:
    explicit OptionTextInputOnVirtualKeyDown(AzOptionTextInputOnVirtualKeyDown inner) noexcept : inner_(inner) {}

    OptionTextInputOnVirtualKeyDown(OptionTextInputOnVirtualKeyDown&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionTextInputOnVirtualKeyDown& operator=(OptionTextInputOnVirtualKeyDown&& other) noexcept {
        if (this != &other) {
            AzOptionTextInputOnVirtualKeyDown_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionTextInputOnVirtualKeyDown() { AzOptionTextInputOnVirtualKeyDown_delete(&inner_); }

    static OptionTextInputOnVirtualKeyDown none();
    static OptionTextInputOnVirtualKeyDown some(TextInputOnVirtualKeyDown payload);
    void delete_();
    OptionTextInputOnVirtualKeyDown clone() const;
    bool partialEq(const OptionTextInputOnVirtualKeyDown& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionTextInputOnVirtualKeyDown& b) const;
    uint8_t cmp(const OptionTextInputOnVirtualKeyDown& b) const;
    String toDbgString() const;

    const AzOptionTextInputOnVirtualKeyDown& inner() const { return inner_; }
    AzOptionTextInputOnVirtualKeyDown& inner() { return inner_; }
    const AzOptionTextInputOnVirtualKeyDown* ptr() const { return &inner_; }
    AzOptionTextInputOnVirtualKeyDown* ptr() { return &inner_; }
    AzOptionTextInputOnVirtualKeyDown release() { AzOptionTextInputOnVirtualKeyDown result = inner_; inner_ = {}; return result; }
    operator AzOptionTextInputOnVirtualKeyDown() && noexcept { AzOptionTextInputOnVirtualKeyDown result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTextInputOnVirtualKeyDown_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTextInputOnVirtualKeyDown_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTextInputOnVirtualKeyDown& unwrap() const { return inner_.Some.payload; }
    AzTextInputOnVirtualKeyDown& unwrap() { return inner_.Some.payload; }
    AzTextInputOnVirtualKeyDown unwrapOr(const AzTextInputOnVirtualKeyDown& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTextInputOnVirtualKeyDown> toStdOptional() const { return isSome() ? std::optional<AzTextInputOnVirtualKeyDown>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTextInputOnVirtualKeyDown>() const { return toStdOptional(); }
};

class OptionTextInputOnFocusLost {
private:
    AzOptionTextInputOnFocusLost inner_;

    OptionTextInputOnFocusLost(const OptionTextInputOnFocusLost&) = delete;
    OptionTextInputOnFocusLost& operator=(const OptionTextInputOnFocusLost&) = delete;

public:
    explicit OptionTextInputOnFocusLost(AzOptionTextInputOnFocusLost inner) noexcept : inner_(inner) {}

    OptionTextInputOnFocusLost(OptionTextInputOnFocusLost&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionTextInputOnFocusLost& operator=(OptionTextInputOnFocusLost&& other) noexcept {
        if (this != &other) {
            AzOptionTextInputOnFocusLost_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionTextInputOnFocusLost() { AzOptionTextInputOnFocusLost_delete(&inner_); }

    static OptionTextInputOnFocusLost none();
    static OptionTextInputOnFocusLost some(TextInputOnFocusLost payload);
    void delete_();
    OptionTextInputOnFocusLost clone() const;
    bool partialEq(const OptionTextInputOnFocusLost& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionTextInputOnFocusLost& b) const;
    uint8_t cmp(const OptionTextInputOnFocusLost& b) const;
    String toDbgString() const;

    const AzOptionTextInputOnFocusLost& inner() const { return inner_; }
    AzOptionTextInputOnFocusLost& inner() { return inner_; }
    const AzOptionTextInputOnFocusLost* ptr() const { return &inner_; }
    AzOptionTextInputOnFocusLost* ptr() { return &inner_; }
    AzOptionTextInputOnFocusLost release() { AzOptionTextInputOnFocusLost result = inner_; inner_ = {}; return result; }
    operator AzOptionTextInputOnFocusLost() && noexcept { AzOptionTextInputOnFocusLost result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTextInputOnFocusLost_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTextInputOnFocusLost_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTextInputOnFocusLost& unwrap() const { return inner_.Some.payload; }
    AzTextInputOnFocusLost& unwrap() { return inner_.Some.payload; }
    AzTextInputOnFocusLost unwrapOr(const AzTextInputOnFocusLost& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTextInputOnFocusLost> toStdOptional() const { return isSome() ? std::optional<AzTextInputOnFocusLost>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTextInputOnFocusLost>() const { return toStdOptional(); }
};

class OptionNumberInputOnFocusLost {
private:
    AzOptionNumberInputOnFocusLost inner_;

    OptionNumberInputOnFocusLost(const OptionNumberInputOnFocusLost&) = delete;
    OptionNumberInputOnFocusLost& operator=(const OptionNumberInputOnFocusLost&) = delete;

public:
    explicit OptionNumberInputOnFocusLost(AzOptionNumberInputOnFocusLost inner) noexcept : inner_(inner) {}

    OptionNumberInputOnFocusLost(OptionNumberInputOnFocusLost&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionNumberInputOnFocusLost& operator=(OptionNumberInputOnFocusLost&& other) noexcept {
        if (this != &other) {
            AzOptionNumberInputOnFocusLost_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionNumberInputOnFocusLost() { AzOptionNumberInputOnFocusLost_delete(&inner_); }

    static OptionNumberInputOnFocusLost none();
    static OptionNumberInputOnFocusLost some(NumberInputOnFocusLost payload);
    void delete_();
    OptionNumberInputOnFocusLost clone() const;
    bool partialEq(const OptionNumberInputOnFocusLost& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionNumberInputOnFocusLost& b) const;
    uint8_t cmp(const OptionNumberInputOnFocusLost& b) const;
    String toDbgString() const;

    const AzOptionNumberInputOnFocusLost& inner() const { return inner_; }
    AzOptionNumberInputOnFocusLost& inner() { return inner_; }
    const AzOptionNumberInputOnFocusLost* ptr() const { return &inner_; }
    AzOptionNumberInputOnFocusLost* ptr() { return &inner_; }
    AzOptionNumberInputOnFocusLost release() { AzOptionNumberInputOnFocusLost result = inner_; inner_ = {}; return result; }
    operator AzOptionNumberInputOnFocusLost() && noexcept { AzOptionNumberInputOnFocusLost result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionNumberInputOnFocusLost_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionNumberInputOnFocusLost_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzNumberInputOnFocusLost& unwrap() const { return inner_.Some.payload; }
    AzNumberInputOnFocusLost& unwrap() { return inner_.Some.payload; }
    AzNumberInputOnFocusLost unwrapOr(const AzNumberInputOnFocusLost& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzNumberInputOnFocusLost> toStdOptional() const { return isSome() ? std::optional<AzNumberInputOnFocusLost>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzNumberInputOnFocusLost>() const { return toStdOptional(); }
};

class OptionNumberInputOnValueChange {
private:
    AzOptionNumberInputOnValueChange inner_;

    OptionNumberInputOnValueChange(const OptionNumberInputOnValueChange&) = delete;
    OptionNumberInputOnValueChange& operator=(const OptionNumberInputOnValueChange&) = delete;

public:
    explicit OptionNumberInputOnValueChange(AzOptionNumberInputOnValueChange inner) noexcept : inner_(inner) {}

    OptionNumberInputOnValueChange(OptionNumberInputOnValueChange&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionNumberInputOnValueChange& operator=(OptionNumberInputOnValueChange&& other) noexcept {
        if (this != &other) {
            AzOptionNumberInputOnValueChange_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionNumberInputOnValueChange() { AzOptionNumberInputOnValueChange_delete(&inner_); }

    static OptionNumberInputOnValueChange none();
    static OptionNumberInputOnValueChange some(NumberInputOnValueChange payload);
    void delete_();
    OptionNumberInputOnValueChange clone() const;
    bool partialEq(const OptionNumberInputOnValueChange& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionNumberInputOnValueChange& b) const;
    uint8_t cmp(const OptionNumberInputOnValueChange& b) const;
    String toDbgString() const;

    const AzOptionNumberInputOnValueChange& inner() const { return inner_; }
    AzOptionNumberInputOnValueChange& inner() { return inner_; }
    const AzOptionNumberInputOnValueChange* ptr() const { return &inner_; }
    AzOptionNumberInputOnValueChange* ptr() { return &inner_; }
    AzOptionNumberInputOnValueChange release() { AzOptionNumberInputOnValueChange result = inner_; inner_ = {}; return result; }
    operator AzOptionNumberInputOnValueChange() && noexcept { AzOptionNumberInputOnValueChange result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionNumberInputOnValueChange_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionNumberInputOnValueChange_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzNumberInputOnValueChange& unwrap() const { return inner_.Some.payload; }
    AzNumberInputOnValueChange& unwrap() { return inner_.Some.payload; }
    AzNumberInputOnValueChange unwrapOr(const AzNumberInputOnValueChange& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzNumberInputOnValueChange> toStdOptional() const { return isSome() ? std::optional<AzNumberInputOnValueChange>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzNumberInputOnValueChange>() const { return toStdOptional(); }
};

class OptionRawImage {
private:
    AzOptionRawImage inner_;

    OptionRawImage(const OptionRawImage&) = delete;
    OptionRawImage& operator=(const OptionRawImage&) = delete;

public:
    explicit OptionRawImage(AzOptionRawImage inner) noexcept : inner_(inner) {}

    OptionRawImage(OptionRawImage&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionRawImage& operator=(OptionRawImage&& other) noexcept {
        if (this != &other) {
            AzOptionRawImage_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionRawImage() { AzOptionRawImage_delete(&inner_); }

    static OptionRawImage none();
    static OptionRawImage some(RawImage payload);
    void delete_();
    OptionRawImage clone() const;
    bool partialEq(const OptionRawImage& b) const;
    uint8_t partialCmp(const OptionRawImage& b) const;
    String toDbgString() const;

    const AzOptionRawImage& inner() const { return inner_; }
    AzOptionRawImage& inner() { return inner_; }
    const AzOptionRawImage* ptr() const { return &inner_; }
    AzOptionRawImage* ptr() { return &inner_; }
    AzOptionRawImage release() { AzOptionRawImage result = inner_; inner_ = {}; return result; }
    operator AzOptionRawImage() && noexcept { AzOptionRawImage result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionRawImage_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionRawImage_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzRawImage& unwrap() const { return inner_.Some.payload; }
    AzRawImage& unwrap() { return inner_.Some.payload; }
    AzRawImage unwrapOr(const AzRawImage& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzRawImage> toStdOptional() const { return isSome() ? std::optional<AzRawImage>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzRawImage>() const { return toStdOptional(); }
};

class OptionCoreMenuCallback {
private:
    AzOptionCoreMenuCallback inner_;

    OptionCoreMenuCallback(const OptionCoreMenuCallback&) = delete;
    OptionCoreMenuCallback& operator=(const OptionCoreMenuCallback&) = delete;

public:
    explicit OptionCoreMenuCallback(AzOptionCoreMenuCallback inner) noexcept : inner_(inner) {}

    OptionCoreMenuCallback(OptionCoreMenuCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionCoreMenuCallback& operator=(OptionCoreMenuCallback&& other) noexcept {
        if (this != &other) {
            AzOptionCoreMenuCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionCoreMenuCallback() { AzOptionCoreMenuCallback_delete(&inner_); }

    static OptionCoreMenuCallback none();
    static OptionCoreMenuCallback some(CoreMenuCallback payload);
    void delete_();
    OptionCoreMenuCallback clone() const;
    bool partialEq(const OptionCoreMenuCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionCoreMenuCallback& b) const;
    uint8_t cmp(const OptionCoreMenuCallback& b) const;
    String toDbgString() const;

    const AzOptionCoreMenuCallback& inner() const { return inner_; }
    AzOptionCoreMenuCallback& inner() { return inner_; }
    const AzOptionCoreMenuCallback* ptr() const { return &inner_; }
    AzOptionCoreMenuCallback* ptr() { return &inner_; }
    AzOptionCoreMenuCallback release() { AzOptionCoreMenuCallback result = inner_; inner_ = {}; return result; }
    operator AzOptionCoreMenuCallback() && noexcept { AzOptionCoreMenuCallback result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCoreMenuCallback_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCoreMenuCallback_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCoreMenuCallback& unwrap() const { return inner_.Some.payload; }
    AzCoreMenuCallback& unwrap() { return inner_.Some.payload; }
    AzCoreMenuCallback unwrapOr(const AzCoreMenuCallback& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCoreMenuCallback> toStdOptional() const { return isSome() ? std::optional<AzCoreMenuCallback>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCoreMenuCallback>() const { return toStdOptional(); }
};

class OptionWaylandTheme {
private:
    AzOptionWaylandTheme inner_;

    OptionWaylandTheme(const OptionWaylandTheme&) = delete;
    OptionWaylandTheme& operator=(const OptionWaylandTheme&) = delete;

public:
    explicit OptionWaylandTheme(AzOptionWaylandTheme inner) noexcept : inner_(inner) {}

    OptionWaylandTheme(OptionWaylandTheme&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionWaylandTheme& operator=(OptionWaylandTheme&& other) noexcept {
        if (this != &other) {
            AzOptionWaylandTheme_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionWaylandTheme() { AzOptionWaylandTheme_delete(&inner_); }

    static OptionWaylandTheme none();
    static OptionWaylandTheme some(WaylandTheme payload);
    void delete_();
    OptionWaylandTheme clone() const;
    bool partialEq(const OptionWaylandTheme& b) const;
    uint8_t partialCmp(const OptionWaylandTheme& b) const;
    String toDbgString() const;

    const AzOptionWaylandTheme& inner() const { return inner_; }
    AzOptionWaylandTheme& inner() { return inner_; }
    const AzOptionWaylandTheme* ptr() const { return &inner_; }
    AzOptionWaylandTheme* ptr() { return &inner_; }
    AzOptionWaylandTheme release() { AzOptionWaylandTheme result = inner_; inner_ = {}; return result; }
    operator AzOptionWaylandTheme() && noexcept { AzOptionWaylandTheme result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionWaylandTheme_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionWaylandTheme_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzWaylandTheme& unwrap() const { return inner_.Some.payload; }
    AzWaylandTheme& unwrap() { return inner_.Some.payload; }
    AzWaylandTheme unwrapOr(const AzWaylandTheme& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzWaylandTheme> toStdOptional() const { return isSome() ? std::optional<AzWaylandTheme>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzWaylandTheme>() const { return toStdOptional(); }
};

class OptionWindowIcon {
private:
    AzOptionWindowIcon inner_;

    OptionWindowIcon(const OptionWindowIcon&) = delete;
    OptionWindowIcon& operator=(const OptionWindowIcon&) = delete;

public:
    explicit OptionWindowIcon(AzOptionWindowIcon inner) noexcept : inner_(inner) {}

    OptionWindowIcon(OptionWindowIcon&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionWindowIcon& operator=(OptionWindowIcon&& other) noexcept {
        if (this != &other) {
            AzOptionWindowIcon_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionWindowIcon() { AzOptionWindowIcon_delete(&inner_); }

    static OptionWindowIcon none();
    static OptionWindowIcon some(AzWindowIcon payload);
    void delete_();
    OptionWindowIcon clone() const;
    bool partialEq(const OptionWindowIcon& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionWindowIcon& b) const;
    uint8_t cmp(const OptionWindowIcon& b) const;
    String toDbgString() const;

    const AzOptionWindowIcon& inner() const { return inner_; }
    AzOptionWindowIcon& inner() { return inner_; }
    const AzOptionWindowIcon* ptr() const { return &inner_; }
    AzOptionWindowIcon* ptr() { return &inner_; }
    AzOptionWindowIcon release() { AzOptionWindowIcon result = inner_; inner_ = {}; return result; }
    operator AzOptionWindowIcon() && noexcept { AzOptionWindowIcon result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionWindowIcon_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionWindowIcon_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzWindowIcon& unwrap() const { return inner_.Some.payload; }
    AzWindowIcon& unwrap() { return inner_.Some.payload; }
    AzWindowIcon unwrapOr(const AzWindowIcon& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzWindowIcon> toStdOptional() const { return isSome() ? std::optional<AzWindowIcon>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzWindowIcon>() const { return toStdOptional(); }
};

class OptionCoreImageCallback {
private:
    AzOptionCoreImageCallback inner_;

    OptionCoreImageCallback(const OptionCoreImageCallback&) = delete;
    OptionCoreImageCallback& operator=(const OptionCoreImageCallback&) = delete;

public:
    explicit OptionCoreImageCallback(AzOptionCoreImageCallback inner) noexcept : inner_(inner) {}

    OptionCoreImageCallback(OptionCoreImageCallback&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionCoreImageCallback& operator=(OptionCoreImageCallback&& other) noexcept {
        if (this != &other) {
            AzOptionCoreImageCallback_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionCoreImageCallback() { AzOptionCoreImageCallback_delete(&inner_); }

    static OptionCoreImageCallback none();
    static OptionCoreImageCallback some(CoreImageCallback payload);
    void delete_();
    OptionCoreImageCallback clone() const;
    bool partialEq(const OptionCoreImageCallback& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionCoreImageCallback& b) const;
    uint8_t cmp(const OptionCoreImageCallback& b) const;
    String toDbgString() const;

    const AzOptionCoreImageCallback& inner() const { return inner_; }
    AzOptionCoreImageCallback& inner() { return inner_; }
    const AzOptionCoreImageCallback* ptr() const { return &inner_; }
    AzOptionCoreImageCallback* ptr() { return &inner_; }
    AzOptionCoreImageCallback release() { AzOptionCoreImageCallback result = inner_; inner_ = {}; return result; }
    operator AzOptionCoreImageCallback() && noexcept { AzOptionCoreImageCallback result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCoreImageCallback_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCoreImageCallback_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCoreImageCallback& unwrap() const { return inner_.Some.payload; }
    AzCoreImageCallback& unwrap() { return inner_.Some.payload; }
    AzCoreImageCallback unwrapOr(const AzCoreImageCallback& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCoreImageCallback> toStdOptional() const { return isSome() ? std::optional<AzCoreImageCallback>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCoreImageCallback>() const { return toStdOptional(); }
};

class OptionSelectAllResult {
private:
    AzOptionSelectAllResult inner_;

    OptionSelectAllResult(const OptionSelectAllResult&) = delete;
    OptionSelectAllResult& operator=(const OptionSelectAllResult&) = delete;

public:
    explicit OptionSelectAllResult(AzOptionSelectAllResult inner) noexcept : inner_(inner) {}

    OptionSelectAllResult(OptionSelectAllResult&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionSelectAllResult& operator=(OptionSelectAllResult&& other) noexcept {
        if (this != &other) {
            AzOptionSelectAllResult_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionSelectAllResult() { AzOptionSelectAllResult_delete(&inner_); }

    static OptionSelectAllResult none();
    static OptionSelectAllResult some(SelectAllResult payload);
    void delete_();
    OptionSelectAllResult clone() const;
    bool partialEq(const OptionSelectAllResult& b) const;
    String toDbgString() const;

    const AzOptionSelectAllResult& inner() const { return inner_; }
    AzOptionSelectAllResult& inner() { return inner_; }
    const AzOptionSelectAllResult* ptr() const { return &inner_; }
    AzOptionSelectAllResult* ptr() { return &inner_; }
    AzOptionSelectAllResult release() { AzOptionSelectAllResult result = inner_; inner_ = {}; return result; }
    operator AzOptionSelectAllResult() && noexcept { AzOptionSelectAllResult result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionSelectAllResult_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionSelectAllResult_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzSelectAllResult& unwrap() const { return inner_.Some.payload; }
    AzSelectAllResult& unwrap() { return inner_.Some.payload; }
    AzSelectAllResult unwrapOr(const AzSelectAllResult& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzSelectAllResult> toStdOptional() const { return isSome() ? std::optional<AzSelectAllResult>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzSelectAllResult>() const { return toStdOptional(); }
};

class OptionDeleteResult {
private:
    AzOptionDeleteResult inner_;

    OptionDeleteResult(const OptionDeleteResult&) = delete;
    OptionDeleteResult& operator=(const OptionDeleteResult&) = delete;

public:
    explicit OptionDeleteResult(AzOptionDeleteResult inner) noexcept : inner_(inner) {}

    OptionDeleteResult(OptionDeleteResult&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionDeleteResult& operator=(OptionDeleteResult&& other) noexcept {
        if (this != &other) {
            AzOptionDeleteResult_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionDeleteResult() { AzOptionDeleteResult_delete(&inner_); }

    static OptionDeleteResult none();
    static OptionDeleteResult some(DeleteResult payload);
    void delete_();
    OptionDeleteResult clone() const;
    bool partialEq(const OptionDeleteResult& b) const;
    String toDbgString() const;

    const AzOptionDeleteResult& inner() const { return inner_; }
    AzOptionDeleteResult& inner() { return inner_; }
    const AzOptionDeleteResult* ptr() const { return &inner_; }
    AzOptionDeleteResult* ptr() { return &inner_; }
    AzOptionDeleteResult release() { AzOptionDeleteResult result = inner_; inner_ = {}; return result; }
    operator AzOptionDeleteResult() && noexcept { AzOptionDeleteResult result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDeleteResult_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDeleteResult_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDeleteResult& unwrap() const { return inner_.Some.payload; }
    AzDeleteResult& unwrap() { return inner_.Some.payload; }
    AzDeleteResult unwrapOr(const AzDeleteResult& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDeleteResult> toStdOptional() const { return isSome() ? std::optional<AzDeleteResult>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDeleteResult>() const { return toStdOptional(); }
};

class OptionClipboardContent {
private:
    AzOptionClipboardContent inner_;

    OptionClipboardContent(const OptionClipboardContent&) = delete;
    OptionClipboardContent& operator=(const OptionClipboardContent&) = delete;

public:
    explicit OptionClipboardContent(AzOptionClipboardContent inner) noexcept : inner_(inner) {}

    OptionClipboardContent(OptionClipboardContent&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionClipboardContent& operator=(OptionClipboardContent&& other) noexcept {
        if (this != &other) {
            AzOptionClipboardContent_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionClipboardContent() { AzOptionClipboardContent_delete(&inner_); }

    static OptionClipboardContent none();
    static OptionClipboardContent some(ClipboardContent payload);
    void delete_();
    OptionClipboardContent clone() const;
    bool partialEq(const OptionClipboardContent& b) const;
    String toDbgString() const;

    const AzOptionClipboardContent& inner() const { return inner_; }
    AzOptionClipboardContent& inner() { return inner_; }
    const AzOptionClipboardContent* ptr() const { return &inner_; }
    AzOptionClipboardContent* ptr() { return &inner_; }
    AzOptionClipboardContent release() { AzOptionClipboardContent result = inner_; inner_ = {}; return result; }
    operator AzOptionClipboardContent() && noexcept { AzOptionClipboardContent result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionClipboardContent_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionClipboardContent_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzClipboardContent& unwrap() const { return inner_.Some.payload; }
    AzClipboardContent& unwrap() { return inner_.Some.payload; }
    AzClipboardContent unwrapOr(const AzClipboardContent& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzClipboardContent> toStdOptional() const { return isSome() ? std::optional<AzClipboardContent>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzClipboardContent>() const { return toStdOptional(); }
};

class OptionFilePath {
private:
    AzOptionFilePath inner_;

    OptionFilePath(const OptionFilePath&) = delete;
    OptionFilePath& operator=(const OptionFilePath&) = delete;

public:
    explicit OptionFilePath(AzOptionFilePath inner) noexcept : inner_(inner) {}

    OptionFilePath(OptionFilePath&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionFilePath& operator=(OptionFilePath&& other) noexcept {
        if (this != &other) {
            AzOptionFilePath_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionFilePath() { AzOptionFilePath_delete(&inner_); }

    static OptionFilePath none();
    static OptionFilePath some(FilePath payload);
    void delete_();
    OptionFilePath clone() const;
    bool partialEq(const OptionFilePath& b) const;
    String toDbgString() const;

    const AzOptionFilePath& inner() const { return inner_; }
    AzOptionFilePath& inner() { return inner_; }
    const AzOptionFilePath* ptr() const { return &inner_; }
    AzOptionFilePath* ptr() { return &inner_; }
    AzOptionFilePath release() { AzOptionFilePath result = inner_; inner_ = {}; return result; }
    operator AzOptionFilePath() && noexcept { AzOptionFilePath result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionFilePath_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionFilePath_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzFilePath& unwrap() const { return inner_.Some.payload; }
    AzFilePath& unwrap() { return inner_.Some.payload; }
    AzFilePath unwrapOr(const AzFilePath& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzFilePath> toStdOptional() const { return isSome() ? std::optional<AzFilePath>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzFilePath>() const { return toStdOptional(); }
};

class OptionPendingTextEdit {
private:
    AzOptionPendingTextEdit inner_;

    OptionPendingTextEdit(const OptionPendingTextEdit&) = delete;
    OptionPendingTextEdit& operator=(const OptionPendingTextEdit&) = delete;

public:
    explicit OptionPendingTextEdit(AzOptionPendingTextEdit inner) noexcept : inner_(inner) {}

    OptionPendingTextEdit(OptionPendingTextEdit&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionPendingTextEdit& operator=(OptionPendingTextEdit&& other) noexcept {
        if (this != &other) {
            AzOptionPendingTextEdit_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionPendingTextEdit() { AzOptionPendingTextEdit_delete(&inner_); }

    static OptionPendingTextEdit none();
    static OptionPendingTextEdit some(PendingTextEdit payload);
    void delete_();
    OptionPendingTextEdit clone() const;
    String toDbgString() const;

    const AzOptionPendingTextEdit& inner() const { return inner_; }
    AzOptionPendingTextEdit& inner() { return inner_; }
    const AzOptionPendingTextEdit* ptr() const { return &inner_; }
    AzOptionPendingTextEdit* ptr() { return &inner_; }
    AzOptionPendingTextEdit release() { AzOptionPendingTextEdit result = inner_; inner_ = {}; return result; }
    operator AzOptionPendingTextEdit() && noexcept { AzOptionPendingTextEdit result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionPendingTextEdit_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionPendingTextEdit_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzPendingTextEdit& unwrap() const { return inner_.Some.payload; }
    AzPendingTextEdit& unwrap() { return inner_.Some.payload; }
    AzPendingTextEdit unwrapOr(const AzPendingTextEdit& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzPendingTextEdit> toStdOptional() const { return isSome() ? std::optional<AzPendingTextEdit>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzPendingTextEdit>() const { return toStdOptional(); }
};

class OptionMimeTypeHint {
private:
    AzOptionMimeTypeHint inner_;

    OptionMimeTypeHint(const OptionMimeTypeHint&) = delete;
    OptionMimeTypeHint& operator=(const OptionMimeTypeHint&) = delete;

public:
    explicit OptionMimeTypeHint(AzOptionMimeTypeHint inner) noexcept : inner_(inner) {}

    OptionMimeTypeHint(OptionMimeTypeHint&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionMimeTypeHint& operator=(OptionMimeTypeHint&& other) noexcept {
        if (this != &other) {
            AzOptionMimeTypeHint_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionMimeTypeHint() { AzOptionMimeTypeHint_delete(&inner_); }

    static OptionMimeTypeHint none();
    static OptionMimeTypeHint some(MimeTypeHint payload);
    void delete_();
    OptionMimeTypeHint clone() const;
    bool partialEq(const OptionMimeTypeHint& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionMimeTypeHint& b) const;
    uint8_t cmp(const OptionMimeTypeHint& b) const;
    String toDbgString() const;

    const AzOptionMimeTypeHint& inner() const { return inner_; }
    AzOptionMimeTypeHint& inner() { return inner_; }
    const AzOptionMimeTypeHint* ptr() const { return &inner_; }
    AzOptionMimeTypeHint* ptr() { return &inner_; }
    AzOptionMimeTypeHint release() { AzOptionMimeTypeHint result = inner_; inner_ = {}; return result; }
    operator AzOptionMimeTypeHint() && noexcept { AzOptionMimeTypeHint result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionMimeTypeHint_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionMimeTypeHint_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzMimeTypeHint& unwrap() const { return inner_.Some.payload; }
    AzMimeTypeHint& unwrap() { return inner_.Some.payload; }
    AzMimeTypeHint unwrapOr(const AzMimeTypeHint& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzMimeTypeHint> toStdOptional() const { return isSome() ? std::optional<AzMimeTypeHint>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzMimeTypeHint>() const { return toStdOptional(); }
};

class OptionAccessibilityAction {
private:
    AzOptionAccessibilityAction inner_;

    OptionAccessibilityAction(const OptionAccessibilityAction&) = delete;
    OptionAccessibilityAction& operator=(const OptionAccessibilityAction&) = delete;

public:
    explicit OptionAccessibilityAction(AzOptionAccessibilityAction inner) noexcept : inner_(inner) {}

    OptionAccessibilityAction(OptionAccessibilityAction&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionAccessibilityAction& operator=(OptionAccessibilityAction&& other) noexcept {
        if (this != &other) {
            AzOptionAccessibilityAction_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionAccessibilityAction() { AzOptionAccessibilityAction_delete(&inner_); }

    static OptionAccessibilityAction none();
    static OptionAccessibilityAction some(AzAccessibilityAction payload);
    void delete_();
    OptionAccessibilityAction clone() const;
    bool partialEq(const OptionAccessibilityAction& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionAccessibilityAction& b) const;
    uint8_t cmp(const OptionAccessibilityAction& b) const;
    String toDbgString() const;

    const AzOptionAccessibilityAction& inner() const { return inner_; }
    AzOptionAccessibilityAction& inner() { return inner_; }
    const AzOptionAccessibilityAction* ptr() const { return &inner_; }
    AzOptionAccessibilityAction* ptr() { return &inner_; }
    AzOptionAccessibilityAction release() { AzOptionAccessibilityAction result = inner_; inner_ = {}; return result; }
    operator AzOptionAccessibilityAction() && noexcept { AzOptionAccessibilityAction result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionAccessibilityAction_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionAccessibilityAction_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzAccessibilityAction& unwrap() const { return inner_.Some.payload; }
    AzAccessibilityAction& unwrap() { return inner_.Some.payload; }
    AzAccessibilityAction unwrapOr(const AzAccessibilityAction& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzAccessibilityAction> toStdOptional() const { return isSome() ? std::optional<AzAccessibilityAction>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzAccessibilityAction>() const { return toStdOptional(); }
};

class OptionDirEntry {
private:
    AzOptionDirEntry inner_;

    OptionDirEntry(const OptionDirEntry&) = delete;
    OptionDirEntry& operator=(const OptionDirEntry&) = delete;

public:
    explicit OptionDirEntry(AzOptionDirEntry inner) noexcept : inner_(inner) {}

    OptionDirEntry(OptionDirEntry&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionDirEntry& operator=(OptionDirEntry&& other) noexcept {
        if (this != &other) {
            AzOptionDirEntry_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionDirEntry() { AzOptionDirEntry_delete(&inner_); }

    static OptionDirEntry none();
    static OptionDirEntry some(DirEntry payload);
    void delete_();
    OptionDirEntry clone() const;
    String toDbgString() const;

    const AzOptionDirEntry& inner() const { return inner_; }
    AzOptionDirEntry& inner() { return inner_; }
    const AzOptionDirEntry* ptr() const { return &inner_; }
    AzOptionDirEntry* ptr() { return &inner_; }
    AzOptionDirEntry release() { AzOptionDirEntry result = inner_; inner_ = {}; return result; }
    operator AzOptionDirEntry() && noexcept { AzOptionDirEntry result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDirEntry_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDirEntry_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDirEntry& unwrap() const { return inner_.Some.payload; }
    AzDirEntry& unwrap() { return inner_.Some.payload; }
    AzDirEntry unwrapOr(const AzDirEntry& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDirEntry> toStdOptional() const { return isSome() ? std::optional<AzDirEntry>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDirEntry>() const { return toStdOptional(); }
};

class OptionNamedFont {
private:
    AzOptionNamedFont inner_;

    OptionNamedFont(const OptionNamedFont&) = delete;
    OptionNamedFont& operator=(const OptionNamedFont&) = delete;

public:
    explicit OptionNamedFont(AzOptionNamedFont inner) noexcept : inner_(inner) {}

    OptionNamedFont(OptionNamedFont&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionNamedFont& operator=(OptionNamedFont&& other) noexcept {
        if (this != &other) {
            AzOptionNamedFont_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionNamedFont() { AzOptionNamedFont_delete(&inner_); }

    static OptionNamedFont none();
    static OptionNamedFont some(NamedFont payload);
    void delete_();
    OptionNamedFont clone() const;
    bool partialEq(const OptionNamedFont& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionNamedFont& b) const;
    uint8_t cmp(const OptionNamedFont& b) const;
    String toDbgString() const;

    const AzOptionNamedFont& inner() const { return inner_; }
    AzOptionNamedFont& inner() { return inner_; }
    const AzOptionNamedFont* ptr() const { return &inner_; }
    AzOptionNamedFont* ptr() { return &inner_; }
    AzOptionNamedFont release() { AzOptionNamedFont result = inner_; inner_ = {}; return result; }
    operator AzOptionNamedFont() && noexcept { AzOptionNamedFont result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionNamedFont_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionNamedFont_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzNamedFont& unwrap() const { return inner_.Some.payload; }
    AzNamedFont& unwrap() { return inner_.Some.payload; }
    AzNamedFont unwrapOr(const AzNamedFont& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzNamedFont> toStdOptional() const { return isSome() ? std::optional<AzNamedFont>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzNamedFont>() const { return toStdOptional(); }
};

class OptionStyleFilter {
private:
    AzOptionStyleFilter inner_;

    OptionStyleFilter(const OptionStyleFilter&) = delete;
    OptionStyleFilter& operator=(const OptionStyleFilter&) = delete;

public:
    explicit OptionStyleFilter(AzOptionStyleFilter inner) noexcept : inner_(inner) {}

    OptionStyleFilter(OptionStyleFilter&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionStyleFilter& operator=(OptionStyleFilter&& other) noexcept {
        if (this != &other) {
            AzOptionStyleFilter_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionStyleFilter() { AzOptionStyleFilter_delete(&inner_); }

    static OptionStyleFilter none();
    static OptionStyleFilter some(AzStyleFilter payload);
    void delete_();
    OptionStyleFilter clone() const;
    bool partialEq(const OptionStyleFilter& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionStyleFilter& b) const;
    uint8_t cmp(const OptionStyleFilter& b) const;
    String toDbgString() const;

    const AzOptionStyleFilter& inner() const { return inner_; }
    AzOptionStyleFilter& inner() { return inner_; }
    const AzOptionStyleFilter* ptr() const { return &inner_; }
    AzOptionStyleFilter* ptr() { return &inner_; }
    AzOptionStyleFilter release() { AzOptionStyleFilter result = inner_; inner_ = {}; return result; }
    operator AzOptionStyleFilter() && noexcept { AzOptionStyleFilter result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionStyleFilter_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionStyleFilter_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzStyleFilter& unwrap() const { return inner_.Some.payload; }
    AzStyleFilter& unwrap() { return inner_.Some.payload; }
    AzStyleFilter unwrapOr(const AzStyleFilter& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzStyleFilter> toStdOptional() const { return isSome() ? std::optional<AzStyleFilter>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzStyleFilter>() const { return toStdOptional(); }
};

class OptionHttpHeader {
private:
    AzOptionHttpHeader inner_;

    OptionHttpHeader(const OptionHttpHeader&) = delete;
    OptionHttpHeader& operator=(const OptionHttpHeader&) = delete;

public:
    explicit OptionHttpHeader(AzOptionHttpHeader inner) noexcept : inner_(inner) {}

    OptionHttpHeader(OptionHttpHeader&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionHttpHeader& operator=(OptionHttpHeader&& other) noexcept {
        if (this != &other) {
            AzOptionHttpHeader_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionHttpHeader() { AzOptionHttpHeader_delete(&inner_); }

    static OptionHttpHeader none();
    static OptionHttpHeader some(HttpHeader payload);
    void delete_();
    OptionHttpHeader clone() const;
    bool partialEq(const OptionHttpHeader& b) const;
    String toDbgString() const;

    const AzOptionHttpHeader& inner() const { return inner_; }
    AzOptionHttpHeader& inner() { return inner_; }
    const AzOptionHttpHeader* ptr() const { return &inner_; }
    AzOptionHttpHeader* ptr() { return &inner_; }
    AzOptionHttpHeader release() { AzOptionHttpHeader result = inner_; inner_ = {}; return result; }
    operator AzOptionHttpHeader() && noexcept { AzOptionHttpHeader result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionHttpHeader_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionHttpHeader_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzHttpHeader& unwrap() const { return inner_.Some.payload; }
    AzHttpHeader& unwrap() { return inner_.Some.payload; }
    AzHttpHeader unwrapOr(const AzHttpHeader& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzHttpHeader> toStdOptional() const { return isSome() ? std::optional<AzHttpHeader>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzHttpHeader>() const { return toStdOptional(); }
};

class OptionCssRuleBlock {
private:
    AzOptionCssRuleBlock inner_;

    OptionCssRuleBlock(const OptionCssRuleBlock&) = delete;
    OptionCssRuleBlock& operator=(const OptionCssRuleBlock&) = delete;

public:
    explicit OptionCssRuleBlock(AzOptionCssRuleBlock inner) noexcept : inner_(inner) {}

    OptionCssRuleBlock(OptionCssRuleBlock&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionCssRuleBlock& operator=(OptionCssRuleBlock&& other) noexcept {
        if (this != &other) {
            AzOptionCssRuleBlock_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionCssRuleBlock() { AzOptionCssRuleBlock_delete(&inner_); }

    static OptionCssRuleBlock none();
    static OptionCssRuleBlock some(CssRuleBlock payload);
    void delete_();
    OptionCssRuleBlock clone() const;
    bool partialEq(const OptionCssRuleBlock& b) const;
    uint8_t partialCmp(const OptionCssRuleBlock& b) const;
    String toDbgString() const;

    const AzOptionCssRuleBlock& inner() const { return inner_; }
    AzOptionCssRuleBlock& inner() { return inner_; }
    const AzOptionCssRuleBlock* ptr() const { return &inner_; }
    AzOptionCssRuleBlock* ptr() { return &inner_; }
    AzOptionCssRuleBlock release() { AzOptionCssRuleBlock result = inner_; inner_ = {}; return result; }
    operator AzOptionCssRuleBlock() && noexcept { AzOptionCssRuleBlock result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCssRuleBlock_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCssRuleBlock_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCssRuleBlock& unwrap() const { return inner_.Some.payload; }
    AzCssRuleBlock& unwrap() { return inner_.Some.payload; }
    AzCssRuleBlock unwrapOr(const AzCssRuleBlock& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCssRuleBlock> toStdOptional() const { return isSome() ? std::optional<AzCssRuleBlock>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCssRuleBlock>() const { return toStdOptional(); }
};

class OptionCoreCallbackData {
private:
    AzOptionCoreCallbackData inner_;

    OptionCoreCallbackData(const OptionCoreCallbackData&) = delete;
    OptionCoreCallbackData& operator=(const OptionCoreCallbackData&) = delete;

public:
    explicit OptionCoreCallbackData(AzOptionCoreCallbackData inner) noexcept : inner_(inner) {}

    OptionCoreCallbackData(OptionCoreCallbackData&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionCoreCallbackData& operator=(OptionCoreCallbackData&& other) noexcept {
        if (this != &other) {
            AzOptionCoreCallbackData_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionCoreCallbackData() { AzOptionCoreCallbackData_delete(&inner_); }

    static OptionCoreCallbackData none();
    static OptionCoreCallbackData some(CoreCallbackData payload);
    void delete_();
    OptionCoreCallbackData clone() const;
    bool partialEq(const OptionCoreCallbackData& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionCoreCallbackData& b) const;
    uint8_t cmp(const OptionCoreCallbackData& b) const;
    String toDbgString() const;

    const AzOptionCoreCallbackData& inner() const { return inner_; }
    AzOptionCoreCallbackData& inner() { return inner_; }
    const AzOptionCoreCallbackData* ptr() const { return &inner_; }
    AzOptionCoreCallbackData* ptr() { return &inner_; }
    AzOptionCoreCallbackData release() { AzOptionCoreCallbackData result = inner_; inner_ = {}; return result; }
    operator AzOptionCoreCallbackData() && noexcept { AzOptionCoreCallbackData result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCoreCallbackData_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCoreCallbackData_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCoreCallbackData& unwrap() const { return inner_.Some.payload; }
    AzCoreCallbackData& unwrap() { return inner_.Some.payload; }
    AzCoreCallbackData unwrapOr(const AzCoreCallbackData& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCoreCallbackData> toStdOptional() const { return isSome() ? std::optional<AzCoreCallbackData>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCoreCallbackData>() const { return toStdOptional(); }
};

class OptionVertexAttribute {
private:
    AzOptionVertexAttribute inner_;

    OptionVertexAttribute(const OptionVertexAttribute&) = delete;
    OptionVertexAttribute& operator=(const OptionVertexAttribute&) = delete;

public:
    explicit OptionVertexAttribute(AzOptionVertexAttribute inner) noexcept : inner_(inner) {}

    OptionVertexAttribute(OptionVertexAttribute&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionVertexAttribute& operator=(OptionVertexAttribute&& other) noexcept {
        if (this != &other) {
            AzOptionVertexAttribute_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionVertexAttribute() { AzOptionVertexAttribute_delete(&inner_); }

    static OptionVertexAttribute none();
    static OptionVertexAttribute some(VertexAttribute payload);
    void delete_();
    OptionVertexAttribute clone() const;
    bool partialEq(const OptionVertexAttribute& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionVertexAttribute& b) const;
    uint8_t cmp(const OptionVertexAttribute& b) const;
    String toDbgString() const;

    const AzOptionVertexAttribute& inner() const { return inner_; }
    AzOptionVertexAttribute& inner() { return inner_; }
    const AzOptionVertexAttribute* ptr() const { return &inner_; }
    AzOptionVertexAttribute* ptr() { return &inner_; }
    AzOptionVertexAttribute release() { AzOptionVertexAttribute result = inner_; inner_ = {}; return result; }
    operator AzOptionVertexAttribute() && noexcept { AzOptionVertexAttribute result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionVertexAttribute_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionVertexAttribute_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzVertexAttribute& unwrap() const { return inner_.Some.payload; }
    AzVertexAttribute& unwrap() { return inner_.Some.payload; }
    AzVertexAttribute unwrapOr(const AzVertexAttribute& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzVertexAttribute> toStdOptional() const { return isSome() ? std::optional<AzVertexAttribute>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzVertexAttribute>() const { return toStdOptional(); }
};

class OptionDebugMessage {
private:
    AzOptionDebugMessage inner_;

    OptionDebugMessage(const OptionDebugMessage&) = delete;
    OptionDebugMessage& operator=(const OptionDebugMessage&) = delete;

public:
    explicit OptionDebugMessage(AzOptionDebugMessage inner) noexcept : inner_(inner) {}

    OptionDebugMessage(OptionDebugMessage&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionDebugMessage& operator=(OptionDebugMessage&& other) noexcept {
        if (this != &other) {
            AzOptionDebugMessage_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionDebugMessage() { AzOptionDebugMessage_delete(&inner_); }

    static OptionDebugMessage none();
    static OptionDebugMessage some(DebugMessage payload);
    void delete_();
    OptionDebugMessage clone() const;
    bool partialEq(const OptionDebugMessage& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionDebugMessage& b) const;
    uint8_t cmp(const OptionDebugMessage& b) const;
    String toDbgString() const;

    const AzOptionDebugMessage& inner() const { return inner_; }
    AzOptionDebugMessage& inner() { return inner_; }
    const AzOptionDebugMessage* ptr() const { return &inner_; }
    AzOptionDebugMessage* ptr() { return &inner_; }
    AzOptionDebugMessage release() { AzOptionDebugMessage result = inner_; inner_ = {}; return result; }
    operator AzOptionDebugMessage() && noexcept { AzOptionDebugMessage result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDebugMessage_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDebugMessage_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDebugMessage& unwrap() const { return inner_.Some.payload; }
    AzDebugMessage& unwrap() { return inner_.Some.payload; }
    AzDebugMessage unwrapOr(const AzDebugMessage& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDebugMessage> toStdOptional() const { return isSome() ? std::optional<AzDebugMessage>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDebugMessage>() const { return toStdOptional(); }
};

class OptionListViewRow {
private:
    AzOptionListViewRow inner_;

    OptionListViewRow(const OptionListViewRow&) = delete;
    OptionListViewRow& operator=(const OptionListViewRow&) = delete;

public:
    explicit OptionListViewRow(AzOptionListViewRow inner) noexcept : inner_(inner) {}

    OptionListViewRow(OptionListViewRow&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionListViewRow& operator=(OptionListViewRow&& other) noexcept {
        if (this != &other) {
            AzOptionListViewRow_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionListViewRow() { AzOptionListViewRow_delete(&inner_); }

    static OptionListViewRow none();
    static OptionListViewRow some(ListViewRow payload);
    void delete_();
    OptionListViewRow clone() const;
    String toDbgString() const;

    const AzOptionListViewRow& inner() const { return inner_; }
    AzOptionListViewRow& inner() { return inner_; }
    const AzOptionListViewRow* ptr() const { return &inner_; }
    AzOptionListViewRow* ptr() { return &inner_; }
    AzOptionListViewRow release() { AzOptionListViewRow result = inner_; inner_ = {}; return result; }
    operator AzOptionListViewRow() && noexcept { AzOptionListViewRow result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionListViewRow_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionListViewRow_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzListViewRow& unwrap() const { return inner_.Some.payload; }
    AzListViewRow& unwrap() { return inner_.Some.payload; }
    AzListViewRow unwrapOr(const AzListViewRow& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzListViewRow> toStdOptional() const { return isSome() ? std::optional<AzListViewRow>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzListViewRow>() const { return toStdOptional(); }
};

class OptionIdOrClass {
private:
    AzOptionIdOrClass inner_;

    OptionIdOrClass(const OptionIdOrClass&) = delete;
    OptionIdOrClass& operator=(const OptionIdOrClass&) = delete;

public:
    explicit OptionIdOrClass(AzOptionIdOrClass inner) noexcept : inner_(inner) {}

    OptionIdOrClass(OptionIdOrClass&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionIdOrClass& operator=(OptionIdOrClass&& other) noexcept {
        if (this != &other) {
            AzOptionIdOrClass_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionIdOrClass() { AzOptionIdOrClass_delete(&inner_); }

    static OptionIdOrClass none();
    static OptionIdOrClass some(AzIdOrClass payload);
    void delete_();
    OptionIdOrClass clone() const;
    bool partialEq(const OptionIdOrClass& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionIdOrClass& b) const;
    uint8_t cmp(const OptionIdOrClass& b) const;
    String toDbgString() const;

    const AzOptionIdOrClass& inner() const { return inner_; }
    AzOptionIdOrClass& inner() { return inner_; }
    const AzOptionIdOrClass* ptr() const { return &inner_; }
    AzOptionIdOrClass* ptr() { return &inner_; }
    AzOptionIdOrClass release() { AzOptionIdOrClass result = inner_; inner_ = {}; return result; }
    operator AzOptionIdOrClass() && noexcept { AzOptionIdOrClass result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionIdOrClass_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionIdOrClass_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzIdOrClass& unwrap() const { return inner_.Some.payload; }
    AzIdOrClass& unwrap() { return inner_.Some.payload; }
    AzIdOrClass unwrapOr(const AzIdOrClass& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzIdOrClass> toStdOptional() const { return isSome() ? std::optional<AzIdOrClass>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzIdOrClass>() const { return toStdOptional(); }
};

class OptionStyleFontFamily {
private:
    AzOptionStyleFontFamily inner_;

    OptionStyleFontFamily(const OptionStyleFontFamily&) = delete;
    OptionStyleFontFamily& operator=(const OptionStyleFontFamily&) = delete;

public:
    explicit OptionStyleFontFamily(AzOptionStyleFontFamily inner) noexcept : inner_(inner) {}

    OptionStyleFontFamily(OptionStyleFontFamily&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionStyleFontFamily& operator=(OptionStyleFontFamily&& other) noexcept {
        if (this != &other) {
            AzOptionStyleFontFamily_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionStyleFontFamily() { AzOptionStyleFontFamily_delete(&inner_); }

    static OptionStyleFontFamily none();
    static OptionStyleFontFamily some(AzStyleFontFamily payload);
    void delete_();
    OptionStyleFontFamily clone() const;
    bool partialEq(const OptionStyleFontFamily& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionStyleFontFamily& b) const;
    uint8_t cmp(const OptionStyleFontFamily& b) const;
    String toDbgString() const;

    const AzOptionStyleFontFamily& inner() const { return inner_; }
    AzOptionStyleFontFamily& inner() { return inner_; }
    const AzOptionStyleFontFamily* ptr() const { return &inner_; }
    AzOptionStyleFontFamily* ptr() { return &inner_; }
    AzOptionStyleFontFamily release() { AzOptionStyleFontFamily result = inner_; inner_ = {}; return result; }
    operator AzOptionStyleFontFamily() && noexcept { AzOptionStyleFontFamily result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionStyleFontFamily_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionStyleFontFamily_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzStyleFontFamily& unwrap() const { return inner_.Some.payload; }
    AzStyleFontFamily& unwrap() { return inner_.Some.payload; }
    AzStyleFontFamily unwrapOr(const AzStyleFontFamily& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzStyleFontFamily> toStdOptional() const { return isSome() ? std::optional<AzStyleFontFamily>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzStyleFontFamily>() const { return toStdOptional(); }
};

class OptionStringPair {
private:
    AzOptionStringPair inner_;

    OptionStringPair(const OptionStringPair&) = delete;
    OptionStringPair& operator=(const OptionStringPair&) = delete;

public:
    explicit OptionStringPair(AzOptionStringPair inner) noexcept : inner_(inner) {}

    OptionStringPair(OptionStringPair&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionStringPair& operator=(OptionStringPair&& other) noexcept {
        if (this != &other) {
            AzOptionStringPair_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionStringPair() { AzOptionStringPair_delete(&inner_); }

    static OptionStringPair none();
    static OptionStringPair some(StringPair payload);
    void delete_();
    OptionStringPair clone() const;
    bool partialEq(const OptionStringPair& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionStringPair& b) const;
    uint8_t cmp(const OptionStringPair& b) const;
    String toDbgString() const;

    const AzOptionStringPair& inner() const { return inner_; }
    AzOptionStringPair& inner() { return inner_; }
    const AzOptionStringPair* ptr() const { return &inner_; }
    AzOptionStringPair* ptr() { return &inner_; }
    AzOptionStringPair release() { AzOptionStringPair result = inner_; inner_ = {}; return result; }
    operator AzOptionStringPair() && noexcept { AzOptionStringPair result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionStringPair_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionStringPair_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzStringPair& unwrap() const { return inner_.Some.payload; }
    AzStringPair& unwrap() { return inner_.Some.payload; }
    AzStringPair unwrapOr(const AzStringPair& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzStringPair> toStdOptional() const { return isSome() ? std::optional<AzStringPair>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzStringPair>() const { return toStdOptional(); }
};

class OptionMimeTypeData {
private:
    AzOptionMimeTypeData inner_;

    OptionMimeTypeData(const OptionMimeTypeData&) = delete;
    OptionMimeTypeData& operator=(const OptionMimeTypeData&) = delete;

public:
    explicit OptionMimeTypeData(AzOptionMimeTypeData inner) noexcept : inner_(inner) {}

    OptionMimeTypeData(OptionMimeTypeData&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionMimeTypeData& operator=(OptionMimeTypeData&& other) noexcept {
        if (this != &other) {
            AzOptionMimeTypeData_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionMimeTypeData() { AzOptionMimeTypeData_delete(&inner_); }

    static OptionMimeTypeData none();
    static OptionMimeTypeData some(MimeTypeData payload);
    void delete_();
    OptionMimeTypeData clone() const;
    bool partialEq(const OptionMimeTypeData& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionMimeTypeData& b) const;
    uint8_t cmp(const OptionMimeTypeData& b) const;
    String toDbgString() const;

    const AzOptionMimeTypeData& inner() const { return inner_; }
    AzOptionMimeTypeData& inner() { return inner_; }
    const AzOptionMimeTypeData* ptr() const { return &inner_; }
    AzOptionMimeTypeData* ptr() { return &inner_; }
    AzOptionMimeTypeData release() { AzOptionMimeTypeData result = inner_; inner_ = {}; return result; }
    operator AzOptionMimeTypeData() && noexcept { AzOptionMimeTypeData result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionMimeTypeData_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionMimeTypeData_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzMimeTypeData& unwrap() const { return inner_.Some.payload; }
    AzMimeTypeData& unwrap() { return inner_.Some.payload; }
    AzMimeTypeData unwrapOr(const AzMimeTypeData& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzMimeTypeData> toStdOptional() const { return isSome() ? std::optional<AzMimeTypeData>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzMimeTypeData>() const { return toStdOptional(); }
};

class OptionThemeCondition {
private:
    AzOptionThemeCondition inner_;

    OptionThemeCondition(const OptionThemeCondition&) = delete;
    OptionThemeCondition& operator=(const OptionThemeCondition&) = delete;

public:
    explicit OptionThemeCondition(AzOptionThemeCondition inner) noexcept : inner_(inner) {}

    OptionThemeCondition(OptionThemeCondition&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionThemeCondition& operator=(OptionThemeCondition&& other) noexcept {
        if (this != &other) {
            AzOptionThemeCondition_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionThemeCondition() { AzOptionThemeCondition_delete(&inner_); }

    static OptionThemeCondition none();
    static OptionThemeCondition some(AzThemeCondition payload);
    void delete_();
    OptionThemeCondition clone() const;
    bool partialEq(const OptionThemeCondition& b) const;
    uint64_t hash() const;
    String toDbgString() const;

    const AzOptionThemeCondition& inner() const { return inner_; }
    AzOptionThemeCondition& inner() { return inner_; }
    const AzOptionThemeCondition* ptr() const { return &inner_; }
    AzOptionThemeCondition* ptr() { return &inner_; }
    AzOptionThemeCondition release() { AzOptionThemeCondition result = inner_; inner_ = {}; return result; }
    operator AzOptionThemeCondition() && noexcept { AzOptionThemeCondition result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionThemeCondition_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionThemeCondition_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzThemeCondition& unwrap() const { return inner_.Some.payload; }
    AzThemeCondition& unwrap() { return inner_.Some.payload; }
    AzThemeCondition unwrapOr(const AzThemeCondition& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzThemeCondition> toStdOptional() const { return isSome() ? std::optional<AzThemeCondition>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzThemeCondition>() const { return toStdOptional(); }
};

class OptionGridAreaDefinition {
private:
    AzOptionGridAreaDefinition inner_;

    OptionGridAreaDefinition(const OptionGridAreaDefinition&) = delete;
    OptionGridAreaDefinition& operator=(const OptionGridAreaDefinition&) = delete;

public:
    explicit OptionGridAreaDefinition(AzOptionGridAreaDefinition inner) noexcept : inner_(inner) {}

    OptionGridAreaDefinition(OptionGridAreaDefinition&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionGridAreaDefinition& operator=(OptionGridAreaDefinition&& other) noexcept {
        if (this != &other) {
            AzOptionGridAreaDefinition_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionGridAreaDefinition() { AzOptionGridAreaDefinition_delete(&inner_); }

    static OptionGridAreaDefinition none();
    static OptionGridAreaDefinition some(GridAreaDefinition payload);
    void delete_();
    OptionGridAreaDefinition clone() const;
    bool partialEq(const OptionGridAreaDefinition& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionGridAreaDefinition& b) const;
    uint8_t cmp(const OptionGridAreaDefinition& b) const;

    const AzOptionGridAreaDefinition& inner() const { return inner_; }
    AzOptionGridAreaDefinition& inner() { return inner_; }
    const AzOptionGridAreaDefinition* ptr() const { return &inner_; }
    AzOptionGridAreaDefinition* ptr() { return &inner_; }
    AzOptionGridAreaDefinition release() { AzOptionGridAreaDefinition result = inner_; inner_ = {}; return result; }
    operator AzOptionGridAreaDefinition() && noexcept { AzOptionGridAreaDefinition result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionGridAreaDefinition_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionGridAreaDefinition_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzGridAreaDefinition& unwrap() const { return inner_.Some.payload; }
    AzGridAreaDefinition& unwrap() { return inner_.Some.payload; }
    AzGridAreaDefinition unwrapOr(const AzGridAreaDefinition& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzGridAreaDefinition> toStdOptional() const { return isSome() ? std::optional<AzGridAreaDefinition>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzGridAreaDefinition>() const { return toStdOptional(); }
};

class OptionComponentLibrary {
private:
    AzOptionComponentLibrary inner_;

    OptionComponentLibrary(const OptionComponentLibrary&) = delete;
    OptionComponentLibrary& operator=(const OptionComponentLibrary&) = delete;

public:
    explicit OptionComponentLibrary(AzOptionComponentLibrary inner) noexcept : inner_(inner) {}

    OptionComponentLibrary(OptionComponentLibrary&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionComponentLibrary& operator=(OptionComponentLibrary&& other) noexcept {
        if (this != &other) {
            AzOptionComponentLibrary_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionComponentLibrary() { AzOptionComponentLibrary_delete(&inner_); }

    static OptionComponentLibrary none();
    static OptionComponentLibrary some(ComponentLibrary payload);
    void delete_();
    OptionComponentLibrary clone() const;
    String toDbgString() const;

    const AzOptionComponentLibrary& inner() const { return inner_; }
    AzOptionComponentLibrary& inner() { return inner_; }
    const AzOptionComponentLibrary* ptr() const { return &inner_; }
    AzOptionComponentLibrary* ptr() { return &inner_; }
    AzOptionComponentLibrary release() { AzOptionComponentLibrary result = inner_; inner_ = {}; return result; }
    operator AzOptionComponentLibrary() && noexcept { AzOptionComponentLibrary result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionComponentLibrary_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionComponentLibrary_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzComponentLibrary& unwrap() const { return inner_.Some.payload; }
    AzComponentLibrary& unwrap() { return inner_.Some.payload; }
    AzComponentLibrary unwrapOr(const AzComponentLibrary& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzComponentLibrary> toStdOptional() const { return isSome() ? std::optional<AzComponentLibrary>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzComponentLibrary>() const { return toStdOptional(); }
};

class OptionComponentDataModel {
private:
    AzOptionComponentDataModel inner_;

    OptionComponentDataModel(const OptionComponentDataModel&) = delete;
    OptionComponentDataModel& operator=(const OptionComponentDataModel&) = delete;

public:
    explicit OptionComponentDataModel(AzOptionComponentDataModel inner) noexcept : inner_(inner) {}

    OptionComponentDataModel(OptionComponentDataModel&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionComponentDataModel& operator=(OptionComponentDataModel&& other) noexcept {
        if (this != &other) {
            AzOptionComponentDataModel_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionComponentDataModel() { AzOptionComponentDataModel_delete(&inner_); }

    static OptionComponentDataModel none();
    static OptionComponentDataModel some(ComponentDataModel payload);
    void delete_();
    OptionComponentDataModel clone() const;
    String toDbgString() const;

    const AzOptionComponentDataModel& inner() const { return inner_; }
    AzOptionComponentDataModel& inner() { return inner_; }
    const AzOptionComponentDataModel* ptr() const { return &inner_; }
    AzOptionComponentDataModel* ptr() { return &inner_; }
    AzOptionComponentDataModel release() { AzOptionComponentDataModel result = inner_; inner_ = {}; return result; }
    operator AzOptionComponentDataModel() && noexcept { AzOptionComponentDataModel result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionComponentDataModel_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionComponentDataModel_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzComponentDataModel& unwrap() const { return inner_.Some.payload; }
    AzComponentDataModel& unwrap() { return inner_.Some.payload; }
    AzComponentDataModel unwrapOr(const AzComponentDataModel& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzComponentDataModel> toStdOptional() const { return isSome() ? std::optional<AzComponentDataModel>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzComponentDataModel>() const { return toStdOptional(); }
};

class OptionComponentEnumModel {
private:
    AzOptionComponentEnumModel inner_;

    OptionComponentEnumModel(const OptionComponentEnumModel&) = delete;
    OptionComponentEnumModel& operator=(const OptionComponentEnumModel&) = delete;

public:
    explicit OptionComponentEnumModel(AzOptionComponentEnumModel inner) noexcept : inner_(inner) {}

    OptionComponentEnumModel(OptionComponentEnumModel&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionComponentEnumModel& operator=(OptionComponentEnumModel&& other) noexcept {
        if (this != &other) {
            AzOptionComponentEnumModel_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionComponentEnumModel() { AzOptionComponentEnumModel_delete(&inner_); }

    static OptionComponentEnumModel none();
    static OptionComponentEnumModel some(ComponentEnumModel payload);
    void delete_();
    OptionComponentEnumModel clone() const;
    bool partialEq(const OptionComponentEnumModel& b) const;
    String toDbgString() const;

    const AzOptionComponentEnumModel& inner() const { return inner_; }
    AzOptionComponentEnumModel& inner() { return inner_; }
    const AzOptionComponentEnumModel* ptr() const { return &inner_; }
    AzOptionComponentEnumModel* ptr() { return &inner_; }
    AzOptionComponentEnumModel release() { AzOptionComponentEnumModel result = inner_; inner_ = {}; return result; }
    operator AzOptionComponentEnumModel() && noexcept { AzOptionComponentEnumModel result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionComponentEnumModel_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionComponentEnumModel_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzComponentEnumModel& unwrap() const { return inner_.Some.payload; }
    AzComponentEnumModel& unwrap() { return inner_.Some.payload; }
    AzComponentEnumModel unwrapOr(const AzComponentEnumModel& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzComponentEnumModel> toStdOptional() const { return isSome() ? std::optional<AzComponentEnumModel>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzComponentEnumModel>() const { return toStdOptional(); }
};

class OptionComponentEnumVariant {
private:
    AzOptionComponentEnumVariant inner_;

    OptionComponentEnumVariant(const OptionComponentEnumVariant&) = delete;
    OptionComponentEnumVariant& operator=(const OptionComponentEnumVariant&) = delete;

public:
    explicit OptionComponentEnumVariant(AzOptionComponentEnumVariant inner) noexcept : inner_(inner) {}

    OptionComponentEnumVariant(OptionComponentEnumVariant&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionComponentEnumVariant& operator=(OptionComponentEnumVariant&& other) noexcept {
        if (this != &other) {
            AzOptionComponentEnumVariant_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionComponentEnumVariant() { AzOptionComponentEnumVariant_delete(&inner_); }

    static OptionComponentEnumVariant none();
    static OptionComponentEnumVariant some(ComponentEnumVariant payload);
    void delete_();
    OptionComponentEnumVariant clone() const;
    bool partialEq(const OptionComponentEnumVariant& b) const;
    String toDbgString() const;

    const AzOptionComponentEnumVariant& inner() const { return inner_; }
    AzOptionComponentEnumVariant& inner() { return inner_; }
    const AzOptionComponentEnumVariant* ptr() const { return &inner_; }
    AzOptionComponentEnumVariant* ptr() { return &inner_; }
    AzOptionComponentEnumVariant release() { AzOptionComponentEnumVariant result = inner_; inner_ = {}; return result; }
    operator AzOptionComponentEnumVariant() && noexcept { AzOptionComponentEnumVariant result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionComponentEnumVariant_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionComponentEnumVariant_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzComponentEnumVariant& unwrap() const { return inner_.Some.payload; }
    AzComponentEnumVariant& unwrap() { return inner_.Some.payload; }
    AzComponentEnumVariant unwrapOr(const AzComponentEnumVariant& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzComponentEnumVariant> toStdOptional() const { return isSome() ? std::optional<AzComponentEnumVariant>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzComponentEnumVariant>() const { return toStdOptional(); }
};

class OptionRibbonOnTabClick {
private:
    AzOptionRibbonOnTabClick inner_;

    OptionRibbonOnTabClick(const OptionRibbonOnTabClick&) = delete;
    OptionRibbonOnTabClick& operator=(const OptionRibbonOnTabClick&) = delete;

public:
    explicit OptionRibbonOnTabClick(AzOptionRibbonOnTabClick inner) noexcept : inner_(inner) {}

    OptionRibbonOnTabClick(OptionRibbonOnTabClick&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionRibbonOnTabClick& operator=(OptionRibbonOnTabClick&& other) noexcept {
        if (this != &other) {
            AzOptionRibbonOnTabClick_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionRibbonOnTabClick() { AzOptionRibbonOnTabClick_delete(&inner_); }

    static OptionRibbonOnTabClick none();
    static OptionRibbonOnTabClick some(RibbonOnTabClick payload);
    void delete_();
    OptionRibbonOnTabClick clone() const;
    bool partialEq(const OptionRibbonOnTabClick& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionRibbonOnTabClick& b) const;
    uint8_t cmp(const OptionRibbonOnTabClick& b) const;
    String toDbgString() const;

    const AzOptionRibbonOnTabClick& inner() const { return inner_; }
    AzOptionRibbonOnTabClick& inner() { return inner_; }
    const AzOptionRibbonOnTabClick* ptr() const { return &inner_; }
    AzOptionRibbonOnTabClick* ptr() { return &inner_; }
    AzOptionRibbonOnTabClick release() { AzOptionRibbonOnTabClick result = inner_; inner_ = {}; return result; }
    operator AzOptionRibbonOnTabClick() && noexcept { AzOptionRibbonOnTabClick result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionRibbonOnTabClick_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionRibbonOnTabClick_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzRibbonOnTabClick& unwrap() const { return inner_.Some.payload; }
    AzRibbonOnTabClick& unwrap() { return inner_.Some.payload; }
    AzRibbonOnTabClick unwrapOr(const AzRibbonOnTabClick& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzRibbonOnTabClick> toStdOptional() const { return isSome() ? std::optional<AzRibbonOnTabClick>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzRibbonOnTabClick>() const { return toStdOptional(); }
};

class OptionTreeViewOnNodeClick {
private:
    AzOptionTreeViewOnNodeClick inner_;

    OptionTreeViewOnNodeClick(const OptionTreeViewOnNodeClick&) = delete;
    OptionTreeViewOnNodeClick& operator=(const OptionTreeViewOnNodeClick&) = delete;

public:
    explicit OptionTreeViewOnNodeClick(AzOptionTreeViewOnNodeClick inner) noexcept : inner_(inner) {}

    OptionTreeViewOnNodeClick(OptionTreeViewOnNodeClick&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionTreeViewOnNodeClick& operator=(OptionTreeViewOnNodeClick&& other) noexcept {
        if (this != &other) {
            AzOptionTreeViewOnNodeClick_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionTreeViewOnNodeClick() { AzOptionTreeViewOnNodeClick_delete(&inner_); }

    static OptionTreeViewOnNodeClick none();
    static OptionTreeViewOnNodeClick some(TreeViewOnNodeClick payload);
    void delete_();
    OptionTreeViewOnNodeClick clone() const;
    bool partialEq(const OptionTreeViewOnNodeClick& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionTreeViewOnNodeClick& b) const;
    uint8_t cmp(const OptionTreeViewOnNodeClick& b) const;
    String toDbgString() const;

    const AzOptionTreeViewOnNodeClick& inner() const { return inner_; }
    AzOptionTreeViewOnNodeClick& inner() { return inner_; }
    const AzOptionTreeViewOnNodeClick* ptr() const { return &inner_; }
    AzOptionTreeViewOnNodeClick* ptr() { return &inner_; }
    AzOptionTreeViewOnNodeClick release() { AzOptionTreeViewOnNodeClick result = inner_; inner_ = {}; return result; }
    operator AzOptionTreeViewOnNodeClick() && noexcept { AzOptionTreeViewOnNodeClick result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTreeViewOnNodeClick_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTreeViewOnNodeClick_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTreeViewOnNodeClick& unwrap() const { return inner_.Some.payload; }
    AzTreeViewOnNodeClick& unwrap() { return inner_.Some.payload; }
    AzTreeViewOnNodeClick unwrapOr(const AzTreeViewOnNodeClick& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTreeViewOnNodeClick> toStdOptional() const { return isSome() ? std::optional<AzTreeViewOnNodeClick>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTreeViewOnNodeClick>() const { return toStdOptional(); }
};

class OptionRibbonTab {
private:
    AzOptionRibbonTab inner_;

    OptionRibbonTab(const OptionRibbonTab&) = delete;
    OptionRibbonTab& operator=(const OptionRibbonTab&) = delete;

public:
    explicit OptionRibbonTab(AzOptionRibbonTab inner) noexcept : inner_(inner) {}

    OptionRibbonTab(OptionRibbonTab&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionRibbonTab& operator=(OptionRibbonTab&& other) noexcept {
        if (this != &other) {
            AzOptionRibbonTab_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionRibbonTab() { AzOptionRibbonTab_delete(&inner_); }

    static OptionRibbonTab none();
    static OptionRibbonTab some(RibbonTab payload);
    void delete_();
    OptionRibbonTab clone() const;
    String toDbgString() const;

    const AzOptionRibbonTab& inner() const { return inner_; }
    AzOptionRibbonTab& inner() { return inner_; }
    const AzOptionRibbonTab* ptr() const { return &inner_; }
    AzOptionRibbonTab* ptr() { return &inner_; }
    AzOptionRibbonTab release() { AzOptionRibbonTab result = inner_; inner_ = {}; return result; }
    operator AzOptionRibbonTab() && noexcept { AzOptionRibbonTab result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionRibbonTab_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionRibbonTab_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzRibbonTab& unwrap() const { return inner_.Some.payload; }
    AzRibbonTab& unwrap() { return inner_.Some.payload; }
    AzRibbonTab unwrapOr(const AzRibbonTab& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzRibbonTab> toStdOptional() const { return isSome() ? std::optional<AzRibbonTab>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzRibbonTab>() const { return toStdOptional(); }
};

class OptionTreeViewNode {
private:
    AzOptionTreeViewNode inner_;

    OptionTreeViewNode(const OptionTreeViewNode&) = delete;
    OptionTreeViewNode& operator=(const OptionTreeViewNode&) = delete;

public:
    explicit OptionTreeViewNode(AzOptionTreeViewNode inner) noexcept : inner_(inner) {}

    OptionTreeViewNode(OptionTreeViewNode&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionTreeViewNode& operator=(OptionTreeViewNode&& other) noexcept {
        if (this != &other) {
            AzOptionTreeViewNode_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionTreeViewNode() { AzOptionTreeViewNode_delete(&inner_); }

    static OptionTreeViewNode none();
    static OptionTreeViewNode some(TreeViewNode payload);
    void delete_();
    OptionTreeViewNode clone() const;
    bool partialEq(const OptionTreeViewNode& b) const;
    String toDbgString() const;

    const AzOptionTreeViewNode& inner() const { return inner_; }
    AzOptionTreeViewNode& inner() { return inner_; }
    const AzOptionTreeViewNode* ptr() const { return &inner_; }
    AzOptionTreeViewNode* ptr() { return &inner_; }
    AzOptionTreeViewNode release() { AzOptionTreeViewNode result = inner_; inner_ = {}; return result; }
    operator AzOptionTreeViewNode() && noexcept { AzOptionTreeViewNode result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTreeViewNode_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTreeViewNode_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTreeViewNode& unwrap() const { return inner_.Some.payload; }
    AzTreeViewNode& unwrap() { return inner_.Some.payload; }
    AzTreeViewNode unwrapOr(const AzTreeViewNode& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTreeViewNode> toStdOptional() const { return isSome() ? std::optional<AzTreeViewNode>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTreeViewNode>() const { return toStdOptional(); }
};

class OptionRoute {
private:
    AzOptionRoute inner_;

    OptionRoute(const OptionRoute&) = delete;
    OptionRoute& operator=(const OptionRoute&) = delete;

public:
    explicit OptionRoute(AzOptionRoute inner) noexcept : inner_(inner) {}

    OptionRoute(OptionRoute&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionRoute& operator=(OptionRoute&& other) noexcept {
        if (this != &other) {
            AzOptionRoute_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionRoute() { AzOptionRoute_delete(&inner_); }

    static OptionRoute none();
    static OptionRoute some(Route payload);
    void delete_();
    OptionRoute clone() const;
    bool partialEq(const OptionRoute& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionRoute& b) const;
    uint8_t cmp(const OptionRoute& b) const;
    String toDbgString() const;

    const AzOptionRoute& inner() const { return inner_; }
    AzOptionRoute& inner() { return inner_; }
    const AzOptionRoute* ptr() const { return &inner_; }
    AzOptionRoute* ptr() { return &inner_; }
    AzOptionRoute release() { AzOptionRoute result = inner_; inner_ = {}; return result; }
    operator AzOptionRoute() && noexcept { AzOptionRoute result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionRoute_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionRoute_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzRoute& unwrap() const { return inner_.Some.payload; }
    AzRoute& unwrap() { return inner_.Some.payload; }
    AzRoute unwrapOr(const AzRoute& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzRoute> toStdOptional() const { return isSome() ? std::optional<AzRoute>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzRoute>() const { return toStdOptional(); }
};

class OptionRouteMatch {
private:
    AzOptionRouteMatch inner_;

    OptionRouteMatch(const OptionRouteMatch&) = delete;
    OptionRouteMatch& operator=(const OptionRouteMatch&) = delete;

public:
    explicit OptionRouteMatch(AzOptionRouteMatch inner) noexcept : inner_(inner) {}

    OptionRouteMatch(OptionRouteMatch&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionRouteMatch& operator=(OptionRouteMatch&& other) noexcept {
        if (this != &other) {
            AzOptionRouteMatch_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionRouteMatch() { AzOptionRouteMatch_delete(&inner_); }

    static OptionRouteMatch none();
    static OptionRouteMatch some(RouteMatch payload);
    void delete_();
    OptionRouteMatch clone() const;
    bool partialEq(const OptionRouteMatch& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionRouteMatch& b) const;
    uint8_t cmp(const OptionRouteMatch& b) const;
    String toDbgString() const;

    const AzOptionRouteMatch& inner() const { return inner_; }
    AzOptionRouteMatch& inner() { return inner_; }
    const AzOptionRouteMatch* ptr() const { return &inner_; }
    AzOptionRouteMatch* ptr() { return &inner_; }
    AzOptionRouteMatch release() { AzOptionRouteMatch result = inner_; inner_ = {}; return result; }
    operator AzOptionRouteMatch() && noexcept { AzOptionRouteMatch result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionRouteMatch_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionRouteMatch_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzRouteMatch& unwrap() const { return inner_.Some.payload; }
    AzRouteMatch& unwrap() { return inner_.Some.payload; }
    AzRouteMatch unwrapOr(const AzRouteMatch& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzRouteMatch> toStdOptional() const { return isSome() ? std::optional<AzRouteMatch>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzRouteMatch>() const { return toStdOptional(); }
};

class OptionFileTypeList {
private:
    AzOptionFileTypeList inner_;

    OptionFileTypeList(const OptionFileTypeList&) = delete;
    OptionFileTypeList& operator=(const OptionFileTypeList&) = delete;

public:
    explicit OptionFileTypeList(AzOptionFileTypeList inner) noexcept : inner_(inner) {}

    OptionFileTypeList(OptionFileTypeList&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionFileTypeList& operator=(OptionFileTypeList&& other) noexcept {
        if (this != &other) {
            AzOptionFileTypeList_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionFileTypeList() { AzOptionFileTypeList_delete(&inner_); }

    static OptionFileTypeList none();
    static OptionFileTypeList some(FileTypeList payload);
    void delete_();
    OptionFileTypeList clone() const;
    bool partialEq(const OptionFileTypeList& b) const;
    uint8_t partialCmp(const OptionFileTypeList& b) const;
    String toDbgString() const;

    const AzOptionFileTypeList& inner() const { return inner_; }
    AzOptionFileTypeList& inner() { return inner_; }
    const AzOptionFileTypeList* ptr() const { return &inner_; }
    AzOptionFileTypeList* ptr() { return &inner_; }
    AzOptionFileTypeList release() { AzOptionFileTypeList result = inner_; inner_ = {}; return result; }
    operator AzOptionFileTypeList() && noexcept { AzOptionFileTypeList result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionFileTypeList_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionFileTypeList_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzFileTypeList& unwrap() const { return inner_.Some.payload; }
    AzFileTypeList& unwrap() { return inner_.Some.payload; }
    AzFileTypeList unwrapOr(const AzFileTypeList& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzFileTypeList> toStdOptional() const { return isSome() ? std::optional<AzFileTypeList>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzFileTypeList>() const { return toStdOptional(); }
};

class OptionKeyringResult {
private:
    AzOptionKeyringResult inner_;

    OptionKeyringResult(const OptionKeyringResult&) = delete;
    OptionKeyringResult& operator=(const OptionKeyringResult&) = delete;

public:
    explicit OptionKeyringResult(AzOptionKeyringResult inner) noexcept : inner_(inner) {}

    OptionKeyringResult(OptionKeyringResult&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionKeyringResult& operator=(OptionKeyringResult&& other) noexcept {
        if (this != &other) {
            AzOptionKeyringResult_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionKeyringResult() { AzOptionKeyringResult_delete(&inner_); }

    static OptionKeyringResult none();
    static OptionKeyringResult some(AzKeyringResult payload);
    void delete_();
    OptionKeyringResult clone() const;
    bool partialEq(const OptionKeyringResult& b) const;
    String toDbgString() const;

    const AzOptionKeyringResult& inner() const { return inner_; }
    AzOptionKeyringResult& inner() { return inner_; }
    const AzOptionKeyringResult* ptr() const { return &inner_; }
    AzOptionKeyringResult* ptr() { return &inner_; }
    AzOptionKeyringResult release() { AzOptionKeyringResult result = inner_; inner_ = {}; return result; }
    operator AzOptionKeyringResult() && noexcept { AzOptionKeyringResult result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionKeyringResult_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionKeyringResult_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzKeyringResult& unwrap() const { return inner_.Some.payload; }
    AzKeyringResult& unwrap() { return inner_.Some.payload; }
    AzKeyringResult unwrapOr(const AzKeyringResult& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzKeyringResult> toStdOptional() const { return isSome() ? std::optional<AzKeyringResult>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzKeyringResult>() const { return toStdOptional(); }
};

class OptionDbValue {
private:
    AzOptionDbValue inner_;

    OptionDbValue(const OptionDbValue&) = delete;
    OptionDbValue& operator=(const OptionDbValue&) = delete;

public:
    explicit OptionDbValue(AzOptionDbValue inner) noexcept : inner_(inner) {}

    OptionDbValue(OptionDbValue&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionDbValue& operator=(OptionDbValue&& other) noexcept {
        if (this != &other) {
            AzOptionDbValue_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionDbValue() { AzOptionDbValue_delete(&inner_); }

    static OptionDbValue none();
    static OptionDbValue some(AzDbValue payload);
    void delete_();
    OptionDbValue clone() const;
    bool partialEq(const OptionDbValue& b) const;
    String toDbgString() const;

    const AzOptionDbValue& inner() const { return inner_; }
    AzOptionDbValue& inner() { return inner_; }
    const AzOptionDbValue* ptr() const { return &inner_; }
    AzOptionDbValue* ptr() { return &inner_; }
    AzOptionDbValue release() { AzOptionDbValue result = inner_; inner_ = {}; return result; }
    operator AzOptionDbValue() && noexcept { AzOptionDbValue result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDbValue_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDbValue_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDbValue& unwrap() const { return inner_.Some.payload; }
    AzDbValue& unwrap() { return inner_.Some.payload; }
    AzDbValue unwrapOr(const AzDbValue& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDbValue> toStdOptional() const { return isSome() ? std::optional<AzDbValue>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDbValue>() const { return toStdOptional(); }
};

class OptionOnVideoFrame {
private:
    AzOptionOnVideoFrame inner_;

    OptionOnVideoFrame(const OptionOnVideoFrame&) = delete;
    OptionOnVideoFrame& operator=(const OptionOnVideoFrame&) = delete;

public:
    explicit OptionOnVideoFrame(AzOptionOnVideoFrame inner) noexcept : inner_(inner) {}

    OptionOnVideoFrame(OptionOnVideoFrame&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionOnVideoFrame& operator=(OptionOnVideoFrame&& other) noexcept {
        if (this != &other) {
            AzOptionOnVideoFrame_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionOnVideoFrame() { AzOptionOnVideoFrame_delete(&inner_); }

    static OptionOnVideoFrame none();
    static OptionOnVideoFrame some(OnVideoFrame payload);
    void delete_();
    OptionOnVideoFrame clone() const;
    bool partialEq(const OptionOnVideoFrame& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionOnVideoFrame& b) const;
    uint8_t cmp(const OptionOnVideoFrame& b) const;
    String toDbgString() const;

    const AzOptionOnVideoFrame& inner() const { return inner_; }
    AzOptionOnVideoFrame& inner() { return inner_; }
    const AzOptionOnVideoFrame* ptr() const { return &inner_; }
    AzOptionOnVideoFrame* ptr() { return &inner_; }
    AzOptionOnVideoFrame release() { AzOptionOnVideoFrame result = inner_; inner_ = {}; return result; }
    operator AzOptionOnVideoFrame() && noexcept { AzOptionOnVideoFrame result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionOnVideoFrame_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionOnVideoFrame_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzOnVideoFrame& unwrap() const { return inner_.Some.payload; }
    AzOnVideoFrame& unwrap() { return inner_.Some.payload; }
    AzOnVideoFrame unwrapOr(const AzOnVideoFrame& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzOnVideoFrame> toStdOptional() const { return isSome() ? std::optional<AzOnVideoFrame>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzOnVideoFrame>() const { return toStdOptional(); }
};

class OptionMapViewportChanged {
private:
    AzOptionMapViewportChanged inner_;

    OptionMapViewportChanged(const OptionMapViewportChanged&) = delete;
    OptionMapViewportChanged& operator=(const OptionMapViewportChanged&) = delete;

public:
    explicit OptionMapViewportChanged(AzOptionMapViewportChanged inner) noexcept : inner_(inner) {}

    OptionMapViewportChanged(OptionMapViewportChanged&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionMapViewportChanged& operator=(OptionMapViewportChanged&& other) noexcept {
        if (this != &other) {
            AzOptionMapViewportChanged_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionMapViewportChanged() { AzOptionMapViewportChanged_delete(&inner_); }

    static OptionMapViewportChanged none();
    static OptionMapViewportChanged some(MapViewportChanged payload);
    void delete_();
    OptionMapViewportChanged clone() const;
    bool partialEq(const OptionMapViewportChanged& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionMapViewportChanged& b) const;
    uint8_t cmp(const OptionMapViewportChanged& b) const;
    String toDbgString() const;

    const AzOptionMapViewportChanged& inner() const { return inner_; }
    AzOptionMapViewportChanged& inner() { return inner_; }
    const AzOptionMapViewportChanged* ptr() const { return &inner_; }
    AzOptionMapViewportChanged* ptr() { return &inner_; }
    AzOptionMapViewportChanged release() { AzOptionMapViewportChanged result = inner_; inner_ = {}; return result; }
    operator AzOptionMapViewportChanged() && noexcept { AzOptionMapViewportChanged result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionMapViewportChanged_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionMapViewportChanged_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzMapViewportChanged& unwrap() const { return inner_.Some.payload; }
    AzMapViewportChanged& unwrap() { return inner_.Some.payload; }
    AzMapViewportChanged unwrapOr(const AzMapViewportChanged& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzMapViewportChanged> toStdOptional() const { return isSome() ? std::optional<AzMapViewportChanged>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzMapViewportChanged>() const { return toStdOptional(); }
};

class OptionMapPinTap {
private:
    AzOptionMapPinTap inner_;

    OptionMapPinTap(const OptionMapPinTap&) = delete;
    OptionMapPinTap& operator=(const OptionMapPinTap&) = delete;

public:
    explicit OptionMapPinTap(AzOptionMapPinTap inner) noexcept : inner_(inner) {}

    OptionMapPinTap(OptionMapPinTap&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionMapPinTap& operator=(OptionMapPinTap&& other) noexcept {
        if (this != &other) {
            AzOptionMapPinTap_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionMapPinTap() { AzOptionMapPinTap_delete(&inner_); }

    static OptionMapPinTap none();
    static OptionMapPinTap some(MapPinTap payload);
    void delete_();
    OptionMapPinTap clone() const;
    bool partialEq(const OptionMapPinTap& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionMapPinTap& b) const;
    uint8_t cmp(const OptionMapPinTap& b) const;
    String toDbgString() const;

    const AzOptionMapPinTap& inner() const { return inner_; }
    AzOptionMapPinTap& inner() { return inner_; }
    const AzOptionMapPinTap* ptr() const { return &inner_; }
    AzOptionMapPinTap* ptr() { return &inner_; }
    AzOptionMapPinTap release() { AzOptionMapPinTap result = inner_; inner_ = {}; return result; }
    operator AzOptionMapPinTap() && noexcept { AzOptionMapPinTap result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionMapPinTap_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionMapPinTap_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzMapPinTap& unwrap() const { return inner_.Some.payload; }
    AzMapPinTap& unwrap() { return inner_.Some.payload; }
    AzMapPinTap unwrapOr(const AzMapPinTap& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzMapPinTap> toStdOptional() const { return isSome() ? std::optional<AzMapPinTap>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzMapPinTap>() const { return toStdOptional(); }
};

class OptionOnAudioFrame {
private:
    AzOptionOnAudioFrame inner_;

    OptionOnAudioFrame(const OptionOnAudioFrame&) = delete;
    OptionOnAudioFrame& operator=(const OptionOnAudioFrame&) = delete;

public:
    explicit OptionOnAudioFrame(AzOptionOnAudioFrame inner) noexcept : inner_(inner) {}

    OptionOnAudioFrame(OptionOnAudioFrame&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionOnAudioFrame& operator=(OptionOnAudioFrame&& other) noexcept {
        if (this != &other) {
            AzOptionOnAudioFrame_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionOnAudioFrame() { AzOptionOnAudioFrame_delete(&inner_); }

    static OptionOnAudioFrame none();
    static OptionOnAudioFrame some(OnAudioFrame payload);
    void delete_();
    OptionOnAudioFrame clone() const;
    bool partialEq(const OptionOnAudioFrame& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionOnAudioFrame& b) const;
    uint8_t cmp(const OptionOnAudioFrame& b) const;
    String toDbgString() const;

    const AzOptionOnAudioFrame& inner() const { return inner_; }
    AzOptionOnAudioFrame& inner() { return inner_; }
    const AzOptionOnAudioFrame* ptr() const { return &inner_; }
    AzOptionOnAudioFrame* ptr() { return &inner_; }
    AzOptionOnAudioFrame release() { AzOptionOnAudioFrame result = inner_; inner_ = {}; return result; }
    operator AzOptionOnAudioFrame() && noexcept { AzOptionOnAudioFrame result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionOnAudioFrame_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionOnAudioFrame_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzOnAudioFrame& unwrap() const { return inner_.Some.payload; }
    AzOnAudioFrame& unwrap() { return inner_.Some.payload; }
    AzOnAudioFrame unwrapOr(const AzOnAudioFrame& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzOnAudioFrame> toStdOptional() const { return isSome() ? std::optional<AzOnAudioFrame>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzOnAudioFrame>() const { return toStdOptional(); }
};

class OptionLoadedFont {
private:
    AzOptionLoadedFont inner_;

    OptionLoadedFont(const OptionLoadedFont&) = delete;
    OptionLoadedFont& operator=(const OptionLoadedFont&) = delete;

public:
    explicit OptionLoadedFont(AzOptionLoadedFont inner) noexcept : inner_(inner) {}

    OptionLoadedFont(OptionLoadedFont&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionLoadedFont& operator=(OptionLoadedFont&& other) noexcept {
        if (this != &other) {
            AzOptionLoadedFont_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionLoadedFont() { AzOptionLoadedFont_delete(&inner_); }

    static OptionLoadedFont none();
    static OptionLoadedFont some(LoadedFont payload);
    void delete_();
    OptionLoadedFont clone() const;
    bool partialEq(const OptionLoadedFont& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionLoadedFont& b) const;
    uint8_t cmp(const OptionLoadedFont& b) const;
    String toDbgString() const;

    const AzOptionLoadedFont& inner() const { return inner_; }
    AzOptionLoadedFont& inner() { return inner_; }
    const AzOptionLoadedFont* ptr() const { return &inner_; }
    AzOptionLoadedFont* ptr() { return &inner_; }
    AzOptionLoadedFont release() { AzOptionLoadedFont result = inner_; inner_ = {}; return result; }
    operator AzOptionLoadedFont() && noexcept { AzOptionLoadedFont result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionLoadedFont_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionLoadedFont_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzLoadedFont& unwrap() const { return inner_.Some.payload; }
    AzLoadedFont& unwrap() { return inner_.Some.payload; }
    AzLoadedFont unwrapOr(const AzLoadedFont& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzLoadedFont> toStdOptional() const { return isSome() ? std::optional<AzLoadedFont>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzLoadedFont>() const { return toStdOptional(); }
};

class ResultRawImageDecodeImageError {
private:
    AzResultRawImageDecodeImageError inner_;

    ResultRawImageDecodeImageError(const ResultRawImageDecodeImageError&) = delete;
    ResultRawImageDecodeImageError& operator=(const ResultRawImageDecodeImageError&) = delete;

public:
    explicit ResultRawImageDecodeImageError(AzResultRawImageDecodeImageError inner) noexcept : inner_(inner) {}

    ResultRawImageDecodeImageError(ResultRawImageDecodeImageError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultRawImageDecodeImageError& operator=(ResultRawImageDecodeImageError&& other) noexcept {
        if (this != &other) {
            AzResultRawImageDecodeImageError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultRawImageDecodeImageError() { AzResultRawImageDecodeImageError_delete(&inner_); }

    static ResultRawImageDecodeImageError ok(RawImage payload);
    static ResultRawImageDecodeImageError err(AzDecodeImageError payload);
    void delete_();
    ResultRawImageDecodeImageError clone() const;
    String toDbgString() const;

    const AzResultRawImageDecodeImageError& inner() const { return inner_; }
    AzResultRawImageDecodeImageError& inner() { return inner_; }
    const AzResultRawImageDecodeImageError* ptr() const { return &inner_; }
    AzResultRawImageDecodeImageError* ptr() { return &inner_; }
    AzResultRawImageDecodeImageError release() { AzResultRawImageDecodeImageError result = inner_; inner_ = {}; return result; }
    operator AzResultRawImageDecodeImageError() && noexcept { AzResultRawImageDecodeImageError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultRawImageDecodeImageError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultRawImageDecodeImageError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultEmptyStructFileError {
private:
    AzResultEmptyStructFileError inner_;

    ResultEmptyStructFileError(const ResultEmptyStructFileError&) = delete;
    ResultEmptyStructFileError& operator=(const ResultEmptyStructFileError&) = delete;

public:
    explicit ResultEmptyStructFileError(AzResultEmptyStructFileError inner) noexcept : inner_(inner) {}

    ResultEmptyStructFileError(ResultEmptyStructFileError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultEmptyStructFileError& operator=(ResultEmptyStructFileError&& other) noexcept {
        if (this != &other) {
            AzResultEmptyStructFileError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultEmptyStructFileError() { AzResultEmptyStructFileError_delete(&inner_); }

    static ResultEmptyStructFileError ok(EmptyStruct payload);
    static ResultEmptyStructFileError err(FileError payload);
    void delete_();
    ResultEmptyStructFileError clone() const;
    String toDbgString() const;

    const AzResultEmptyStructFileError& inner() const { return inner_; }
    AzResultEmptyStructFileError& inner() { return inner_; }
    const AzResultEmptyStructFileError* ptr() const { return &inner_; }
    AzResultEmptyStructFileError* ptr() { return &inner_; }
    AzResultEmptyStructFileError release() { AzResultEmptyStructFileError result = inner_; inner_ = {}; return result; }
    operator AzResultEmptyStructFileError() && noexcept { AzResultEmptyStructFileError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultEmptyStructFileError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultEmptyStructFileError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class Resultu64FileError {
private:
    AzResultu64FileError inner_;

    Resultu64FileError(const Resultu64FileError&) = delete;
    Resultu64FileError& operator=(const Resultu64FileError&) = delete;

public:
    explicit Resultu64FileError(AzResultu64FileError inner) noexcept : inner_(inner) {}

    Resultu64FileError(Resultu64FileError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    Resultu64FileError& operator=(Resultu64FileError&& other) noexcept {
        if (this != &other) {
            AzResultu64FileError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~Resultu64FileError() { AzResultu64FileError_delete(&inner_); }

    static Resultu64FileError ok(uint64_t payload);
    static Resultu64FileError err(FileError payload);
    void delete_();
    Resultu64FileError clone() const;
    String toDbgString() const;

    const AzResultu64FileError& inner() const { return inner_; }
    AzResultu64FileError& inner() { return inner_; }
    const AzResultu64FileError* ptr() const { return &inner_; }
    AzResultu64FileError* ptr() { return &inner_; }
    AzResultu64FileError release() { AzResultu64FileError result = inner_; inner_ = {}; return result; }
    operator AzResultu64FileError() && noexcept { AzResultu64FileError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultu64FileError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultu64FileError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultU8VecFileError {
private:
    AzResultU8VecFileError inner_;

    ResultU8VecFileError(const ResultU8VecFileError&) = delete;
    ResultU8VecFileError& operator=(const ResultU8VecFileError&) = delete;

public:
    explicit ResultU8VecFileError(AzResultU8VecFileError inner) noexcept : inner_(inner) {}

    ResultU8VecFileError(ResultU8VecFileError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultU8VecFileError& operator=(ResultU8VecFileError&& other) noexcept {
        if (this != &other) {
            AzResultU8VecFileError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultU8VecFileError() { AzResultU8VecFileError_delete(&inner_); }

    static ResultU8VecFileError ok(U8Vec payload);
    static ResultU8VecFileError err(FileError payload);
    void delete_();
    ResultU8VecFileError clone() const;
    String toDbgString() const;

    const AzResultU8VecFileError& inner() const { return inner_; }
    AzResultU8VecFileError& inner() { return inner_; }
    const AzResultU8VecFileError* ptr() const { return &inner_; }
    AzResultU8VecFileError* ptr() { return &inner_; }
    AzResultU8VecFileError release() { AzResultU8VecFileError result = inner_; inner_ = {}; return result; }
    operator AzResultU8VecFileError() && noexcept { AzResultU8VecFileError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultU8VecFileError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultU8VecFileError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultFileMetadataFileError {
private:
    AzResultFileMetadataFileError inner_;

    ResultFileMetadataFileError(const ResultFileMetadataFileError&) = delete;
    ResultFileMetadataFileError& operator=(const ResultFileMetadataFileError&) = delete;

public:
    explicit ResultFileMetadataFileError(AzResultFileMetadataFileError inner) noexcept : inner_(inner) {}

    ResultFileMetadataFileError(ResultFileMetadataFileError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultFileMetadataFileError& operator=(ResultFileMetadataFileError&& other) noexcept {
        if (this != &other) {
            AzResultFileMetadataFileError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultFileMetadataFileError() { AzResultFileMetadataFileError_delete(&inner_); }

    static ResultFileMetadataFileError ok(FileMetadata payload);
    static ResultFileMetadataFileError err(FileError payload);
    void delete_();
    ResultFileMetadataFileError clone() const;
    String toDbgString() const;

    const AzResultFileMetadataFileError& inner() const { return inner_; }
    AzResultFileMetadataFileError& inner() { return inner_; }
    const AzResultFileMetadataFileError* ptr() const { return &inner_; }
    AzResultFileMetadataFileError* ptr() { return &inner_; }
    AzResultFileMetadataFileError release() { AzResultFileMetadataFileError result = inner_; inner_ = {}; return result; }
    operator AzResultFileMetadataFileError() && noexcept { AzResultFileMetadataFileError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultFileMetadataFileError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultFileMetadataFileError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultStringFileError {
private:
    AzResultStringFileError inner_;

    ResultStringFileError(const ResultStringFileError&) = delete;
    ResultStringFileError& operator=(const ResultStringFileError&) = delete;

public:
    explicit ResultStringFileError(AzResultStringFileError inner) noexcept : inner_(inner) {}

    ResultStringFileError(ResultStringFileError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultStringFileError& operator=(ResultStringFileError&& other) noexcept {
        if (this != &other) {
            AzResultStringFileError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultStringFileError() { AzResultStringFileError_delete(&inner_); }

    static ResultStringFileError ok(String payload);
    static ResultStringFileError err(FileError payload);
    void delete_();
    ResultStringFileError clone() const;
    String toDbgString() const;

    const AzResultStringFileError& inner() const { return inner_; }
    AzResultStringFileError& inner() { return inner_; }
    const AzResultStringFileError* ptr() const { return &inner_; }
    AzResultStringFileError* ptr() { return &inner_; }
    AzResultStringFileError release() { AzResultStringFileError result = inner_; inner_ = {}; return result; }
    operator AzResultStringFileError() && noexcept { AzResultStringFileError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultStringFileError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultStringFileError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultDirEntryVecFileError {
private:
    AzResultDirEntryVecFileError inner_;

    ResultDirEntryVecFileError(const ResultDirEntryVecFileError&) = delete;
    ResultDirEntryVecFileError& operator=(const ResultDirEntryVecFileError&) = delete;

public:
    explicit ResultDirEntryVecFileError(AzResultDirEntryVecFileError inner) noexcept : inner_(inner) {}

    ResultDirEntryVecFileError(ResultDirEntryVecFileError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultDirEntryVecFileError& operator=(ResultDirEntryVecFileError&& other) noexcept {
        if (this != &other) {
            AzResultDirEntryVecFileError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultDirEntryVecFileError() { AzResultDirEntryVecFileError_delete(&inner_); }

    static ResultDirEntryVecFileError ok(DirEntryVec payload);
    static ResultDirEntryVecFileError err(FileError payload);
    void delete_();
    ResultDirEntryVecFileError clone() const;
    String toDbgString() const;

    const AzResultDirEntryVecFileError& inner() const { return inner_; }
    AzResultDirEntryVecFileError& inner() { return inner_; }
    const AzResultDirEntryVecFileError* ptr() const { return &inner_; }
    AzResultDirEntryVecFileError* ptr() { return &inner_; }
    AzResultDirEntryVecFileError release() { AzResultDirEntryVecFileError result = inner_; inner_ = {}; return result; }
    operator AzResultDirEntryVecFileError() && noexcept { AzResultDirEntryVecFileError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultDirEntryVecFileError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultDirEntryVecFileError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultFilePathFileError {
private:
    AzResultFilePathFileError inner_;

    ResultFilePathFileError(const ResultFilePathFileError&) = delete;
    ResultFilePathFileError& operator=(const ResultFilePathFileError&) = delete;

public:
    explicit ResultFilePathFileError(AzResultFilePathFileError inner) noexcept : inner_(inner) {}

    ResultFilePathFileError(ResultFilePathFileError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultFilePathFileError& operator=(ResultFilePathFileError&& other) noexcept {
        if (this != &other) {
            AzResultFilePathFileError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultFilePathFileError() { AzResultFilePathFileError_delete(&inner_); }

    static ResultFilePathFileError ok(FilePath payload);
    static ResultFilePathFileError err(FileError payload);
    void delete_();
    ResultFilePathFileError clone() const;
    String toDbgString() const;

    const AzResultFilePathFileError& inner() const { return inner_; }
    AzResultFilePathFileError& inner() { return inner_; }
    const AzResultFilePathFileError* ptr() const { return &inner_; }
    AzResultFilePathFileError* ptr() { return &inner_; }
    AzResultFilePathFileError release() { AzResultFilePathFileError result = inner_; inner_ = {}; return result; }
    operator AzResultFilePathFileError() && noexcept { AzResultFilePathFileError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultFilePathFileError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultFilePathFileError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultUrlUrlParseError {
private:
    AzResultUrlUrlParseError inner_;

    ResultUrlUrlParseError(const ResultUrlUrlParseError&) = delete;
    ResultUrlUrlParseError& operator=(const ResultUrlUrlParseError&) = delete;

public:
    explicit ResultUrlUrlParseError(AzResultUrlUrlParseError inner) noexcept : inner_(inner) {}

    ResultUrlUrlParseError(ResultUrlUrlParseError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultUrlUrlParseError& operator=(ResultUrlUrlParseError&& other) noexcept {
        if (this != &other) {
            AzResultUrlUrlParseError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultUrlUrlParseError() { AzResultUrlUrlParseError_delete(&inner_); }

    static ResultUrlUrlParseError ok(Url payload);
    static ResultUrlUrlParseError err(UrlParseError payload);
    void delete_();
    ResultUrlUrlParseError clone() const;
    String toDbgString() const;

    const AzResultUrlUrlParseError& inner() const { return inner_; }
    AzResultUrlUrlParseError& inner() { return inner_; }
    const AzResultUrlUrlParseError* ptr() const { return &inner_; }
    AzResultUrlUrlParseError* ptr() { return &inner_; }
    AzResultUrlUrlParseError release() { AzResultUrlUrlParseError result = inner_; inner_ = {}; return result; }
    operator AzResultUrlUrlParseError() && noexcept { AzResultUrlUrlParseError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultUrlUrlParseError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultUrlUrlParseError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class OptionTimer {
private:
    AzOptionTimer inner_;

    OptionTimer(const OptionTimer&) = delete;
    OptionTimer& operator=(const OptionTimer&) = delete;

public:
    explicit OptionTimer(AzOptionTimer inner) noexcept : inner_(inner) {}

    OptionTimer(OptionTimer&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionTimer& operator=(OptionTimer&& other) noexcept {
        if (this != &other) {
            AzOptionTimer_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionTimer() { AzOptionTimer_delete(&inner_); }

    static OptionTimer none();
    static OptionTimer some(Timer payload);
    void delete_();
    OptionTimer clone() const;
    String toDbgString() const;

    const AzOptionTimer& inner() const { return inner_; }
    AzOptionTimer& inner() { return inner_; }
    const AzOptionTimer* ptr() const { return &inner_; }
    AzOptionTimer* ptr() { return &inner_; }
    AzOptionTimer release() { AzOptionTimer result = inner_; inner_ = {}; return result; }
    operator AzOptionTimer() && noexcept { AzOptionTimer result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionTimer_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionTimer_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzTimer& unwrap() const { return inner_.Some.payload; }
    AzTimer& unwrap() { return inner_.Some.payload; }
    AzTimer unwrapOr(const AzTimer& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzTimer> toStdOptional() const { return isSome() ? std::optional<AzTimer>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzTimer>() const { return toStdOptional(); }
};

class OptionDragState {
private:
    AzOptionDragState inner_;

    OptionDragState(const OptionDragState&) = delete;
    OptionDragState& operator=(const OptionDragState&) = delete;

public:
    explicit OptionDragState(AzOptionDragState inner) noexcept : inner_(inner) {}

    OptionDragState(OptionDragState&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionDragState& operator=(OptionDragState&& other) noexcept {
        if (this != &other) {
            AzOptionDragState_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionDragState() { AzOptionDragState_delete(&inner_); }

    static OptionDragState none();
    static OptionDragState some(DragState payload);
    void delete_();
    OptionDragState clone() const;
    bool partialEq(const OptionDragState& b) const;
    String toDbgString() const;

    const AzOptionDragState& inner() const { return inner_; }
    AzOptionDragState& inner() { return inner_; }
    const AzOptionDragState* ptr() const { return &inner_; }
    AzOptionDragState* ptr() { return &inner_; }
    AzOptionDragState release() { AzOptionDragState result = inner_; inner_ = {}; return result; }
    operator AzOptionDragState() && noexcept { AzOptionDragState result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDragState_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDragState_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDragState& unwrap() const { return inner_.Some.payload; }
    AzDragState& unwrap() { return inner_.Some.payload; }
    AzDragState unwrapOr(const AzDragState& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDragState> toStdOptional() const { return isSome() ? std::optional<AzDragState>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDragState>() const { return toStdOptional(); }
};

class OptionJson {
private:
    AzOptionJson inner_;

    OptionJson(const OptionJson&) = delete;
    OptionJson& operator=(const OptionJson&) = delete;

public:
    explicit OptionJson(AzOptionJson inner) noexcept : inner_(inner) {}

    OptionJson(OptionJson&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionJson& operator=(OptionJson&& other) noexcept {
        if (this != &other) {
            AzOptionJson_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionJson() { AzOptionJson_delete(&inner_); }

    static OptionJson none();
    static OptionJson some(Json payload);
    void delete_();
    OptionJson clone() const;
    bool partialEq(const OptionJson& b) const;
    String toDbgString() const;

    const AzOptionJson& inner() const { return inner_; }
    AzOptionJson& inner() { return inner_; }
    const AzOptionJson* ptr() const { return &inner_; }
    AzOptionJson* ptr() { return &inner_; }
    AzOptionJson release() { AzOptionJson result = inner_; inner_ = {}; return result; }
    operator AzOptionJson() && noexcept { AzOptionJson result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionJson_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionJson_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzJson& unwrap() const { return inner_.Some.payload; }
    AzJson& unwrap() { return inner_.Some.payload; }
    AzJson unwrapOr(const AzJson& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzJson> toStdOptional() const { return isSome() ? std::optional<AzJson>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzJson>() const { return toStdOptional(); }
};

class OptionFmtArg {
private:
    AzOptionFmtArg inner_;

    OptionFmtArg(const OptionFmtArg&) = delete;
    OptionFmtArg& operator=(const OptionFmtArg&) = delete;

public:
    explicit OptionFmtArg(AzOptionFmtArg inner) noexcept : inner_(inner) {}

    OptionFmtArg(OptionFmtArg&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionFmtArg& operator=(OptionFmtArg&& other) noexcept {
        if (this != &other) {
            AzOptionFmtArg_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionFmtArg() { AzOptionFmtArg_delete(&inner_); }

    static OptionFmtArg none();
    static OptionFmtArg some(FmtArg payload);
    void delete_();
    OptionFmtArg clone() const;
    bool partialEq(const OptionFmtArg& b) const;
    uint8_t partialCmp(const OptionFmtArg& b) const;
    String toDbgString() const;

    const AzOptionFmtArg& inner() const { return inner_; }
    AzOptionFmtArg& inner() { return inner_; }
    const AzOptionFmtArg* ptr() const { return &inner_; }
    AzOptionFmtArg* ptr() { return &inner_; }
    AzOptionFmtArg release() { AzOptionFmtArg result = inner_; inner_ = {}; return result; }
    operator AzOptionFmtArg() && noexcept { AzOptionFmtArg result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionFmtArg_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionFmtArg_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzFmtArg& unwrap() const { return inner_.Some.payload; }
    AzFmtArg& unwrap() { return inner_.Some.payload; }
    AzFmtArg unwrapOr(const AzFmtArg& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzFmtArg> toStdOptional() const { return isSome() ? std::optional<AzFmtArg>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzFmtArg>() const { return toStdOptional(); }
};

class OptionMonitor {
private:
    AzOptionMonitor inner_;

    OptionMonitor(const OptionMonitor&) = delete;
    OptionMonitor& operator=(const OptionMonitor&) = delete;

public:
    explicit OptionMonitor(AzOptionMonitor inner) noexcept : inner_(inner) {}

    OptionMonitor(OptionMonitor&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionMonitor& operator=(OptionMonitor&& other) noexcept {
        if (this != &other) {
            AzOptionMonitor_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionMonitor() { AzOptionMonitor_delete(&inner_); }

    static OptionMonitor none();
    static OptionMonitor some(Monitor payload);
    void delete_();
    OptionMonitor clone() const;
    bool partialEq(const OptionMonitor& b) const;
    uint8_t partialCmp(const OptionMonitor& b) const;
    String toDbgString() const;

    const AzOptionMonitor& inner() const { return inner_; }
    AzOptionMonitor& inner() { return inner_; }
    const AzOptionMonitor* ptr() const { return &inner_; }
    AzOptionMonitor* ptr() { return &inner_; }
    AzOptionMonitor release() { AzOptionMonitor result = inner_; inner_ = {}; return result; }
    operator AzOptionMonitor() && noexcept { AzOptionMonitor result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionMonitor_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionMonitor_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzMonitor& unwrap() const { return inner_.Some.payload; }
    AzMonitor& unwrap() { return inner_.Some.payload; }
    AzMonitor unwrapOr(const AzMonitor& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzMonitor> toStdOptional() const { return isSome() ? std::optional<AzMonitor>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzMonitor>() const { return toStdOptional(); }
};

class OptionStyleBackgroundContent {
private:
    AzOptionStyleBackgroundContent inner_;

    OptionStyleBackgroundContent(const OptionStyleBackgroundContent&) = delete;
    OptionStyleBackgroundContent& operator=(const OptionStyleBackgroundContent&) = delete;

public:
    explicit OptionStyleBackgroundContent(AzOptionStyleBackgroundContent inner) noexcept : inner_(inner) {}

    OptionStyleBackgroundContent(OptionStyleBackgroundContent&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionStyleBackgroundContent& operator=(OptionStyleBackgroundContent&& other) noexcept {
        if (this != &other) {
            AzOptionStyleBackgroundContent_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionStyleBackgroundContent() { AzOptionStyleBackgroundContent_delete(&inner_); }

    static OptionStyleBackgroundContent none();
    static OptionStyleBackgroundContent some(AzStyleBackgroundContent payload);
    void delete_();
    OptionStyleBackgroundContent clone() const;
    bool partialEq(const OptionStyleBackgroundContent& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionStyleBackgroundContent& b) const;
    uint8_t cmp(const OptionStyleBackgroundContent& b) const;
    String toDbgString() const;

    const AzOptionStyleBackgroundContent& inner() const { return inner_; }
    AzOptionStyleBackgroundContent& inner() { return inner_; }
    const AzOptionStyleBackgroundContent* ptr() const { return &inner_; }
    AzOptionStyleBackgroundContent* ptr() { return &inner_; }
    AzOptionStyleBackgroundContent release() { AzOptionStyleBackgroundContent result = inner_; inner_ = {}; return result; }
    operator AzOptionStyleBackgroundContent() && noexcept { AzOptionStyleBackgroundContent result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionStyleBackgroundContent_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionStyleBackgroundContent_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzStyleBackgroundContent& unwrap() const { return inner_.Some.payload; }
    AzStyleBackgroundContent& unwrap() { return inner_.Some.payload; }
    AzStyleBackgroundContent unwrapOr(const AzStyleBackgroundContent& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzStyleBackgroundContent> toStdOptional() const { return isSome() ? std::optional<AzStyleBackgroundContent>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzStyleBackgroundContent>() const { return toStdOptional(); }
};

class OptionStyledTextRun {
private:
    AzOptionStyledTextRun inner_;

    OptionStyledTextRun(const OptionStyledTextRun&) = delete;
    OptionStyledTextRun& operator=(const OptionStyledTextRun&) = delete;

public:
    explicit OptionStyledTextRun(AzOptionStyledTextRun inner) noexcept : inner_(inner) {}

    OptionStyledTextRun(OptionStyledTextRun&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionStyledTextRun& operator=(OptionStyledTextRun&& other) noexcept {
        if (this != &other) {
            AzOptionStyledTextRun_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionStyledTextRun() { AzOptionStyledTextRun_delete(&inner_); }

    static OptionStyledTextRun none();
    static OptionStyledTextRun some(StyledTextRun payload);
    void delete_();
    OptionStyledTextRun clone() const;
    bool partialEq(const OptionStyledTextRun& b) const;
    String toDbgString() const;

    const AzOptionStyledTextRun& inner() const { return inner_; }
    AzOptionStyledTextRun& inner() { return inner_; }
    const AzOptionStyledTextRun* ptr() const { return &inner_; }
    AzOptionStyledTextRun* ptr() { return &inner_; }
    AzOptionStyledTextRun release() { AzOptionStyledTextRun result = inner_; inner_ = {}; return result; }
    operator AzOptionStyledTextRun() && noexcept { AzOptionStyledTextRun result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionStyledTextRun_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionStyledTextRun_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzStyledTextRun& unwrap() const { return inner_.Some.payload; }
    AzStyledTextRun& unwrap() { return inner_.Some.payload; }
    AzStyledTextRun unwrapOr(const AzStyledTextRun& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzStyledTextRun> toStdOptional() const { return isSome() ? std::optional<AzStyledTextRun>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzStyledTextRun>() const { return toStdOptional(); }
};

class OptionDynamicSelector {
private:
    AzOptionDynamicSelector inner_;

    OptionDynamicSelector(const OptionDynamicSelector&) = delete;
    OptionDynamicSelector& operator=(const OptionDynamicSelector&) = delete;

public:
    explicit OptionDynamicSelector(AzOptionDynamicSelector inner) noexcept : inner_(inner) {}

    OptionDynamicSelector(OptionDynamicSelector&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionDynamicSelector& operator=(OptionDynamicSelector&& other) noexcept {
        if (this != &other) {
            AzOptionDynamicSelector_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionDynamicSelector() { AzOptionDynamicSelector_delete(&inner_); }

    static OptionDynamicSelector none();
    static OptionDynamicSelector some(AzDynamicSelector payload);
    void delete_();
    OptionDynamicSelector clone() const;
    bool partialEq(const OptionDynamicSelector& b) const;
    String toDbgString() const;

    const AzOptionDynamicSelector& inner() const { return inner_; }
    AzOptionDynamicSelector& inner() { return inner_; }
    const AzOptionDynamicSelector* ptr() const { return &inner_; }
    AzOptionDynamicSelector* ptr() { return &inner_; }
    AzOptionDynamicSelector release() { AzOptionDynamicSelector result = inner_; inner_ = {}; return result; }
    operator AzOptionDynamicSelector() && noexcept { AzOptionDynamicSelector result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDynamicSelector_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDynamicSelector_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDynamicSelector& unwrap() const { return inner_.Some.payload; }
    AzDynamicSelector& unwrap() { return inner_.Some.payload; }
    AzDynamicSelector unwrapOr(const AzDynamicSelector& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDynamicSelector> toStdOptional() const { return isSome() ? std::optional<AzDynamicSelector>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDynamicSelector>() const { return toStdOptional(); }
};

class OptionAttributeType {
private:
    AzOptionAttributeType inner_;

    OptionAttributeType(const OptionAttributeType&) = delete;
    OptionAttributeType& operator=(const OptionAttributeType&) = delete;

public:
    explicit OptionAttributeType(AzOptionAttributeType inner) noexcept : inner_(inner) {}

    OptionAttributeType(OptionAttributeType&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionAttributeType& operator=(OptionAttributeType&& other) noexcept {
        if (this != &other) {
            AzOptionAttributeType_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionAttributeType() { AzOptionAttributeType_delete(&inner_); }

    static OptionAttributeType none();
    static OptionAttributeType some(AzAttributeType payload);
    void delete_();
    OptionAttributeType clone() const;
    bool partialEq(const OptionAttributeType& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionAttributeType& b) const;
    uint8_t cmp(const OptionAttributeType& b) const;
    String toDbgString() const;

    const AzOptionAttributeType& inner() const { return inner_; }
    AzOptionAttributeType& inner() { return inner_; }
    const AzOptionAttributeType* ptr() const { return &inner_; }
    AzOptionAttributeType* ptr() { return &inner_; }
    AzOptionAttributeType release() { AzOptionAttributeType result = inner_; inner_ = {}; return result; }
    operator AzOptionAttributeType() && noexcept { AzOptionAttributeType result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionAttributeType_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionAttributeType_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzAttributeType& unwrap() const { return inner_.Some.payload; }
    AzAttributeType& unwrap() { return inner_.Some.payload; }
    AzAttributeType unwrapOr(const AzAttributeType& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzAttributeType> toStdOptional() const { return isSome() ? std::optional<AzAttributeType>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzAttributeType>() const { return toStdOptional(); }
};

class OptionComponentDef {
private:
    AzOptionComponentDef inner_;

    OptionComponentDef(const OptionComponentDef&) = delete;
    OptionComponentDef& operator=(const OptionComponentDef&) = delete;

public:
    explicit OptionComponentDef(AzOptionComponentDef inner) noexcept : inner_(inner) {}

    OptionComponentDef(OptionComponentDef&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionComponentDef& operator=(OptionComponentDef&& other) noexcept {
        if (this != &other) {
            AzOptionComponentDef_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionComponentDef() { AzOptionComponentDef_delete(&inner_); }

    static OptionComponentDef none();
    static OptionComponentDef some(ComponentDef payload);
    void delete_();
    OptionComponentDef clone() const;

    const AzOptionComponentDef& inner() const { return inner_; }
    AzOptionComponentDef& inner() { return inner_; }
    const AzOptionComponentDef* ptr() const { return &inner_; }
    AzOptionComponentDef* ptr() { return &inner_; }
    AzOptionComponentDef release() { AzOptionComponentDef result = inner_; inner_ = {}; return result; }
    operator AzOptionComponentDef() && noexcept { AzOptionComponentDef result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionComponentDef_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionComponentDef_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzComponentDef& unwrap() const { return inner_.Some.payload; }
    AzComponentDef& unwrap() { return inner_.Some.payload; }
    AzComponentDef unwrapOr(const AzComponentDef& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzComponentDef> toStdOptional() const { return isSome() ? std::optional<AzComponentDef>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzComponentDef>() const { return toStdOptional(); }
};

class OptionComponentDefaultValue {
private:
    AzOptionComponentDefaultValue inner_;

    OptionComponentDefaultValue(const OptionComponentDefaultValue&) = delete;
    OptionComponentDefaultValue& operator=(const OptionComponentDefaultValue&) = delete;

public:
    explicit OptionComponentDefaultValue(AzOptionComponentDefaultValue inner) noexcept : inner_(inner) {}

    OptionComponentDefaultValue(OptionComponentDefaultValue&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionComponentDefaultValue& operator=(OptionComponentDefaultValue&& other) noexcept {
        if (this != &other) {
            AzOptionComponentDefaultValue_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionComponentDefaultValue() { AzOptionComponentDefaultValue_delete(&inner_); }

    static OptionComponentDefaultValue none();
    static OptionComponentDefaultValue some(AzComponentDefaultValue payload);
    void delete_();
    OptionComponentDefaultValue clone() const;
    bool partialEq(const OptionComponentDefaultValue& b) const;
    String toDbgString() const;

    const AzOptionComponentDefaultValue& inner() const { return inner_; }
    AzOptionComponentDefaultValue& inner() { return inner_; }
    const AzOptionComponentDefaultValue* ptr() const { return &inner_; }
    AzOptionComponentDefaultValue* ptr() { return &inner_; }
    AzOptionComponentDefaultValue release() { AzOptionComponentDefaultValue result = inner_; inner_ = {}; return result; }
    operator AzOptionComponentDefaultValue() && noexcept { AzOptionComponentDefaultValue result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionComponentDefaultValue_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionComponentDefaultValue_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzComponentDefaultValue& unwrap() const { return inner_.Some.payload; }
    AzComponentDefaultValue& unwrap() { return inner_.Some.payload; }
    AzComponentDefaultValue unwrapOr(const AzComponentDefaultValue& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzComponentDefaultValue> toStdOptional() const { return isSome() ? std::optional<AzComponentDefaultValue>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzComponentDefaultValue>() const { return toStdOptional(); }
};

class OptionComponentFieldOverride {
private:
    AzOptionComponentFieldOverride inner_;

    OptionComponentFieldOverride(const OptionComponentFieldOverride&) = delete;
    OptionComponentFieldOverride& operator=(const OptionComponentFieldOverride&) = delete;

public:
    explicit OptionComponentFieldOverride(AzOptionComponentFieldOverride inner) noexcept : inner_(inner) {}

    OptionComponentFieldOverride(OptionComponentFieldOverride&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionComponentFieldOverride& operator=(OptionComponentFieldOverride&& other) noexcept {
        if (this != &other) {
            AzOptionComponentFieldOverride_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionComponentFieldOverride() { AzOptionComponentFieldOverride_delete(&inner_); }

    static OptionComponentFieldOverride none();
    static OptionComponentFieldOverride some(ComponentFieldOverride payload);
    void delete_();
    OptionComponentFieldOverride clone() const;
    bool partialEq(const OptionComponentFieldOverride& b) const;
    String toDbgString() const;

    const AzOptionComponentFieldOverride& inner() const { return inner_; }
    AzOptionComponentFieldOverride& inner() { return inner_; }
    const AzOptionComponentFieldOverride* ptr() const { return &inner_; }
    AzOptionComponentFieldOverride* ptr() { return &inner_; }
    AzOptionComponentFieldOverride release() { AzOptionComponentFieldOverride result = inner_; inner_ = {}; return result; }
    operator AzOptionComponentFieldOverride() && noexcept { AzOptionComponentFieldOverride result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionComponentFieldOverride_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionComponentFieldOverride_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzComponentFieldOverride& unwrap() const { return inner_.Some.payload; }
    AzComponentFieldOverride& unwrap() { return inner_.Some.payload; }
    AzComponentFieldOverride unwrapOr(const AzComponentFieldOverride& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzComponentFieldOverride> toStdOptional() const { return isSome() ? std::optional<AzComponentFieldOverride>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzComponentFieldOverride>() const { return toStdOptional(); }
};

class ResultHttpResponseHttpError {
private:
    AzResultHttpResponseHttpError inner_;

    ResultHttpResponseHttpError(const ResultHttpResponseHttpError&) = delete;
    ResultHttpResponseHttpError& operator=(const ResultHttpResponseHttpError&) = delete;

public:
    explicit ResultHttpResponseHttpError(AzResultHttpResponseHttpError inner) noexcept : inner_(inner) {}

    ResultHttpResponseHttpError(ResultHttpResponseHttpError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultHttpResponseHttpError& operator=(ResultHttpResponseHttpError&& other) noexcept {
        if (this != &other) {
            AzResultHttpResponseHttpError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultHttpResponseHttpError() { AzResultHttpResponseHttpError_delete(&inner_); }

    static ResultHttpResponseHttpError ok(HttpResponse payload);
    static ResultHttpResponseHttpError err(AzHttpError payload);
    void delete_();
    ResultHttpResponseHttpError clone() const;
    String toDbgString() const;

    const AzResultHttpResponseHttpError& inner() const { return inner_; }
    AzResultHttpResponseHttpError& inner() { return inner_; }
    const AzResultHttpResponseHttpError* ptr() const { return &inner_; }
    AzResultHttpResponseHttpError* ptr() { return &inner_; }
    AzResultHttpResponseHttpError release() { AzResultHttpResponseHttpError result = inner_; inner_ = {}; return result; }
    operator AzResultHttpResponseHttpError() && noexcept { AzResultHttpResponseHttpError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultHttpResponseHttpError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultHttpResponseHttpError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultU8VecHttpError {
private:
    AzResultU8VecHttpError inner_;

    ResultU8VecHttpError(const ResultU8VecHttpError&) = delete;
    ResultU8VecHttpError& operator=(const ResultU8VecHttpError&) = delete;

public:
    explicit ResultU8VecHttpError(AzResultU8VecHttpError inner) noexcept : inner_(inner) {}

    ResultU8VecHttpError(ResultU8VecHttpError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultU8VecHttpError& operator=(ResultU8VecHttpError&& other) noexcept {
        if (this != &other) {
            AzResultU8VecHttpError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultU8VecHttpError() { AzResultU8VecHttpError_delete(&inner_); }

    static ResultU8VecHttpError ok(U8Vec payload);
    static ResultU8VecHttpError err(AzHttpError payload);
    void delete_();
    ResultU8VecHttpError clone() const;
    String toDbgString() const;

    const AzResultU8VecHttpError& inner() const { return inner_; }
    AzResultU8VecHttpError& inner() { return inner_; }
    const AzResultU8VecHttpError* ptr() const { return &inner_; }
    AzResultU8VecHttpError* ptr() { return &inner_; }
    AzResultU8VecHttpError release() { AzResultU8VecHttpError result = inner_; inner_ = {}; return result; }
    operator AzResultU8VecHttpError() && noexcept { AzResultU8VecHttpError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultU8VecHttpError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultU8VecHttpError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultJsonJsonParseError {
private:
    AzResultJsonJsonParseError inner_;

    ResultJsonJsonParseError(const ResultJsonJsonParseError&) = delete;
    ResultJsonJsonParseError& operator=(const ResultJsonJsonParseError&) = delete;

public:
    explicit ResultJsonJsonParseError(AzResultJsonJsonParseError inner) noexcept : inner_(inner) {}

    ResultJsonJsonParseError(ResultJsonJsonParseError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultJsonJsonParseError& operator=(ResultJsonJsonParseError&& other) noexcept {
        if (this != &other) {
            AzResultJsonJsonParseError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultJsonJsonParseError() { AzResultJsonJsonParseError_delete(&inner_); }

    static ResultJsonJsonParseError ok(Json payload);
    static ResultJsonJsonParseError err(JsonParseError payload);
    void delete_();
    ResultJsonJsonParseError clone() const;
    String toDbgString() const;

    const AzResultJsonJsonParseError& inner() const { return inner_; }
    AzResultJsonJsonParseError& inner() { return inner_; }
    const AzResultJsonJsonParseError* ptr() const { return &inner_; }
    AzResultJsonJsonParseError* ptr() { return &inner_; }
    AzResultJsonJsonParseError release() { AzResultJsonJsonParseError result = inner_; inner_ = {}; return result; }
    operator AzResultJsonJsonParseError() && noexcept { AzResultJsonJsonParseError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultJsonJsonParseError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultJsonJsonParseError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class OptionExternalResource {
private:
    AzOptionExternalResource inner_;

    OptionExternalResource(const OptionExternalResource&) = delete;
    OptionExternalResource& operator=(const OptionExternalResource&) = delete;

public:
    explicit OptionExternalResource(AzOptionExternalResource inner) noexcept : inner_(inner) {}

    OptionExternalResource(OptionExternalResource&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionExternalResource& operator=(OptionExternalResource&& other) noexcept {
        if (this != &other) {
            AzOptionExternalResource_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionExternalResource() { AzOptionExternalResource_delete(&inner_); }

    static OptionExternalResource none();
    static OptionExternalResource some(ExternalResource payload);
    void delete_();
    OptionExternalResource clone() const;
    bool partialEq(const OptionExternalResource& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionExternalResource& b) const;
    uint8_t cmp(const OptionExternalResource& b) const;
    String toDbgString() const;

    const AzOptionExternalResource& inner() const { return inner_; }
    AzOptionExternalResource& inner() { return inner_; }
    const AzOptionExternalResource* ptr() const { return &inner_; }
    AzOptionExternalResource* ptr() { return &inner_; }
    AzOptionExternalResource release() { AzOptionExternalResource result = inner_; inner_ = {}; return result; }
    operator AzOptionExternalResource() && noexcept { AzOptionExternalResource result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionExternalResource_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionExternalResource_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzExternalResource& unwrap() const { return inner_.Some.payload; }
    AzExternalResource& unwrap() { return inner_.Some.payload; }
    AzExternalResource unwrapOr(const AzExternalResource& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzExternalResource> toStdOptional() const { return isSome() ? std::optional<AzExternalResource>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzExternalResource>() const { return toStdOptional(); }
};

class OptionJsonKeyValue {
private:
    AzOptionJsonKeyValue inner_;

    OptionJsonKeyValue(const OptionJsonKeyValue&) = delete;
    OptionJsonKeyValue& operator=(const OptionJsonKeyValue&) = delete;

public:
    explicit OptionJsonKeyValue(AzOptionJsonKeyValue inner) noexcept : inner_(inner) {}

    OptionJsonKeyValue(OptionJsonKeyValue&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionJsonKeyValue& operator=(OptionJsonKeyValue&& other) noexcept {
        if (this != &other) {
            AzOptionJsonKeyValue_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionJsonKeyValue() { AzOptionJsonKeyValue_delete(&inner_); }

    static OptionJsonKeyValue none();
    static OptionJsonKeyValue some(JsonKeyValue payload);
    void delete_();
    OptionJsonKeyValue clone() const;
    bool partialEq(const OptionJsonKeyValue& b) const;
    String toDbgString() const;

    const AzOptionJsonKeyValue& inner() const { return inner_; }
    AzOptionJsonKeyValue& inner() { return inner_; }
    const AzOptionJsonKeyValue* ptr() const { return &inner_; }
    AzOptionJsonKeyValue* ptr() { return &inner_; }
    AzOptionJsonKeyValue release() { AzOptionJsonKeyValue result = inner_; inner_ = {}; return result; }
    operator AzOptionJsonKeyValue() && noexcept { AzOptionJsonKeyValue result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionJsonKeyValue_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionJsonKeyValue_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzJsonKeyValue& unwrap() const { return inner_.Some.payload; }
    AzJsonKeyValue& unwrap() { return inner_.Some.payload; }
    AzJsonKeyValue unwrapOr(const AzJsonKeyValue& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzJsonKeyValue> toStdOptional() const { return isSome() ? std::optional<AzJsonKeyValue>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzJsonKeyValue>() const { return toStdOptional(); }
};

class OptionXmlNodeChild {
private:
    AzOptionXmlNodeChild inner_;

    OptionXmlNodeChild(const OptionXmlNodeChild&) = delete;
    OptionXmlNodeChild& operator=(const OptionXmlNodeChild&) = delete;

public:
    explicit OptionXmlNodeChild(AzOptionXmlNodeChild inner) noexcept : inner_(inner) {}

    OptionXmlNodeChild(OptionXmlNodeChild&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionXmlNodeChild& operator=(OptionXmlNodeChild&& other) noexcept {
        if (this != &other) {
            AzOptionXmlNodeChild_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionXmlNodeChild() { AzOptionXmlNodeChild_delete(&inner_); }

    static OptionXmlNodeChild none();
    static OptionXmlNodeChild some(AzXmlNodeChild payload);
    void delete_();
    OptionXmlNodeChild clone() const;
    bool partialEq(const OptionXmlNodeChild& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionXmlNodeChild& b) const;
    uint8_t cmp(const OptionXmlNodeChild& b) const;
    String toDbgString() const;

    const AzOptionXmlNodeChild& inner() const { return inner_; }
    AzOptionXmlNodeChild& inner() { return inner_; }
    const AzOptionXmlNodeChild* ptr() const { return &inner_; }
    AzOptionXmlNodeChild* ptr() { return &inner_; }
    AzOptionXmlNodeChild release() { AzOptionXmlNodeChild result = inner_; inner_ = {}; return result; }
    operator AzOptionXmlNodeChild() && noexcept { AzOptionXmlNodeChild result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionXmlNodeChild_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionXmlNodeChild_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzXmlNodeChild& unwrap() const { return inner_.Some.payload; }
    AzXmlNodeChild& unwrap() { return inner_.Some.payload; }
    AzXmlNodeChild unwrapOr(const AzXmlNodeChild& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzXmlNodeChild> toStdOptional() const { return isSome() ? std::optional<AzXmlNodeChild>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzXmlNodeChild>() const { return toStdOptional(); }
};

class OptionCssPathSelector {
private:
    AzOptionCssPathSelector inner_;

    OptionCssPathSelector(const OptionCssPathSelector&) = delete;
    OptionCssPathSelector& operator=(const OptionCssPathSelector&) = delete;

public:
    explicit OptionCssPathSelector(AzOptionCssPathSelector inner) noexcept : inner_(inner) {}

    OptionCssPathSelector(OptionCssPathSelector&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionCssPathSelector& operator=(OptionCssPathSelector&& other) noexcept {
        if (this != &other) {
            AzOptionCssPathSelector_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionCssPathSelector() { AzOptionCssPathSelector_delete(&inner_); }

    static OptionCssPathSelector none();
    static OptionCssPathSelector some(AzCssPathSelector payload);
    void delete_();
    OptionCssPathSelector clone() const;
    bool partialEq(const OptionCssPathSelector& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionCssPathSelector& b) const;
    uint8_t cmp(const OptionCssPathSelector& b) const;
    String toDbgString() const;

    const AzOptionCssPathSelector& inner() const { return inner_; }
    AzOptionCssPathSelector& inner() { return inner_; }
    const AzOptionCssPathSelector* ptr() const { return &inner_; }
    AzOptionCssPathSelector* ptr() { return &inner_; }
    AzOptionCssPathSelector release() { AzOptionCssPathSelector result = inner_; inner_ = {}; return result; }
    operator AzOptionCssPathSelector() && noexcept { AzOptionCssPathSelector result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCssPathSelector_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCssPathSelector_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCssPathSelector& unwrap() const { return inner_.Some.payload; }
    AzCssPathSelector& unwrap() { return inner_.Some.payload; }
    AzCssPathSelector unwrapOr(const AzCssPathSelector& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCssPathSelector> toStdOptional() const { return isSome() ? std::optional<AzCssPathSelector>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCssPathSelector>() const { return toStdOptional(); }
};

class OptionNodeData {
private:
    AzOptionNodeData inner_;

    OptionNodeData(const OptionNodeData&) = delete;
    OptionNodeData& operator=(const OptionNodeData&) = delete;

public:
    explicit OptionNodeData(AzOptionNodeData inner) noexcept : inner_(inner) {}

    OptionNodeData(OptionNodeData&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionNodeData& operator=(OptionNodeData&& other) noexcept {
        if (this != &other) {
            AzOptionNodeData_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionNodeData() { AzOptionNodeData_delete(&inner_); }

    static OptionNodeData none();
    static OptionNodeData some(NodeData payload);
    void delete_();
    bool partialEq(const OptionNodeData& b) const;
    uint8_t partialCmp(const OptionNodeData& b) const;
    uint8_t cmp(const OptionNodeData& b) const;
    String toDbgString() const;

    const AzOptionNodeData& inner() const { return inner_; }
    AzOptionNodeData& inner() { return inner_; }
    const AzOptionNodeData* ptr() const { return &inner_; }
    AzOptionNodeData* ptr() { return &inner_; }
    AzOptionNodeData release() { AzOptionNodeData result = inner_; inner_ = {}; return result; }
    operator AzOptionNodeData() && noexcept { AzOptionNodeData result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionNodeData_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionNodeData_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzNodeData& unwrap() const { return inner_.Some.payload; }
    AzNodeData& unwrap() { return inner_.Some.payload; }
    AzNodeData unwrapOr(const AzNodeData& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzNodeData> toStdOptional() const { return isSome() ? std::optional<AzNodeData>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzNodeData>() const { return toStdOptional(); }
};

class OptionCssMockEnvironment {
private:
    AzOptionCssMockEnvironment inner_;

    OptionCssMockEnvironment(const OptionCssMockEnvironment&) = delete;
    OptionCssMockEnvironment& operator=(const OptionCssMockEnvironment&) = delete;

public:
    explicit OptionCssMockEnvironment(AzOptionCssMockEnvironment inner) noexcept : inner_(inner) {}

    OptionCssMockEnvironment(OptionCssMockEnvironment&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionCssMockEnvironment& operator=(OptionCssMockEnvironment&& other) noexcept {
        if (this != &other) {
            AzOptionCssMockEnvironment_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionCssMockEnvironment() { AzOptionCssMockEnvironment_delete(&inner_); }

    static OptionCssMockEnvironment none();
    static OptionCssMockEnvironment some(CssMockEnvironment payload);
    void delete_();
    OptionCssMockEnvironment clone() const;
    String toDbgString() const;

    const AzOptionCssMockEnvironment& inner() const { return inner_; }
    AzOptionCssMockEnvironment& inner() { return inner_; }
    const AzOptionCssMockEnvironment* ptr() const { return &inner_; }
    AzOptionCssMockEnvironment* ptr() { return &inner_; }
    AzOptionCssMockEnvironment release() { AzOptionCssMockEnvironment result = inner_; inner_ = {}; return result; }
    operator AzOptionCssMockEnvironment() && noexcept { AzOptionCssMockEnvironment result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCssMockEnvironment_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCssMockEnvironment_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCssMockEnvironment& unwrap() const { return inner_.Some.payload; }
    AzCssMockEnvironment& unwrap() { return inner_.Some.payload; }
    AzCssMockEnvironment unwrapOr(const AzCssMockEnvironment& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCssMockEnvironment> toStdOptional() const { return isSome() ? std::optional<AzCssMockEnvironment>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCssMockEnvironment>() const { return toStdOptional(); }
};

class OptionComponentCallbackArg {
private:
    AzOptionComponentCallbackArg inner_;

    OptionComponentCallbackArg(const OptionComponentCallbackArg&) = delete;
    OptionComponentCallbackArg& operator=(const OptionComponentCallbackArg&) = delete;

public:
    explicit OptionComponentCallbackArg(AzOptionComponentCallbackArg inner) noexcept : inner_(inner) {}

    OptionComponentCallbackArg(OptionComponentCallbackArg&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionComponentCallbackArg& operator=(OptionComponentCallbackArg&& other) noexcept {
        if (this != &other) {
            AzOptionComponentCallbackArg_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionComponentCallbackArg() { AzOptionComponentCallbackArg_delete(&inner_); }

    static OptionComponentCallbackArg none();
    static OptionComponentCallbackArg some(ComponentCallbackArg payload);
    void delete_();
    OptionComponentCallbackArg clone() const;
    bool partialEq(const OptionComponentCallbackArg& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionComponentCallbackArg& b) const;
    uint8_t cmp(const OptionComponentCallbackArg& b) const;
    String toDbgString() const;

    const AzOptionComponentCallbackArg& inner() const { return inner_; }
    AzOptionComponentCallbackArg& inner() { return inner_; }
    const AzOptionComponentCallbackArg* ptr() const { return &inner_; }
    AzOptionComponentCallbackArg* ptr() { return &inner_; }
    AzOptionComponentCallbackArg release() { AzOptionComponentCallbackArg result = inner_; inner_ = {}; return result; }
    operator AzOptionComponentCallbackArg() && noexcept { AzOptionComponentCallbackArg result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionComponentCallbackArg_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionComponentCallbackArg_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzComponentCallbackArg& unwrap() const { return inner_.Some.payload; }
    AzComponentCallbackArg& unwrap() { return inner_.Some.payload; }
    AzComponentCallbackArg unwrapOr(const AzComponentCallbackArg& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzComponentCallbackArg> toStdOptional() const { return isSome() ? std::optional<AzComponentCallbackArg>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzComponentCallbackArg>() const { return toStdOptional(); }
};

class OptionDom {
private:
    AzOptionDom inner_;

    OptionDom(const OptionDom&) = delete;
    OptionDom& operator=(const OptionDom&) = delete;

public:
    explicit OptionDom(AzOptionDom inner) noexcept : inner_(inner) {}

    OptionDom(OptionDom&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionDom& operator=(OptionDom&& other) noexcept {
        if (this != &other) {
            AzOptionDom_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionDom() { AzOptionDom_delete(&inner_); }

    static OptionDom none();
    static OptionDom some(Dom payload);
    void delete_();
    OptionDom clone() const;
    bool partialEq(const OptionDom& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionDom& b) const;
    uint8_t cmp(const OptionDom& b) const;
    String toDbgString() const;

    const AzOptionDom& inner() const { return inner_; }
    AzOptionDom& inner() { return inner_; }
    const AzOptionDom* ptr() const { return &inner_; }
    AzOptionDom* ptr() { return &inner_; }
    AzOptionDom release() { AzOptionDom result = inner_; inner_ = {}; return result; }
    operator AzOptionDom() && noexcept { AzOptionDom result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionDom_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionDom_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzDom& unwrap() const { return inner_.Some.payload; }
    AzDom& unwrap() { return inner_.Some.payload; }
    AzDom unwrapOr(const AzDom& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzDom> toStdOptional() const { return isSome() ? std::optional<AzDom>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzDom>() const { return toStdOptional(); }
};

class OptionMenuItem {
private:
    AzOptionMenuItem inner_;

    OptionMenuItem(const OptionMenuItem&) = delete;
    OptionMenuItem& operator=(const OptionMenuItem&) = delete;

public:
    explicit OptionMenuItem(AzOptionMenuItem inner) noexcept : inner_(inner) {}

    OptionMenuItem(OptionMenuItem&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionMenuItem& operator=(OptionMenuItem&& other) noexcept {
        if (this != &other) {
            AzOptionMenuItem_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionMenuItem() { AzOptionMenuItem_delete(&inner_); }

    static OptionMenuItem none();
    static OptionMenuItem some(AzMenuItem payload);
    void delete_();
    OptionMenuItem clone() const;
    bool partialEq(const OptionMenuItem& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionMenuItem& b) const;
    uint8_t cmp(const OptionMenuItem& b) const;
    String toDbgString() const;

    const AzOptionMenuItem& inner() const { return inner_; }
    AzOptionMenuItem& inner() { return inner_; }
    const AzOptionMenuItem* ptr() const { return &inner_; }
    AzOptionMenuItem* ptr() { return &inner_; }
    AzOptionMenuItem release() { AzOptionMenuItem result = inner_; inner_ = {}; return result; }
    operator AzOptionMenuItem() && noexcept { AzOptionMenuItem result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionMenuItem_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionMenuItem_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzMenuItem& unwrap() const { return inner_.Some.payload; }
    AzMenuItem& unwrap() { return inner_.Some.payload; }
    AzMenuItem unwrapOr(const AzMenuItem& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzMenuItem> toStdOptional() const { return isSome() ? std::optional<AzMenuItem>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzMenuItem>() const { return toStdOptional(); }
};

class OptionComponentDataField {
private:
    AzOptionComponentDataField inner_;

    OptionComponentDataField(const OptionComponentDataField&) = delete;
    OptionComponentDataField& operator=(const OptionComponentDataField&) = delete;

public:
    explicit OptionComponentDataField(AzOptionComponentDataField inner) noexcept : inner_(inner) {}

    OptionComponentDataField(OptionComponentDataField&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionComponentDataField& operator=(OptionComponentDataField&& other) noexcept {
        if (this != &other) {
            AzOptionComponentDataField_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionComponentDataField() { AzOptionComponentDataField_delete(&inner_); }

    static OptionComponentDataField none();
    static OptionComponentDataField some(ComponentDataField payload);
    void delete_();
    OptionComponentDataField clone() const;
    bool partialEq(const OptionComponentDataField& b) const;
    String toDbgString() const;

    const AzOptionComponentDataField& inner() const { return inner_; }
    AzOptionComponentDataField& inner() { return inner_; }
    const AzOptionComponentDataField* ptr() const { return &inner_; }
    AzOptionComponentDataField* ptr() { return &inner_; }
    AzOptionComponentDataField release() { AzOptionComponentDataField result = inner_; inner_ = {}; return result; }
    operator AzOptionComponentDataField() && noexcept { AzOptionComponentDataField result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionComponentDataField_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionComponentDataField_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzComponentDataField& unwrap() const { return inner_.Some.payload; }
    AzComponentDataField& unwrap() { return inner_.Some.payload; }
    AzComponentDataField unwrapOr(const AzComponentDataField& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzComponentDataField> toStdOptional() const { return isSome() ? std::optional<AzComponentDataField>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzComponentDataField>() const { return toStdOptional(); }
};

class OptionCssProperty {
private:
    AzOptionCssProperty inner_;

    OptionCssProperty(const OptionCssProperty&) = delete;
    OptionCssProperty& operator=(const OptionCssProperty&) = delete;

public:
    explicit OptionCssProperty(AzOptionCssProperty inner) noexcept : inner_(inner) {}

    OptionCssProperty(OptionCssProperty&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionCssProperty& operator=(OptionCssProperty&& other) noexcept {
        if (this != &other) {
            AzOptionCssProperty_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionCssProperty() { AzOptionCssProperty_delete(&inner_); }

    static OptionCssProperty none();
    static OptionCssProperty some(AzCssProperty payload);
    void delete_();
    OptionCssProperty clone() const;
    bool partialEq(const OptionCssProperty& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionCssProperty& b) const;
    uint8_t cmp(const OptionCssProperty& b) const;
    String toDbgString() const;

    const AzOptionCssProperty& inner() const { return inner_; }
    AzOptionCssProperty& inner() { return inner_; }
    const AzOptionCssProperty* ptr() const { return &inner_; }
    AzOptionCssProperty* ptr() { return &inner_; }
    AzOptionCssProperty release() { AzOptionCssProperty result = inner_; inner_ = {}; return result; }
    operator AzOptionCssProperty() && noexcept { AzOptionCssProperty result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCssProperty_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCssProperty_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCssProperty& unwrap() const { return inner_.Some.payload; }
    AzCssProperty& unwrap() { return inner_.Some.payload; }
    AzCssProperty unwrapOr(const AzCssProperty& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCssProperty> toStdOptional() const { return isSome() ? std::optional<AzCssProperty>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCssProperty>() const { return toStdOptional(); }
};

class OptionUndoableOperation {
private:
    AzOptionUndoableOperation inner_;

    OptionUndoableOperation(const OptionUndoableOperation&) = delete;
    OptionUndoableOperation& operator=(const OptionUndoableOperation&) = delete;

public:
    explicit OptionUndoableOperation(AzOptionUndoableOperation inner) noexcept : inner_(inner) {}

    OptionUndoableOperation(OptionUndoableOperation&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionUndoableOperation& operator=(OptionUndoableOperation&& other) noexcept {
        if (this != &other) {
            AzOptionUndoableOperation_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionUndoableOperation() { AzOptionUndoableOperation_delete(&inner_); }

    static OptionUndoableOperation none();
    static OptionUndoableOperation some(UndoableOperation payload);
    void delete_();
    OptionUndoableOperation clone() const;
    String toDbgString() const;

    const AzOptionUndoableOperation& inner() const { return inner_; }
    AzOptionUndoableOperation& inner() { return inner_; }
    const AzOptionUndoableOperation* ptr() const { return &inner_; }
    AzOptionUndoableOperation* ptr() { return &inner_; }
    AzOptionUndoableOperation release() { AzOptionUndoableOperation result = inner_; inner_ = {}; return result; }
    operator AzOptionUndoableOperation() && noexcept { AzOptionUndoableOperation result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionUndoableOperation_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionUndoableOperation_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzUndoableOperation& unwrap() const { return inner_.Some.payload; }
    AzUndoableOperation& unwrap() { return inner_.Some.payload; }
    AzUndoableOperation unwrapOr(const AzUndoableOperation& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzUndoableOperation> toStdOptional() const { return isSome() ? std::optional<AzUndoableOperation>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzUndoableOperation>() const { return toStdOptional(); }
};

class OptionRibbonSection {
private:
    AzOptionRibbonSection inner_;

    OptionRibbonSection(const OptionRibbonSection&) = delete;
    OptionRibbonSection& operator=(const OptionRibbonSection&) = delete;

public:
    explicit OptionRibbonSection(AzOptionRibbonSection inner) noexcept : inner_(inner) {}

    OptionRibbonSection(OptionRibbonSection&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionRibbonSection& operator=(OptionRibbonSection&& other) noexcept {
        if (this != &other) {
            AzOptionRibbonSection_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionRibbonSection() { AzOptionRibbonSection_delete(&inner_); }

    static OptionRibbonSection none();
    static OptionRibbonSection some(RibbonSection payload);
    void delete_();
    OptionRibbonSection clone() const;
    String toDbgString() const;

    const AzOptionRibbonSection& inner() const { return inner_; }
    AzOptionRibbonSection& inner() { return inner_; }
    const AzOptionRibbonSection* ptr() const { return &inner_; }
    AzOptionRibbonSection* ptr() { return &inner_; }
    AzOptionRibbonSection release() { AzOptionRibbonSection result = inner_; inner_ = {}; return result; }
    operator AzOptionRibbonSection() && noexcept { AzOptionRibbonSection result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionRibbonSection_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionRibbonSection_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzRibbonSection& unwrap() const { return inner_.Some.payload; }
    AzRibbonSection& unwrap() { return inner_.Some.payload; }
    AzRibbonSection unwrapOr(const AzRibbonSection& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzRibbonSection> toStdOptional() const { return isSome() ? std::optional<AzRibbonSection>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzRibbonSection>() const { return toStdOptional(); }
};

class OptionCssPropertyWithConditions {
private:
    AzOptionCssPropertyWithConditions inner_;

    OptionCssPropertyWithConditions(const OptionCssPropertyWithConditions&) = delete;
    OptionCssPropertyWithConditions& operator=(const OptionCssPropertyWithConditions&) = delete;

public:
    explicit OptionCssPropertyWithConditions(AzOptionCssPropertyWithConditions inner) noexcept : inner_(inner) {}

    OptionCssPropertyWithConditions(OptionCssPropertyWithConditions&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionCssPropertyWithConditions& operator=(OptionCssPropertyWithConditions&& other) noexcept {
        if (this != &other) {
            AzOptionCssPropertyWithConditions_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionCssPropertyWithConditions() { AzOptionCssPropertyWithConditions_delete(&inner_); }

    static OptionCssPropertyWithConditions none();
    static OptionCssPropertyWithConditions some(CssPropertyWithConditions payload);
    void delete_();
    OptionCssPropertyWithConditions clone() const;
    bool partialEq(const OptionCssPropertyWithConditions& b) const;
    uint8_t partialCmp(const OptionCssPropertyWithConditions& b) const;
    String toDbgString() const;

    const AzOptionCssPropertyWithConditions& inner() const { return inner_; }
    AzOptionCssPropertyWithConditions& inner() { return inner_; }
    const AzOptionCssPropertyWithConditions* ptr() const { return &inner_; }
    AzOptionCssPropertyWithConditions* ptr() { return &inner_; }
    AzOptionCssPropertyWithConditions release() { AzOptionCssPropertyWithConditions result = inner_; inner_ = {}; return result; }
    operator AzOptionCssPropertyWithConditions() && noexcept { AzOptionCssPropertyWithConditions result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCssPropertyWithConditions_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCssPropertyWithConditions_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCssPropertyWithConditions& unwrap() const { return inner_.Some.payload; }
    AzCssPropertyWithConditions& unwrap() { return inner_.Some.payload; }
    AzCssPropertyWithConditions unwrapOr(const AzCssPropertyWithConditions& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCssPropertyWithConditions> toStdOptional() const { return isSome() ? std::optional<AzCssPropertyWithConditions>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCssPropertyWithConditions>() const { return toStdOptional(); }
};

class ResultSvgSvgParseError {
private:
    AzResultSvgSvgParseError inner_;

    ResultSvgSvgParseError(const ResultSvgSvgParseError&) = delete;
    ResultSvgSvgParseError& operator=(const ResultSvgSvgParseError&) = delete;

public:
    explicit ResultSvgSvgParseError(AzResultSvgSvgParseError inner) noexcept : inner_(inner) {}

    ResultSvgSvgParseError(ResultSvgSvgParseError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultSvgSvgParseError& operator=(ResultSvgSvgParseError&& other) noexcept {
        if (this != &other) {
            AzResultSvgSvgParseError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultSvgSvgParseError() { AzResultSvgSvgParseError_delete(&inner_); }

    static ResultSvgSvgParseError ok(Svg payload);
    static ResultSvgSvgParseError err(AzSvgParseError payload);
    void delete_();
    ResultSvgSvgParseError clone() const;
    String toDbgString() const;

    const AzResultSvgSvgParseError& inner() const { return inner_; }
    AzResultSvgSvgParseError& inner() { return inner_; }
    const AzResultSvgSvgParseError* ptr() const { return &inner_; }
    AzResultSvgSvgParseError* ptr() { return &inner_; }
    AzResultSvgSvgParseError release() { AzResultSvgSvgParseError result = inner_; inner_ = {}; return result; }
    operator AzResultSvgSvgParseError() && noexcept { AzResultSvgSvgParseError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultSvgSvgParseError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultSvgSvgParseError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultParsedSvgSvgParseError {
private:
    AzResultParsedSvgSvgParseError inner_;

    ResultParsedSvgSvgParseError(const ResultParsedSvgSvgParseError&) = delete;
    ResultParsedSvgSvgParseError& operator=(const ResultParsedSvgSvgParseError&) = delete;

public:
    explicit ResultParsedSvgSvgParseError(AzResultParsedSvgSvgParseError inner) noexcept : inner_(inner) {}

    ResultParsedSvgSvgParseError(ResultParsedSvgSvgParseError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultParsedSvgSvgParseError& operator=(ResultParsedSvgSvgParseError&& other) noexcept {
        if (this != &other) {
            AzResultParsedSvgSvgParseError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultParsedSvgSvgParseError() { AzResultParsedSvgSvgParseError_delete(&inner_); }

    static ResultParsedSvgSvgParseError ok(ParsedSvg payload);
    static ResultParsedSvgSvgParseError err(AzSvgParseError payload);
    void delete_();
    ResultParsedSvgSvgParseError clone() const;
    String toDbgString() const;

    const AzResultParsedSvgSvgParseError& inner() const { return inner_; }
    AzResultParsedSvgSvgParseError& inner() { return inner_; }
    const AzResultParsedSvgSvgParseError* ptr() const { return &inner_; }
    AzResultParsedSvgSvgParseError* ptr() { return &inner_; }
    AzResultParsedSvgSvgParseError release() { AzResultParsedSvgSvgParseError result = inner_; inner_ = {}; return result; }
    operator AzResultParsedSvgSvgParseError() && noexcept { AzResultParsedSvgSvgParseError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultParsedSvgSvgParseError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultParsedSvgSvgParseError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class OptionCssDeclaration {
private:
    AzOptionCssDeclaration inner_;

    OptionCssDeclaration(const OptionCssDeclaration&) = delete;
    OptionCssDeclaration& operator=(const OptionCssDeclaration&) = delete;

public:
    explicit OptionCssDeclaration(AzOptionCssDeclaration inner) noexcept : inner_(inner) {}

    OptionCssDeclaration(OptionCssDeclaration&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    OptionCssDeclaration& operator=(OptionCssDeclaration&& other) noexcept {
        if (this != &other) {
            AzOptionCssDeclaration_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~OptionCssDeclaration() { AzOptionCssDeclaration_delete(&inner_); }

    static OptionCssDeclaration none();
    static OptionCssDeclaration some(AzCssDeclaration payload);
    void delete_();
    OptionCssDeclaration clone() const;
    bool partialEq(const OptionCssDeclaration& b) const;
    uint64_t hash() const;
    uint8_t partialCmp(const OptionCssDeclaration& b) const;
    uint8_t cmp(const OptionCssDeclaration& b) const;
    String toDbgString() const;

    const AzOptionCssDeclaration& inner() const { return inner_; }
    AzOptionCssDeclaration& inner() { return inner_; }
    const AzOptionCssDeclaration* ptr() const { return &inner_; }
    AzOptionCssDeclaration* ptr() { return &inner_; }
    AzOptionCssDeclaration release() { AzOptionCssDeclaration result = inner_; inner_ = {}; return result; }
    operator AzOptionCssDeclaration() && noexcept { AzOptionCssDeclaration result = inner_; inner_ = {}; return result; }

    // Option methods
    bool isSome() const { return inner_.Some.tag == AzOptionCssDeclaration_Tag_Some; }
    bool isNone() const { return inner_.Some.tag == AzOptionCssDeclaration_Tag_None; }
    explicit operator bool() const { return isSome(); }
    const AzCssDeclaration& unwrap() const { return inner_.Some.payload; }
    AzCssDeclaration& unwrap() { return inner_.Some.payload; }
    AzCssDeclaration unwrapOr(const AzCssDeclaration& def) const { return isSome() ? inner_.Some.payload : def; }
    std::optional<AzCssDeclaration> toStdOptional() const { return isSome() ? std::optional<AzCssDeclaration>(inner_.Some.payload) : std::nullopt; }
    operator std::optional<AzCssDeclaration>() const { return toStdOptional(); }
};

class ResultStyledDomRenderDomError {
private:
    AzResultStyledDomRenderDomError inner_;

    ResultStyledDomRenderDomError(const ResultStyledDomRenderDomError&) = delete;
    ResultStyledDomRenderDomError& operator=(const ResultStyledDomRenderDomError&) = delete;

public:
    explicit ResultStyledDomRenderDomError(AzResultStyledDomRenderDomError inner) noexcept : inner_(inner) {}

    ResultStyledDomRenderDomError(ResultStyledDomRenderDomError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultStyledDomRenderDomError& operator=(ResultStyledDomRenderDomError&& other) noexcept {
        if (this != &other) {
            AzResultStyledDomRenderDomError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultStyledDomRenderDomError() { AzResultStyledDomRenderDomError_delete(&inner_); }

    static ResultStyledDomRenderDomError ok(StyledDom payload);
    static ResultStyledDomRenderDomError err(AzRenderDomError payload);
    void delete_();
    ResultStyledDomRenderDomError clone() const;
    String toDbgString() const;

    const AzResultStyledDomRenderDomError& inner() const { return inner_; }
    AzResultStyledDomRenderDomError& inner() { return inner_; }
    const AzResultStyledDomRenderDomError* ptr() const { return &inner_; }
    AzResultStyledDomRenderDomError* ptr() { return &inner_; }
    AzResultStyledDomRenderDomError release() { AzResultStyledDomRenderDomError result = inner_; inner_ = {}; return result; }
    operator AzResultStyledDomRenderDomError() && noexcept { AzResultStyledDomRenderDomError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultStyledDomRenderDomError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultStyledDomRenderDomError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

class ResultStringCompileError {
private:
    AzResultStringCompileError inner_;

    ResultStringCompileError(const ResultStringCompileError&) = delete;
    ResultStringCompileError& operator=(const ResultStringCompileError&) = delete;

public:
    explicit ResultStringCompileError(AzResultStringCompileError inner) noexcept : inner_(inner) {}

    ResultStringCompileError(ResultStringCompileError&& other) noexcept : inner_(other.inner_) {
        other.inner_ = {};
    }
    ResultStringCompileError& operator=(ResultStringCompileError&& other) noexcept {
        if (this != &other) {
            AzResultStringCompileError_delete(&inner_);
            inner_ = other.inner_;
            other.inner_ = {};
        }
        return *this;
    }
    ~ResultStringCompileError() { AzResultStringCompileError_delete(&inner_); }

    static ResultStringCompileError ok(String payload);
    static ResultStringCompileError err(AzCompileError payload);
    void delete_();
    ResultStringCompileError clone() const;
    String toDbgString() const;

    const AzResultStringCompileError& inner() const { return inner_; }
    AzResultStringCompileError& inner() { return inner_; }
    const AzResultStringCompileError* ptr() const { return &inner_; }
    AzResultStringCompileError* ptr() { return &inner_; }
    AzResultStringCompileError release() { AzResultStringCompileError result = inner_; inner_ = {}; return result; }
    operator AzResultStringCompileError() && noexcept { AzResultStringCompileError result = inner_; inner_ = {}; return result; }

    // Result methods
    bool isOk() const { return inner_.Ok.tag == AzResultStringCompileError_Tag_Ok; }
    bool isErr() const { return inner_.Ok.tag == AzResultStringCompileError_Tag_Err; }
    explicit operator bool() const { return isOk(); }
};

using StyleCursor = AzStyleCursor;

using WindowEventFilter = AzWindowEventFilter;

using WindowTheme = AzWindowTheme;

using MouseCursorType = AzMouseCursorType;

using WindowFrame = AzWindowFrame;

using UserAttentionType = AzUserAttentionType;

using HwAcceleration = AzHwAcceleration;

using Vsync = AzVsync;

using XWindowType = AzXWindowType;

using WindowType = AzWindowType;

using CursorAffinity = AzCursorAffinity;

using CursorMovement = AzCursorMovement;

using Theme = AzTheme;

using FullScreenMode = AzFullScreenMode;

using MsgBoxIcon = AzMsgBoxIcon;

using Update = AzUpdate;

using EdgeType = AzEdgeType;

using AccessibilityRole = AzAccessibilityRole;

using AccessibilityState = AzAccessibilityState;

// TabIndex is a tagged union - use C API
using TabIndex = AzTabIndex;

using NodeTypeTag = AzNodeTypeTag;

using VertexAttributeType = AzVertexAttributeType;

using VirtualKeyCode = AzVirtualKeyCode;

using SelectionDirection = AzSelectionDirection;

using DragType = AzDragType;

using FocusBehavior = AzFocusBehavior;

using DropEffect = AzDropEffect;

using DragEffect = AzDragEffect;

using ScrollIntoViewBehavior = AzScrollIntoViewBehavior;

using AttributeMatchOp = AzAttributeMatchOp;

using ContextMenuMouseButton = AzContextMenuMouseButton;

using MenuPopupPosition = AzMenuPopupPosition;

using MenuItemState = AzMenuItemState;

using SizeMetric = AzSizeMetric;

using BoxShadowClipMode = AzBoxShadowClipMode;

using StyleMixBlendMode = AzStyleMixBlendMode;

using LayoutAlignContent = AzLayoutAlignContent;

using LayoutAlignItems = AzLayoutAlignItems;

using LayoutBoxSizing = AzLayoutBoxSizing;

using LayoutFlexDirection = AzLayoutFlexDirection;

using LayoutAxis = AzLayoutAxis;

using LayoutDisplay = AzLayoutDisplay;

using LayoutFloat = AzLayoutFloat;

using LayoutJustifyContent = AzLayoutJustifyContent;

using LayoutPosition = AzLayoutPosition;

using LayoutFlexWrap = AzLayoutFlexWrap;

using LayoutOverflow = AzLayoutOverflow;

using AngleMetric = AzAngleMetric;

using DirectionCorner = AzDirectionCorner;

using Shape = AzShape;

using RadialGradientSize = AzRadialGradientSize;

using StyleBackgroundRepeat = AzStyleBackgroundRepeat;

using BorderStyle = AzBorderStyle;

using StyleBackfaceVisibility = AzStyleBackfaceVisibility;

using StyleTextAlign = AzStyleTextAlign;

// LayoutZIndex is a tagged union - use C API
using LayoutZIndex = AzLayoutZIndex;

using LayoutJustifyItems = AzLayoutJustifyItems;

using ColumnSpan = AzColumnSpan;

using LayoutClear = AzLayoutClear;

using StyleWhiteSpace = AzStyleWhiteSpace;

using BreakInside = AzBreakInside;

using LayoutAlignSelf = AzLayoutAlignSelf;

// ColumnCount is a tagged union - use C API
using ColumnCount = AzColumnCount;

using LayoutWritingMode = AzLayoutWritingMode;

using StyleUserSelect = AzStyleUserSelect;

using LayoutJustifySelf = AzLayoutJustifySelf;

using StyleHyphens = AzStyleHyphens;

using StyleDirection = AzStyleDirection;

using LayoutTextJustify = AzLayoutTextJustify;

using BoxDecorationBreak = AzBoxDecorationBreak;

using StyleVisibility = AzStyleVisibility;

using LayoutGridAutoFlow = AzLayoutGridAutoFlow;

using StyleTextDecoration = AzStyleTextDecoration;

using ColumnFill = AzColumnFill;

using PageBreak = AzPageBreak;

using LayoutScrollbarWidth = AzLayoutScrollbarWidth;

using StyleFontWeight = AzStyleFontWeight;

using StyleListStyleType = AzStyleListStyleType;

using StyleListStylePosition = AzStyleListStylePosition;

using StyleBorderCollapse = AzStyleBorderCollapse;

using StyleCaptionSide = AzStyleCaptionSide;

using LayoutTableLayout = AzLayoutTableLayout;

using StyleEmptyCells = AzStyleEmptyCells;

using StyleFontStyle = AzStyleFontStyle;

// StyleTextCombineUpright is a tagged union - use C API
using StyleTextCombineUpright = AzStyleTextCombineUpright;

using HoverEventFilter = AzHoverEventFilter;

using ShapeRendering = AzShapeRendering;

using ApplicationEventFilter = AzApplicationEventFilter;

using TextRendering = AzTextRendering;

using FocusEventFilter = AzFocusEventFilter;

using FontDatabase = AzFontDatabase;

using WindowBackgroundMaterial = AzWindowBackgroundMaterial;

using WindowDecorations = AzWindowDecorations;

using Srgb = AzSrgb;

using CssPropertyType = AzCssPropertyType;

using ExtendMode = AzExtendMode;

using LinuxDesktopEnv = AzLinuxDesktopEnv;

using ScrollLogicalPosition = AzScrollLogicalPosition;

using SystemColorRef = AzSystemColorRef;

using SystemFontType = AzSystemFontType;

using ScrollbarTrackClick = AzScrollbarTrackClick;

using SubpixelType = AzSubpixelType;

using ScrollbarVisibility = AzScrollbarVisibility;

using ToolbarStyle = AzToolbarStyle;

using CombinedCssPropertyType = AzCombinedCssPropertyType;

using ScrollbarVisibilityMode = AzScrollbarVisibilityMode;

using StyleLineBreak = AzStyleLineBreak;

using StyleTextAlignLast = AzStyleTextAlignLast;

using StyleOverflowWrap = AzStyleOverflowWrap;

using StyleWordBreak = AzStyleWordBreak;

using StyleTextOrientation = AzStyleTextOrientation;

using StyleObjectFit = AzStyleObjectFit;

using StyleInitialLetterWrap = AzStyleInitialLetterWrap;

using VisualBox = AzVisualBox;

using StyleInitialLetterAlign = AzStyleInitialLetterAlign;

using StyleTextBoxEdge = AzStyleTextBoxEdge;

using StyleAlignmentBaseline = AzStyleAlignmentBaseline;

using StyleDominantBaseline = AzStyleDominantBaseline;

using StyleTextBoxTrim = AzStyleTextBoxTrim;

using StyleScrollbarGutter = AzStyleScrollbarGutter;

using StyleUnicodeBidi = AzStyleUnicodeBidi;

using MediaType = AzMediaType;

using OrientationType = AzOrientationType;

using SystemMetricRef = AzSystemMetricRef;

using PseudoStateType = AzPseudoStateType;

using OsCondition = AzOsCondition;

using OsFamily = AzOsFamily;

using BoolCondition = AzBoolCondition;

using RelayoutReason = AzRelayoutReason;

using GestureDirection = AzGestureDirection;

using ButtonType = AzButtonType;

using TextInputValid = AzTextInputValid;

using TitlebarButtonSide = AzTitlebarButtonSide;

using GamepadButton = AzGamepadButton;

using GlType = AzGlType;

using IndexBufferFormat = AzIndexBufferFormat;

using RawImageFormat = AzRawImageFormat;

using ImageRendering = AzImageRendering;

// SvgFitTo is a tagged union - use C API
using SvgFitTo = AzSvgFitTo;

using SvgLineJoin = AzSvgLineJoin;

using SvgFillRule = AzSvgFillRule;

using SvgLineCap = AzSvgLineCap;

using EncodeImageError = AzEncodeImageError;

using DecodeImageError = AzDecodeImageError;

using FileErrorKind = AzFileErrorKind;

using ParseFloatError = AzParseFloatError;

using ParseIntError = AzParseIntError;

using BiometricResult = AzBiometricResult;

using AppTerminationBehavior = AzAppTerminationBehavior;

using AppLogLevel = AzAppLogLevel;

using RendererType = AzRendererType;

using TerminateTimer = AzTerminateTimer;

using JsonType = AzJsonType;

using FileType = AzFileType;

using ExternalResourceKind = AzExternalResourceKind;

using YesNo = AzYesNo;

using OkCancel = AzOkCancel;

using BiometricKind = AzBiometricKind;

using SensorKind = AzSensorKind;

using GamepadAxis = AzGamepadAxis;

using CameraFacing = AzCameraFacing;

// ScreenCaptureSource is a tagged union - use C API
using ScreenCaptureSource = AzScreenCaptureSource;

using PluralCategory = AzPluralCategory;

using FormatLength = AzFormatLength;

using ComponentSource = AzComponentSource;

using CompileTarget = AzCompileTarget;

using ComponentEventFilter = AzComponentEventFilter;

using CssColorComponent = AzCssColorComponent;

// RawWindowHandle is a tagged union - use C API
using RawWindowHandle = AzRawWindowHandle;

// TextInputSelection is a tagged union - use C API
using TextInputSelection = AzTextInputSelection;

// VirtualViewCallbackReason is a tagged union - use C API
using VirtualViewCallbackReason = AzVirtualViewCallbackReason;

// MenuItemIcon is a tagged union - use C API
using MenuItemIcon = AzMenuItemIcon;

// CssNthChildSelector is a tagged union - use C API
using CssNthChildSelector = AzCssNthChildSelector;

// EventFilter is a tagged union - use C API
using EventFilter = AzEventFilter;

// WindowPosition is a tagged union - use C API
using WindowPosition = AzWindowPosition;

// CursorPosition is a tagged union - use C API
using CursorPosition = AzCursorPosition;

// ColorOrSystem is a tagged union - use C API
using ColorOrSystem = AzColorOrSystem;

// StyleAspectRatio is a tagged union - use C API
using StyleAspectRatio = AzStyleAspectRatio;

// Duration is a tagged union - use C API
using Duration = AzDuration;

// StyleFilterVecDestructor is a tagged union - use C API
using StyleFilterVecDestructor = AzStyleFilterVecDestructor;

// StyleTransformVecDestructor is a tagged union - use C API
using StyleTransformVecDestructor = AzStyleTransformVecDestructor;

// GLuintVecDestructor is a tagged union - use C API
using GLuintVecDestructor = AzGLuintVecDestructor;

// XmlNodeChildVecDestructor is a tagged union - use C API
using XmlNodeChildVecDestructor = AzXmlNodeChildVecDestructor;

// StyleBackgroundContentVecDestructor is a tagged union - use C API
using StyleBackgroundContentVecDestructor = AzStyleBackgroundContentVecDestructor;

// CascadeInfoVecDestructor is a tagged union - use C API
using CascadeInfoVecDestructor = AzCascadeInfoVecDestructor;

// AccessibilityStateVecDestructor is a tagged union - use C API
using AccessibilityStateVecDestructor = AzAccessibilityStateVecDestructor;

// DomVecDestructor is a tagged union - use C API
using DomVecDestructor = AzDomVecDestructor;

// StringVecDestructor is a tagged union - use C API
using StringVecDestructor = AzStringVecDestructor;

// NodeDataVecDestructor is a tagged union - use C API
using NodeDataVecDestructor = AzNodeDataVecDestructor;

// MenuItemVecDestructor is a tagged union - use C API
using MenuItemVecDestructor = AzMenuItemVecDestructor;

// ListViewRowVecDestructor is a tagged union - use C API
using ListViewRowVecDestructor = AzListViewRowVecDestructor;

// SvgVertexVecDestructor is a tagged union - use C API
using SvgVertexVecDestructor = AzSvgVertexVecDestructor;

// CssVecDestructor is a tagged union - use C API
using CssVecDestructor = AzCssVecDestructor;

// U32VecDestructor is a tagged union - use C API
using U32VecDestructor = AzU32VecDestructor;

// CssRuleBlockVecDestructor is a tagged union - use C API
using CssRuleBlockVecDestructor = AzCssRuleBlockVecDestructor;

// NormalizedLinearColorStopVecDestructor is a tagged union - use C API
using NormalizedLinearColorStopVecDestructor = AzNormalizedLinearColorStopVecDestructor;

// StyleFontFamilyVecDestructor is a tagged union - use C API
using StyleFontFamilyVecDestructor = AzStyleFontFamilyVecDestructor;

// CssPathSelectorVecDestructor is a tagged union - use C API
using CssPathSelectorVecDestructor = AzCssPathSelectorVecDestructor;

// NodeHierarchyItemVecDestructor is a tagged union - use C API
using NodeHierarchyItemVecDestructor = AzNodeHierarchyItemVecDestructor;

// VirtualKeyCodeVecDestructor is a tagged union - use C API
using VirtualKeyCodeVecDestructor = AzVirtualKeyCodeVecDestructor;

// F32VecDestructor is a tagged union - use C API
using F32VecDestructor = AzF32VecDestructor;

// StyleBackgroundRepeatVecDestructor is a tagged union - use C API
using StyleBackgroundRepeatVecDestructor = AzStyleBackgroundRepeatVecDestructor;

// AccessibilityActionVecDestructor is a tagged union - use C API
using AccessibilityActionVecDestructor = AzAccessibilityActionVecDestructor;

// U16VecDestructor is a tagged union - use C API
using U16VecDestructor = AzU16VecDestructor;

// TagIdToNodeIdMappingVecDestructor is a tagged union - use C API
using TagIdToNodeIdMappingVecDestructor = AzTagIdToNodeIdMappingVecDestructor;

// ParentWithNodeDepthVecDestructor is a tagged union - use C API
using ParentWithNodeDepthVecDestructor = AzParentWithNodeDepthVecDestructor;

// GLintVecDestructor is a tagged union - use C API
using GLintVecDestructor = AzGLintVecDestructor;

// CssPropertyWithConditionsVecDestructor is a tagged union - use C API
using CssPropertyWithConditionsVecDestructor = AzCssPropertyWithConditionsVecDestructor;

// DynamicSelectorVecDestructor is a tagged union - use C API
using DynamicSelectorVecDestructor = AzDynamicSelectorVecDestructor;

// NormalizedRadialColorStopVecDestructor is a tagged union - use C API
using NormalizedRadialColorStopVecDestructor = AzNormalizedRadialColorStopVecDestructor;

// StyleBackgroundPositionVecDestructor is a tagged union - use C API
using StyleBackgroundPositionVecDestructor = AzStyleBackgroundPositionVecDestructor;

// AttributeTypeVecDestructor is a tagged union - use C API
using AttributeTypeVecDestructor = AzAttributeTypeVecDestructor;

// CssDeclarationVecDestructor is a tagged union - use C API
using CssDeclarationVecDestructor = AzCssDeclarationVecDestructor;

// IdOrClassVecDestructor is a tagged union - use C API
using IdOrClassVecDestructor = AzIdOrClassVecDestructor;

// StyleBackgroundSizeVecDestructor is a tagged union - use C API
using StyleBackgroundSizeVecDestructor = AzStyleBackgroundSizeVecDestructor;

// StringPairVecDestructor is a tagged union - use C API
using StringPairVecDestructor = AzStringPairVecDestructor;

// MimeTypeDataVecDestructor is a tagged union - use C API
using MimeTypeDataVecDestructor = AzMimeTypeDataVecDestructor;

// CoreCallbackDataVecDestructor is a tagged union - use C API
using CoreCallbackDataVecDestructor = AzCoreCallbackDataVecDestructor;

// U8VecDestructor is a tagged union - use C API
using U8VecDestructor = AzU8VecDestructor;

// GridTrackSizingVecDestructor is a tagged union - use C API
using GridTrackSizingVecDestructor = AzGridTrackSizingVecDestructor;

// VertexAttributeVecDestructor is a tagged union - use C API
using VertexAttributeVecDestructor = AzVertexAttributeVecDestructor;

// DebugMessageVecDestructor is a tagged union - use C API
using DebugMessageVecDestructor = AzDebugMessageVecDestructor;

// ShapePointVecDestructor is a tagged union - use C API
using ShapePointVecDestructor = AzShapePointVecDestructor;

// XWindowTypeVecDestructor is a tagged union - use C API
using XWindowTypeVecDestructor = AzXWindowTypeVecDestructor;

// MonitorVecDestructor is a tagged union - use C API
using MonitorVecDestructor = AzMonitorVecDestructor;

// VideoModeVecDestructor is a tagged union - use C API
using VideoModeVecDestructor = AzVideoModeVecDestructor;

// ScanCodeVecDestructor is a tagged union - use C API
using ScanCodeVecDestructor = AzScanCodeVecDestructor;

// StyledNodeVecDestructor is a tagged union - use C API
using StyledNodeVecDestructor = AzStyledNodeVecDestructor;

// ContentGroupVecDestructor is a tagged union - use C API
using ContentGroupVecDestructor = AzContentGroupVecDestructor;

// DomIdVecDestructor is a tagged union - use C API
using DomIdVecDestructor = AzDomIdVecDestructor;

// TimerIdVecDestructor is a tagged union - use C API
using TimerIdVecDestructor = AzTimerIdVecDestructor;

// ThreadIdVecDestructor is a tagged union - use C API
using ThreadIdVecDestructor = AzThreadIdVecDestructor;

// SelectionRangeVecDestructor is a tagged union - use C API
using SelectionRangeVecDestructor = AzSelectionRangeVecDestructor;

// StyledTextRunVecDestructor is a tagged union - use C API
using StyledTextRunVecDestructor = AzStyledTextRunVecDestructor;

// SelectionVecDestructor is a tagged union - use C API
using SelectionVecDestructor = AzSelectionVecDestructor;

// FmtArgVecDestructor is a tagged union - use C API
using FmtArgVecDestructor = AzFmtArgVecDestructor;

// HttpHeaderVecDestructor is a tagged union - use C API
using HttpHeaderVecDestructor = AzHttpHeaderVecDestructor;

// JsonVecDestructor is a tagged union - use C API
using JsonVecDestructor = AzJsonVecDestructor;

// DirEntryVecDestructor is a tagged union - use C API
using DirEntryVecDestructor = AzDirEntryVecDestructor;

// JsonKeyValueVecDestructor is a tagged union - use C API
using JsonKeyValueVecDestructor = AzJsonKeyValueVecDestructor;

// NamedFontVecDestructor is a tagged union - use C API
using NamedFontVecDestructor = AzNamedFontVecDestructor;

// ExternalResourceVecDestructor is a tagged union - use C API
using ExternalResourceVecDestructor = AzExternalResourceVecDestructor;

// NodeHierarchyItemIdVecDestructor is a tagged union - use C API
using NodeHierarchyItemIdVecDestructor = AzNodeHierarchyItemIdVecDestructor;

// CalcAstItemVecDestructor is a tagged union - use C API
using CalcAstItemVecDestructor = AzCalcAstItemVecDestructor;

// GridAreaDefinitionVecDestructor is a tagged union - use C API
using GridAreaDefinitionVecDestructor = AzGridAreaDefinitionVecDestructor;

// ComponentDataFieldVecDestructor is a tagged union - use C API
using ComponentDataFieldVecDestructor = AzComponentDataFieldVecDestructor;

// ComponentDefVecDestructor is a tagged union - use C API
using ComponentDefVecDestructor = AzComponentDefVecDestructor;

// ComponentLibraryVecDestructor is a tagged union - use C API
using ComponentLibraryVecDestructor = AzComponentLibraryVecDestructor;

// ComponentDataModelVecDestructor is a tagged union - use C API
using ComponentDataModelVecDestructor = AzComponentDataModelVecDestructor;

// ComponentEnumVariantVecDestructor is a tagged union - use C API
using ComponentEnumVariantVecDestructor = AzComponentEnumVariantVecDestructor;

// ComponentEnumModelVecDestructor is a tagged union - use C API
using ComponentEnumModelVecDestructor = AzComponentEnumModelVecDestructor;

// ComponentFieldOverrideVecDestructor is a tagged union - use C API
using ComponentFieldOverrideVecDestructor = AzComponentFieldOverrideVecDestructor;

// ComponentCallbackArgVecDestructor is a tagged union - use C API
using ComponentCallbackArgVecDestructor = AzComponentCallbackArgVecDestructor;

// SvgPathElementVecDestructor is a tagged union - use C API
using SvgPathElementVecDestructor = AzSvgPathElementVecDestructor;

// SvgPathVecDestructor is a tagged union - use C API
using SvgPathVecDestructor = AzSvgPathVecDestructor;

// RibbonTabVecDestructor is a tagged union - use C API
using RibbonTabVecDestructor = AzRibbonTabVecDestructor;

// RibbonSectionVecDestructor is a tagged union - use C API
using RibbonSectionVecDestructor = AzRibbonSectionVecDestructor;

// TreeViewNodeVecDestructor is a tagged union - use C API
using TreeViewNodeVecDestructor = AzTreeViewNodeVecDestructor;

// RouteVecDestructor is a tagged union - use C API
using RouteVecDestructor = AzRouteVecDestructor;

// TouchPointVecDestructor is a tagged union - use C API
using TouchPointVecDestructor = AzTouchPointVecDestructor;

// LayoutRectVecDestructor is a tagged union - use C API
using LayoutRectVecDestructor = AzLayoutRectVecDestructor;

// DbValueVecDestructor is a tagged union - use C API
using DbValueVecDestructor = AzDbValueVecDestructor;

// LoadedFontVecDestructor is a tagged union - use C API
using LoadedFontVecDestructor = AzLoadedFontVecDestructor;

// PixelValueOrSystem is a tagged union - use C API
using PixelValueOrSystem = AzPixelValueOrSystem;

// StyleCompositeFilter is a tagged union - use C API
using StyleCompositeFilter = AzStyleCompositeFilter;

// Direction is a tagged union - use C API
using Direction = AzDirection;

// BackgroundPositionHorizontal is a tagged union - use C API
using BackgroundPositionHorizontal = AzBackgroundPositionHorizontal;

// BackgroundPositionVertical is a tagged union - use C API
using BackgroundPositionVertical = AzBackgroundPositionVertical;

// LayoutFlexBasis is a tagged union - use C API
using LayoutFlexBasis = AzLayoutFlexBasis;

// ColumnWidth is a tagged union - use C API
using ColumnWidth = AzColumnWidth;

// StyleScrollbarColor is a tagged union - use C API
using StyleScrollbarColor = AzStyleScrollbarColor;

// StyleVerticalAlign is a tagged union - use C API
using StyleVerticalAlign = AzStyleVerticalAlign;

// GridTrackSizing is a tagged union - use C API
using GridTrackSizing = AzGridTrackSizing;

// ImePosition is a tagged union - use C API
using ImePosition = AzImePosition;

// CalcAstItem is a tagged union - use C API
using CalcAstItem = AzCalcAstItem;

// OsVersionCondition is a tagged union - use C API
using OsVersionCondition = AzOsVersionCondition;

// SvgPathElement is a tagged union - use C API
using SvgPathElement = AzSvgPathElement;

// CssSyntaxError is a tagged union - use C API
using CssSyntaxError = AzCssSyntaxError;

// ThreadSendMsg is a tagged union - use C API
using ThreadSendMsg = AzThreadSendMsg;

// Selection is a tagged union - use C API
using Selection = AzSelection;

// LayoutHeight is a tagged union - use C API
using LayoutHeight = AzLayoutHeight;

// LayoutWidth is a tagged union - use C API
using LayoutWidth = AzLayoutWidth;

// StyleBackgroundSize is a tagged union - use C API
using StyleBackgroundSize = AzStyleBackgroundSize;

// StyleTransform is a tagged union - use C API
using StyleTransform = AzStyleTransform;

// FontLoadingConfig is a tagged union - use C API
using FontLoadingConfig = AzFontLoadingConfig;

// RawImageData is a tagged union - use C API
using RawImageData = AzRawImageData;

// Instant is a tagged union - use C API
using Instant = AzInstant;

// FluentSyntaxCheckResult is a tagged union - use C API
using FluentSyntaxCheckResult = AzFluentSyntaxCheckResult;

// WindowIcon is a tagged union - use C API
using WindowIcon = AzWindowIcon;

// ThemeCondition is a tagged union - use C API
using ThemeCondition = AzThemeCondition;

// AccessibilityAction is a tagged union - use C API
using AccessibilityAction = AzAccessibilityAction;

// IdOrClass is a tagged union - use C API
using IdOrClass = AzIdOrClass;

// StyleFilter is a tagged union - use C API
using StyleFilter = AzStyleFilter;

// StyleFontFamily is a tagged union - use C API
using StyleFontFamily = AzStyleFontFamily;

// FlowFrom is a tagged union - use C API
using FlowFrom = AzFlowFrom;

// FlowInto is a tagged union - use C API
using FlowInto = AzFlowInto;

// DesktopEnvironment is a tagged union - use C API
using DesktopEnvironment = AzDesktopEnvironment;

// CssBorderStyleParseErrorOwned is a tagged union - use C API
using CssBorderStyleParseErrorOwned = AzCssBorderStyleParseErrorOwned;

// StyleExclusionMarginParseErrorOwned is a tagged union - use C API
using StyleExclusionMarginParseErrorOwned = AzStyleExclusionMarginParseErrorOwned;

// StyleInitialLetterParseErrorOwned is a tagged union - use C API
using StyleInitialLetterParseErrorOwned = AzStyleInitialLetterParseErrorOwned;

// JustifyContentParseErrorOwned is a tagged union - use C API
using JustifyContentParseErrorOwned = AzJustifyContentParseErrorOwned;

// AlignItemsParseErrorOwned is a tagged union - use C API
using AlignItemsParseErrorOwned = AzAlignItemsParseErrorOwned;

// AlignContentParseErrorOwned is a tagged union - use C API
using AlignContentParseErrorOwned = AzAlignContentParseErrorOwned;

// LayoutDisplayParseErrorOwned is a tagged union - use C API
using LayoutDisplayParseErrorOwned = AzLayoutDisplayParseErrorOwned;

// AlignSelfParseErrorOwned is a tagged union - use C API
using AlignSelfParseErrorOwned = AzAlignSelfParseErrorOwned;

// TextJustifyParseErrorOwned is a tagged union - use C API
using TextJustifyParseErrorOwned = AzTextJustifyParseErrorOwned;

// JustifySelfParseErrorOwned is a tagged union - use C API
using JustifySelfParseErrorOwned = AzJustifySelfParseErrorOwned;

// LayoutBoxSizingParseErrorOwned is a tagged union - use C API
using LayoutBoxSizingParseErrorOwned = AzLayoutBoxSizingParseErrorOwned;

// LayoutClearParseErrorOwned is a tagged union - use C API
using LayoutClearParseErrorOwned = AzLayoutClearParseErrorOwned;

// ColumnCountParseErrorOwned is a tagged union - use C API
using ColumnCountParseErrorOwned = AzColumnCountParseErrorOwned;

// StyleTextCombineUprightParseErrorOwned is a tagged union - use C API
using StyleTextCombineUprightParseErrorOwned = AzStyleTextCombineUprightParseErrorOwned;

// PercentageParseErrorOwned is a tagged union - use C API
using PercentageParseErrorOwned = AzPercentageParseErrorOwned;

// LayoutPositionParseErrorOwned is a tagged union - use C API
using LayoutPositionParseErrorOwned = AzLayoutPositionParseErrorOwned;

// LayoutFloatParseErrorOwned is a tagged union - use C API
using LayoutFloatParseErrorOwned = AzLayoutFloatParseErrorOwned;

// FlexDirectionParseErrorOwned is a tagged union - use C API
using FlexDirectionParseErrorOwned = AzFlexDirectionParseErrorOwned;

// CssBackfaceVisibilityParseErrorOwned is a tagged union - use C API
using CssBackfaceVisibilityParseErrorOwned = AzCssBackfaceVisibilityParseErrorOwned;

// StyleHyphenationLanguageParseErrorOwned is a tagged union - use C API
using StyleHyphenationLanguageParseErrorOwned = AzStyleHyphenationLanguageParseErrorOwned;

// StyleListStyleTypeParseErrorOwned is a tagged union - use C API
using StyleListStyleTypeParseErrorOwned = AzStyleListStyleTypeParseErrorOwned;

// LayoutWritingModeParseErrorOwned is a tagged union - use C API
using LayoutWritingModeParseErrorOwned = AzLayoutWritingModeParseErrorOwned;

// JustifyItemsParseErrorOwned is a tagged union - use C API
using JustifyItemsParseErrorOwned = AzJustifyItemsParseErrorOwned;

// BoxDecorationBreakParseErrorOwned is a tagged union - use C API
using BoxDecorationBreakParseErrorOwned = AzBoxDecorationBreakParseErrorOwned;

// PageBreakParseErrorOwned is a tagged union - use C API
using PageBreakParseErrorOwned = AzPageBreakParseErrorOwned;

// StyleLineClampParseErrorOwned is a tagged union - use C API
using StyleLineClampParseErrorOwned = AzStyleLineClampParseErrorOwned;

// BreakInsideParseErrorOwned is a tagged union - use C API
using BreakInsideParseErrorOwned = AzBreakInsideParseErrorOwned;

// LayoutScrollbarWidthParseErrorOwned is a tagged union - use C API
using LayoutScrollbarWidthParseErrorOwned = AzLayoutScrollbarWidthParseErrorOwned;

// LayoutOverflowParseErrorOwned is a tagged union - use C API
using LayoutOverflowParseErrorOwned = AzLayoutOverflowParseErrorOwned;

// CssDirectionCornerParseErrorOwned is a tagged union - use C API
using CssDirectionCornerParseErrorOwned = AzCssDirectionCornerParseErrorOwned;

// CssStyleFontFamilyParseErrorOwned is a tagged union - use C API
using CssStyleFontFamilyParseErrorOwned = AzCssStyleFontFamilyParseErrorOwned;

// StyleHangingPunctuationParseErrorOwned is a tagged union - use C API
using StyleHangingPunctuationParseErrorOwned = AzStyleHangingPunctuationParseErrorOwned;

// StyleListStylePositionParseErrorOwned is a tagged union - use C API
using StyleListStylePositionParseErrorOwned = AzStyleListStylePositionParseErrorOwned;

// ColumnFillParseErrorOwned is a tagged union - use C API
using ColumnFillParseErrorOwned = AzColumnFillParseErrorOwned;

// ColumnSpanParseErrorOwned is a tagged union - use C API
using ColumnSpanParseErrorOwned = AzColumnSpanParseErrorOwned;

// ScrollbarVisibilityModeParseErrorOwned is a tagged union - use C API
using ScrollbarVisibilityModeParseErrorOwned = AzScrollbarVisibilityModeParseErrorOwned;

// ScrollbarFadeDurationParseErrorOwned is a tagged union - use C API
using ScrollbarFadeDurationParseErrorOwned = AzScrollbarFadeDurationParseErrorOwned;

// ScrollbarFadeDelayParseErrorOwned is a tagged union - use C API
using ScrollbarFadeDelayParseErrorOwned = AzScrollbarFadeDelayParseErrorOwned;

// StyleTextOrientationParseErrorOwned is a tagged union - use C API
using StyleTextOrientationParseErrorOwned = AzStyleTextOrientationParseErrorOwned;

// StyleObjectFitParseErrorOwned is a tagged union - use C API
using StyleObjectFitParseErrorOwned = AzStyleObjectFitParseErrorOwned;

// StyleAspectRatioParseErrorOwned is a tagged union - use C API
using StyleAspectRatioParseErrorOwned = AzStyleAspectRatioParseErrorOwned;

// StyleObjectPositionParseErrorOwned is a tagged union - use C API
using StyleObjectPositionParseErrorOwned = AzStyleObjectPositionParseErrorOwned;

// StyleScrollbarGutterParseErrorOwned is a tagged union - use C API
using StyleScrollbarGutterParseErrorOwned = AzStyleScrollbarGutterParseErrorOwned;

// StyleOverflowClipMarginParseErrorOwned is a tagged union - use C API
using StyleOverflowClipMarginParseErrorOwned = AzStyleOverflowClipMarginParseErrorOwned;

// LanguageCondition is a tagged union - use C API
using LanguageCondition = AzLanguageCondition;

// StyleClipRectParseErrorOwned is a tagged union - use C API
using StyleClipRectParseErrorOwned = AzStyleClipRectParseErrorOwned;

// CssImageParseErrorOwned is a tagged union - use C API
using CssImageParseErrorOwned = AzCssImageParseErrorOwned;

// CssPathPseudoSelector is a tagged union - use C API
using CssPathPseudoSelector = AzCssPathPseudoSelector;

// GridAutoFlowParseErrorOwned is a tagged union - use C API
using GridAutoFlowParseErrorOwned = AzGridAutoFlowParseErrorOwned;

// ParenthesisParseErrorOwned is a tagged union - use C API
using ParenthesisParseErrorOwned = AzParenthesisParseErrorOwned;

// NodeTypeTagParseErrorOwned is a tagged union - use C API
using NodeTypeTagParseErrorOwned = AzNodeTypeTagParseErrorOwned;

// FlexWrapParseErrorOwned is a tagged union - use C API
using FlexWrapParseErrorOwned = AzFlexWrapParseErrorOwned;

// GridParseErrorOwned is a tagged union - use C API
using GridParseErrorOwned = AzGridParseErrorOwned;

// FlexBasisParseErrorOwned is a tagged union - use C API
using FlexBasisParseErrorOwned = AzFlexBasisParseErrorOwned;

// FlowIntoParseErrorOwned is a tagged union - use C API
using FlowIntoParseErrorOwned = AzFlowIntoParseErrorOwned;

// FlowFromParseErrorOwned is a tagged union - use C API
using FlowFromParseErrorOwned = AzFlowFromParseErrorOwned;

// DurationParseErrorOwned is a tagged union - use C API
using DurationParseErrorOwned = AzDurationParseErrorOwned;

// PercentageParseError is a tagged union - use C API
using PercentageParseError = AzPercentageParseError;

// KeyringResult is a tagged union - use C API
using KeyringResult = AzKeyringResult;

// FmtValue is a tagged union - use C API
using FmtValue = AzFmtValue;

// DbValue is a tagged union - use C API
using DbValue = AzDbValue;

// ComponentFieldValueSource is a tagged union - use C API
using ComponentFieldValueSource = AzComponentFieldValueSource;

// Platform is a tagged union - use C API
using Platform = AzPlatform;

// CursorParseErrorOwned is a tagged union - use C API
using CursorParseErrorOwned = AzCursorParseErrorOwned;

// NodeType is a tagged union - use C API
using NodeType = AzNodeType;

// AttributeType is a tagged union - use C API
using AttributeType = AzAttributeType;

// StyleBackgroundContent is a tagged union - use C API
using StyleBackgroundContent = AzStyleBackgroundContent;

// GridLine is a tagged union - use C API
using GridLine = AzGridLine;

// CssShape is a tagged union - use C API
using CssShape = AzCssShape;

// CssPixelValueParseErrorOwned is a tagged union - use C API
using CssPixelValueParseErrorOwned = AzCssPixelValueParseErrorOwned;

// StyleVisibilityParseErrorOwned is a tagged union - use C API
using StyleVisibilityParseErrorOwned = AzStyleVisibilityParseErrorOwned;

// StyleTextDecorationParseErrorOwned is a tagged union - use C API
using StyleTextDecorationParseErrorOwned = AzStyleTextDecorationParseErrorOwned;

// LayoutZIndexParseErrorOwned is a tagged union - use C API
using LayoutZIndexParseErrorOwned = AzLayoutZIndexParseErrorOwned;

// StyleWhiteSpaceParseErrorOwned is a tagged union - use C API
using StyleWhiteSpaceParseErrorOwned = AzStyleWhiteSpaceParseErrorOwned;

// StyleDirectionParseErrorOwned is a tagged union - use C API
using StyleDirectionParseErrorOwned = AzStyleDirectionParseErrorOwned;

// StyleVerticalAlignParseErrorOwned is a tagged union - use C API
using StyleVerticalAlignParseErrorOwned = AzStyleVerticalAlignParseErrorOwned;

// CssStyleCompositeFilterParseErrorOwned is a tagged union - use C API
using CssStyleCompositeFilterParseErrorOwned = AzCssStyleCompositeFilterParseErrorOwned;

// CssShapeParseErrorOwned is a tagged union - use C API
using CssShapeParseErrorOwned = AzCssShapeParseErrorOwned;

// StyleHyphensParseErrorOwned is a tagged union - use C API
using StyleHyphensParseErrorOwned = AzStyleHyphensParseErrorOwned;

// CssAngleValueParseErrorOwned is a tagged union - use C API
using CssAngleValueParseErrorOwned = AzCssAngleValueParseErrorOwned;

// MixBlendModeParseErrorOwned is a tagged union - use C API
using MixBlendModeParseErrorOwned = AzMixBlendModeParseErrorOwned;

// ColumnRuleStyleParseErrorOwned is a tagged union - use C API
using ColumnRuleStyleParseErrorOwned = AzColumnRuleStyleParseErrorOwned;

// CssFontStyleParseErrorOwned is a tagged union - use C API
using CssFontStyleParseErrorOwned = AzCssFontStyleParseErrorOwned;

// StyleUserSelectParseErrorOwned is a tagged union - use C API
using StyleUserSelectParseErrorOwned = AzStyleUserSelectParseErrorOwned;

// StyleTextAlignParseErrorOwned is a tagged union - use C API
using StyleTextAlignParseErrorOwned = AzStyleTextAlignParseErrorOwned;

// CssStyleColorMatrixParseErrorOwned is a tagged union - use C API
using CssStyleColorMatrixParseErrorOwned = AzCssStyleColorMatrixParseErrorOwned;

// OrphansParseErrorOwned is a tagged union - use C API
using OrphansParseErrorOwned = AzOrphansParseErrorOwned;

// WidowsParseErrorOwned is a tagged union - use C API
using WidowsParseErrorOwned = AzWidowsParseErrorOwned;

// StyleTextAlignLastParseErrorOwned is a tagged union - use C API
using StyleTextAlignLastParseErrorOwned = AzStyleTextAlignLastParseErrorOwned;

// StyleWordBreakParseErrorOwned is a tagged union - use C API
using StyleWordBreakParseErrorOwned = AzStyleWordBreakParseErrorOwned;

// StyleOverflowWrapParseErrorOwned is a tagged union - use C API
using StyleOverflowWrapParseErrorOwned = AzStyleOverflowWrapParseErrorOwned;

// StyleLineBreakParseErrorOwned is a tagged union - use C API
using StyleLineBreakParseErrorOwned = AzStyleLineBreakParseErrorOwned;

// StyleAlignmentBaselineParseErrorOwned is a tagged union - use C API
using StyleAlignmentBaselineParseErrorOwned = AzStyleAlignmentBaselineParseErrorOwned;

// StyleUnicodeBidiParseErrorOwned is a tagged union - use C API
using StyleUnicodeBidiParseErrorOwned = AzStyleUnicodeBidiParseErrorOwned;

// StyleTextBoxEdgeParseErrorOwned is a tagged union - use C API
using StyleTextBoxEdgeParseErrorOwned = AzStyleTextBoxEdgeParseErrorOwned;

// StyleTextBoxTrimParseErrorOwned is a tagged union - use C API
using StyleTextBoxTrimParseErrorOwned = AzStyleTextBoxTrimParseErrorOwned;

// StyleDominantBaselineParseErrorOwned is a tagged union - use C API
using StyleDominantBaselineParseErrorOwned = AzStyleDominantBaselineParseErrorOwned;

// StyleInitialLetterWrapParseErrorOwned is a tagged union - use C API
using StyleInitialLetterWrapParseErrorOwned = AzStyleInitialLetterWrapParseErrorOwned;

// StyleInitialLetterAlignParseErrorOwned is a tagged union - use C API
using StyleInitialLetterAlignParseErrorOwned = AzStyleInitialLetterAlignParseErrorOwned;

// DynamicSelector is a tagged union - use C API
using DynamicSelector = AzDynamicSelector;

// CssFontWeightParseErrorOwned is a tagged union - use C API
using CssFontWeightParseErrorOwned = AzCssFontWeightParseErrorOwned;

// FlexGrowParseErrorOwned is a tagged union - use C API
using FlexGrowParseErrorOwned = AzFlexGrowParseErrorOwned;

// FlexShrinkParseErrorOwned is a tagged union - use C API
using FlexShrinkParseErrorOwned = AzFlexShrinkParseErrorOwned;

// XmlStreamError is a tagged union - use C API
using XmlStreamError = AzXmlStreamError;

// IcuResult is a tagged union - use C API
using IcuResult = AzIcuResult;

// HttpError is a tagged union - use C API
using HttpError = AzHttpError;

// ComponentError is a tagged union - use C API
using ComponentError = AzComponentError;

// StyleLineHeightParseError is a tagged union - use C API
using StyleLineHeightParseError = AzStyleLineHeightParseError;

// ThreadReceiveMsg is a tagged union - use C API
using ThreadReceiveMsg = AzThreadReceiveMsg;

// ComponentFieldType is a tagged union - use C API
using ComponentFieldType = AzComponentFieldType;

// ComponentDefaultValue is a tagged union - use C API
using ComponentDefaultValue = AzComponentDefaultValue;

// XmlNodeChild is a tagged union - use C API
using XmlNodeChild = AzXmlNodeChild;

// ShapeOutside is a tagged union - use C API
using ShapeOutside = AzShapeOutside;

// ShapeInside is a tagged union - use C API
using ShapeInside = AzShapeInside;

// ClipPath is a tagged union - use C API
using ClipPath = AzClipPath;

// TextOperation is a tagged union - use C API
using TextOperation = AzTextOperation;

// LayoutMarginParseErrorOwned is a tagged union - use C API
using LayoutMarginParseErrorOwned = AzLayoutMarginParseErrorOwned;

// StyleTabSizeParseErrorOwned is a tagged union - use C API
using StyleTabSizeParseErrorOwned = AzStyleTabSizeParseErrorOwned;

// CssStylePerspectiveOriginParseErrorOwned is a tagged union - use C API
using CssStylePerspectiveOriginParseErrorOwned = AzCssStylePerspectiveOriginParseErrorOwned;

// StyleTextIndentParseErrorOwned is a tagged union - use C API
using StyleTextIndentParseErrorOwned = AzStyleTextIndentParseErrorOwned;

// StyleLetterSpacingParseErrorOwned is a tagged union - use C API
using StyleLetterSpacingParseErrorOwned = AzStyleLetterSpacingParseErrorOwned;

// OpacityParseErrorOwned is a tagged union - use C API
using OpacityParseErrorOwned = AzOpacityParseErrorOwned;

// CssStyleTransformParseErrorOwned is a tagged union - use C API
using CssStyleTransformParseErrorOwned = AzCssStyleTransformParseErrorOwned;

// CssStyleFontSizeParseErrorOwned is a tagged union - use C API
using CssStyleFontSizeParseErrorOwned = AzCssStyleFontSizeParseErrorOwned;

// CssStyleFilterOffsetParseErrorOwned is a tagged union - use C API
using CssStyleFilterOffsetParseErrorOwned = AzCssStyleFilterOffsetParseErrorOwned;

// ColumnWidthParseErrorOwned is a tagged union - use C API
using ColumnWidthParseErrorOwned = AzColumnWidthParseErrorOwned;

// ColumnRuleWidthParseErrorOwned is a tagged union - use C API
using ColumnRuleWidthParseErrorOwned = AzColumnRuleWidthParseErrorOwned;

// StyleWordSpacingParseErrorOwned is a tagged union - use C API
using StyleWordSpacingParseErrorOwned = AzStyleWordSpacingParseErrorOwned;

// LayoutHeightParseErrorOwned is a tagged union - use C API
using LayoutHeightParseErrorOwned = AzLayoutHeightParseErrorOwned;

// CssDirectionParseErrorOwned is a tagged union - use C API
using CssDirectionParseErrorOwned = AzCssDirectionParseErrorOwned;

// LayoutPaddingParseErrorOwned is a tagged union - use C API
using LayoutPaddingParseErrorOwned = AzLayoutPaddingParseErrorOwned;

// CssStyleBlurParseErrorOwned is a tagged union - use C API
using CssStyleBlurParseErrorOwned = AzCssStyleBlurParseErrorOwned;

// LayoutWidthParseErrorOwned is a tagged union - use C API
using LayoutWidthParseErrorOwned = AzLayoutWidthParseErrorOwned;

// CssBorderRadiusParseErrorOwned is a tagged union - use C API
using CssBorderRadiusParseErrorOwned = AzCssBorderRadiusParseErrorOwned;

// CssStyleTransformOriginParseErrorOwned is a tagged union - use C API
using CssStyleTransformOriginParseErrorOwned = AzCssStyleTransformOriginParseErrorOwned;

// CssBackgroundPositionParseErrorOwned is a tagged union - use C API
using CssBackgroundPositionParseErrorOwned = AzCssBackgroundPositionParseErrorOwned;

// StyleBorderBottomRightRadiusParseErrorOwned is a tagged union - use C API
using StyleBorderBottomRightRadiusParseErrorOwned = AzStyleBorderBottomRightRadiusParseErrorOwned;

// StyleBorderBottomLeftRadiusParseErrorOwned is a tagged union - use C API
using StyleBorderBottomLeftRadiusParseErrorOwned = AzStyleBorderBottomLeftRadiusParseErrorOwned;

// LayoutMaxWidthParseErrorOwned is a tagged union - use C API
using LayoutMaxWidthParseErrorOwned = AzLayoutMaxWidthParseErrorOwned;

// StyleBorderTopLeftRadiusParseErrorOwned is a tagged union - use C API
using StyleBorderTopLeftRadiusParseErrorOwned = AzStyleBorderTopLeftRadiusParseErrorOwned;

// LayoutMinHeightParseErrorOwned is a tagged union - use C API
using LayoutMinHeightParseErrorOwned = AzLayoutMinHeightParseErrorOwned;

// LayoutMinWidthParseErrorOwned is a tagged union - use C API
using LayoutMinWidthParseErrorOwned = AzLayoutMinWidthParseErrorOwned;

// LayoutMaxHeightParseErrorOwned is a tagged union - use C API
using LayoutMaxHeightParseErrorOwned = AzLayoutMaxHeightParseErrorOwned;

// StyleBorderTopRightRadiusParseErrorOwned is a tagged union - use C API
using StyleBorderTopRightRadiusParseErrorOwned = AzStyleBorderTopRightRadiusParseErrorOwned;

// LayoutLeftParseErrorOwned is a tagged union - use C API
using LayoutLeftParseErrorOwned = AzLayoutLeftParseErrorOwned;

// LayoutTopParseErrorOwned is a tagged union - use C API
using LayoutTopParseErrorOwned = AzLayoutTopParseErrorOwned;

// LayoutInsetBottomParseErrorOwned is a tagged union - use C API
using LayoutInsetBottomParseErrorOwned = AzLayoutInsetBottomParseErrorOwned;

// LayoutRightParseErrorOwned is a tagged union - use C API
using LayoutRightParseErrorOwned = AzLayoutRightParseErrorOwned;

// CssPathSelector is a tagged union - use C API
using CssPathSelector = AzCssPathSelector;

// CssPseudoSelectorParseErrorOwned is a tagged union - use C API
using CssPseudoSelectorParseErrorOwned = AzCssPseudoSelectorParseErrorOwned;

// MenuItem is a tagged union - use C API
using MenuItem = AzMenuItem;

// CssColorParseErrorOwned is a tagged union - use C API
using CssColorParseErrorOwned = AzCssColorParseErrorOwned;

// CssConicGradientParseErrorOwned is a tagged union - use C API
using CssConicGradientParseErrorOwned = AzCssConicGradientParseErrorOwned;

// XmlParseError is a tagged union - use C API
using XmlParseError = AzXmlParseError;

// CssProperty is a tagged union - use C API
using CssProperty = AzCssProperty;

// StyleTextColorParseErrorOwned is a tagged union - use C API
using StyleTextColorParseErrorOwned = AzStyleTextColorParseErrorOwned;

// ColumnRuleColorParseErrorOwned is a tagged union - use C API
using ColumnRuleColorParseErrorOwned = AzColumnRuleColorParseErrorOwned;

// CssBorderSideParseErrorOwned is a tagged union - use C API
using CssBorderSideParseErrorOwned = AzCssBorderSideParseErrorOwned;

// CssGradientStopParseErrorOwned is a tagged union - use C API
using CssGradientStopParseErrorOwned = AzCssGradientStopParseErrorOwned;

// CssShadowParseErrorOwned is a tagged union - use C API
using CssShadowParseErrorOwned = AzCssShadowParseErrorOwned;

// StyleScrollbarColorParseErrorOwned is a tagged union - use C API
using StyleScrollbarColorParseErrorOwned = AzStyleScrollbarColorParseErrorOwned;

// XmlError is a tagged union - use C API
using XmlError = AzXmlError;

// CssBackgroundParseErrorOwned is a tagged union - use C API
using CssBackgroundParseErrorOwned = AzCssBackgroundParseErrorOwned;

// CssStyleFilterParseErrorOwned is a tagged union - use C API
using CssStyleFilterParseErrorOwned = AzCssStyleFilterParseErrorOwned;

// ResultXmlXmlError is a tagged union - use C API
using ResultXmlXmlError = AzResultXmlXmlError;

// SvgParseError is a tagged union - use C API
using SvgParseError = AzSvgParseError;

// CssDeclaration is a tagged union - use C API
using CssDeclaration = AzCssDeclaration;

// CssParsingErrorOwned is a tagged union - use C API
using CssParsingErrorOwned = AzCssParsingErrorOwned;

// DynamicCssParseErrorOwned is a tagged union - use C API
using DynamicCssParseErrorOwned = AzDynamicCssParseErrorOwned;

// CssParseErrorInnerOwned is a tagged union - use C API
using CssParseErrorInnerOwned = AzCssParseErrorInnerOwned;

// RenderDomError is a tagged union - use C API
using RenderDomError = AzRenderDomError;

// ComponentParseError is a tagged union - use C API
using ComponentParseError = AzComponentParseError;

// DomXmlParseError is a tagged union - use C API
using DomXmlParseError = AzDomXmlParseError;

// CompileError is a tagged union - use C API
using CompileError = AzCompileError;

// Method implementations
// (Implemented after all classes are declared to avoid incomplete type errors)

inline bool MonitorId::partialEq(const MonitorId& b) const {
    return AzMonitorId_partialEq(&inner_, b.ptr());
}

inline uint64_t MonitorId::hash() const {
    return AzMonitorId_hash(&inner_);
}

inline uint8_t MonitorId::partialCmp(const MonitorId& b) const {
    return AzMonitorId_partialCmp(&inner_, b.ptr());
}

inline uint8_t MonitorId::cmp(const MonitorId& b) const {
    return AzMonitorId_cmp(&inner_, b.ptr());
}

inline String MonitorId::toDbgString() const {
    return String(AzMonitorId_toDbgString(&inner_));
}

inline WasmWindowOptions WasmWindowOptions::default_() {
    return WasmWindowOptions(AzWasmWindowOptions_default());
}

inline bool WasmWindowOptions::partialEq(const WasmWindowOptions& b) const {
    return AzWasmWindowOptions_partialEq(&inner_, b.ptr());
}

inline uint64_t WasmWindowOptions::hash() const {
    return AzWasmWindowOptions_hash(&inner_);
}

inline uint8_t WasmWindowOptions::partialCmp(const WasmWindowOptions& b) const {
    return AzWasmWindowOptions_partialCmp(&inner_, b.ptr());
}

inline uint8_t WasmWindowOptions::cmp(const WasmWindowOptions& b) const {
    return AzWasmWindowOptions_cmp(&inner_, b.ptr());
}

inline String WasmWindowOptions::toDbgString() const {
    return String(AzWasmWindowOptions_toDbgString(&inner_));
}

inline bool IconKey::partialEq(const IconKey& b) const {
    return AzIconKey_partialEq(&inner_, b.ptr());
}

inline uint64_t IconKey::hash() const {
    return AzIconKey_hash(&inner_);
}

inline uint8_t IconKey::partialCmp(const IconKey& b) const {
    return AzIconKey_partialCmp(&inner_, b.ptr());
}

inline uint8_t IconKey::cmp(const IconKey& b) const {
    return AzIconKey_cmp(&inner_, b.ptr());
}

inline String IconKey::toDbgString() const {
    return String(AzIconKey_toDbgString(&inner_));
}

inline MacWindowOptions MacWindowOptions::default_() {
    return MacWindowOptions(AzMacWindowOptions_default());
}

inline bool MacWindowOptions::partialEq(const MacWindowOptions& b) const {
    return AzMacWindowOptions_partialEq(&inner_, b.ptr());
}

inline uint64_t MacWindowOptions::hash() const {
    return AzMacWindowOptions_hash(&inner_);
}

inline uint8_t MacWindowOptions::partialCmp(const MacWindowOptions& b) const {
    return AzMacWindowOptions_partialCmp(&inner_, b.ptr());
}

inline uint8_t MacWindowOptions::cmp(const MacWindowOptions& b) const {
    return AzMacWindowOptions_cmp(&inner_, b.ptr());
}

inline String MacWindowOptions::toDbgString() const {
    return String(AzMacWindowOptions_toDbgString(&inner_));
}

inline bool IOSHandle::partialEq(const IOSHandle& b) const {
    return AzIOSHandle_partialEq(&inner_, b.ptr());
}

inline uint64_t IOSHandle::hash() const {
    return AzIOSHandle_hash(&inner_);
}

inline uint8_t IOSHandle::partialCmp(const IOSHandle& b) const {
    return AzIOSHandle_partialCmp(&inner_, b.ptr());
}

inline uint8_t IOSHandle::cmp(const IOSHandle& b) const {
    return AzIOSHandle_cmp(&inner_, b.ptr());
}

inline String IOSHandle::toDbgString() const {
    return String(AzIOSHandle_toDbgString(&inner_));
}

inline bool MacOSHandle::partialEq(const MacOSHandle& b) const {
    return AzMacOSHandle_partialEq(&inner_, b.ptr());
}

inline uint64_t MacOSHandle::hash() const {
    return AzMacOSHandle_hash(&inner_);
}

inline uint8_t MacOSHandle::partialCmp(const MacOSHandle& b) const {
    return AzMacOSHandle_partialCmp(&inner_, b.ptr());
}

inline uint8_t MacOSHandle::cmp(const MacOSHandle& b) const {
    return AzMacOSHandle_cmp(&inner_, b.ptr());
}

inline String MacOSHandle::toDbgString() const {
    return String(AzMacOSHandle_toDbgString(&inner_));
}

inline bool XcbHandle::partialEq(const XcbHandle& b) const {
    return AzXcbHandle_partialEq(&inner_, b.ptr());
}

inline uint64_t XcbHandle::hash() const {
    return AzXcbHandle_hash(&inner_);
}

inline uint8_t XcbHandle::partialCmp(const XcbHandle& b) const {
    return AzXcbHandle_partialCmp(&inner_, b.ptr());
}

inline uint8_t XcbHandle::cmp(const XcbHandle& b) const {
    return AzXcbHandle_cmp(&inner_, b.ptr());
}

inline String XcbHandle::toDbgString() const {
    return String(AzXcbHandle_toDbgString(&inner_));
}

inline bool XlibHandle::partialEq(const XlibHandle& b) const {
    return AzXlibHandle_partialEq(&inner_, b.ptr());
}

inline uint64_t XlibHandle::hash() const {
    return AzXlibHandle_hash(&inner_);
}

inline uint8_t XlibHandle::partialCmp(const XlibHandle& b) const {
    return AzXlibHandle_partialCmp(&inner_, b.ptr());
}

inline uint8_t XlibHandle::cmp(const XlibHandle& b) const {
    return AzXlibHandle_cmp(&inner_, b.ptr());
}

inline String XlibHandle::toDbgString() const {
    return String(AzXlibHandle_toDbgString(&inner_));
}

inline bool WaylandHandle::partialEq(const WaylandHandle& b) const {
    return AzWaylandHandle_partialEq(&inner_, b.ptr());
}

inline uint64_t WaylandHandle::hash() const {
    return AzWaylandHandle_hash(&inner_);
}

inline uint8_t WaylandHandle::partialCmp(const WaylandHandle& b) const {
    return AzWaylandHandle_partialCmp(&inner_, b.ptr());
}

inline uint8_t WaylandHandle::cmp(const WaylandHandle& b) const {
    return AzWaylandHandle_cmp(&inner_, b.ptr());
}

inline String WaylandHandle::toDbgString() const {
    return String(AzWaylandHandle_toDbgString(&inner_));
}

inline bool WindowsHandle::partialEq(const WindowsHandle& b) const {
    return AzWindowsHandle_partialEq(&inner_, b.ptr());
}

inline uint64_t WindowsHandle::hash() const {
    return AzWindowsHandle_hash(&inner_);
}

inline uint8_t WindowsHandle::partialCmp(const WindowsHandle& b) const {
    return AzWindowsHandle_partialCmp(&inner_, b.ptr());
}

inline uint8_t WindowsHandle::cmp(const WindowsHandle& b) const {
    return AzWindowsHandle_cmp(&inner_, b.ptr());
}

inline String WindowsHandle::toDbgString() const {
    return String(AzWindowsHandle_toDbgString(&inner_));
}

inline bool WebHandle::partialEq(const WebHandle& b) const {
    return AzWebHandle_partialEq(&inner_, b.ptr());
}

inline uint64_t WebHandle::hash() const {
    return AzWebHandle_hash(&inner_);
}

inline uint8_t WebHandle::partialCmp(const WebHandle& b) const {
    return AzWebHandle_partialCmp(&inner_, b.ptr());
}

inline uint8_t WebHandle::cmp(const WebHandle& b) const {
    return AzWebHandle_cmp(&inner_, b.ptr());
}

inline String WebHandle::toDbgString() const {
    return String(AzWebHandle_toDbgString(&inner_));
}

inline bool AndroidHandle::partialEq(const AndroidHandle& b) const {
    return AzAndroidHandle_partialEq(&inner_, b.ptr());
}

inline uint64_t AndroidHandle::hash() const {
    return AzAndroidHandle_hash(&inner_);
}

inline uint8_t AndroidHandle::partialCmp(const AndroidHandle& b) const {
    return AzAndroidHandle_partialCmp(&inner_, b.ptr());
}

inline uint8_t AndroidHandle::cmp(const AndroidHandle& b) const {
    return AzAndroidHandle_cmp(&inner_, b.ptr());
}

inline String AndroidHandle::toDbgString() const {
    return String(AzAndroidHandle_toDbgString(&inner_));
}

inline IconProviderHandle IconProviderHandle::create() {
    return IconProviderHandle(AzIconProviderHandle_create());
}

inline IconProviderHandle IconProviderHandle::with_resolver(AzIconResolverCallbackType resolver) {
    return IconProviderHandle(AzIconProviderHandle_withResolver(resolver));
}

inline IconProviderHandle IconProviderHandle::default_() {
    return IconProviderHandle(AzIconProviderHandle_default());
}

inline void IconProviderHandle::set_resolver(AzIconResolverCallbackType resolver) {
    AzIconProviderHandle_setResolver(&inner_, resolver);
}

inline void IconProviderHandle::register_icon(String pack_name, String icon_name, RefAny data) {
    AzIconProviderHandle_registerIcon(&inner_, pack_name.release(), icon_name.release(), data.release());
}

inline void IconProviderHandle::unregister_icon(String pack_name, String icon_name) {
    AzIconProviderHandle_unregisterIcon(&inner_, pack_name.release(), icon_name.release());
}

inline void IconProviderHandle::unregister_pack(String pack_name) {
    AzIconProviderHandle_unregisterPack(&inner_, pack_name.release());
}

inline OptionRefAny IconProviderHandle::lookup(String icon_name) const {
    return OptionRefAny(AzIconProviderHandle_lookup(&inner_, icon_name.release()));
}

inline bool IconProviderHandle::has_icon(String icon_name) const {
    return AzIconProviderHandle_hasIcon(&inner_, icon_name.release());
}

inline void IconProviderHandle::register_image_icon(String pack_name, String icon_name, ImageRef image) {
    AzIconProviderHandle_registerImageIcon(&inner_, pack_name.release(), icon_name.release(), image.release());
}

inline void IconProviderHandle::register_font_icon(String pack_name, String icon_name, FontRef font, String icon_char) {
    AzIconProviderHandle_registerFontIcon(&inner_, pack_name.release(), icon_name.release(), font.release(), icon_char.release());
}

inline String IconProviderHandle::debug_lookup(String icon_name) const {
    return String(AzIconProviderHandle_debugLookup(&inner_, icon_name.release()));
}

inline void IconProviderHandle::delete_() {
    AzIconProviderHandle_delete(&inner_);
}

inline IconProviderHandle IconProviderHandle::clone() const {
    return IconProviderHandle(AzIconProviderHandle_clone(&inner_));
}

inline String IconProviderHandle::toDbgString() const {
    return String(AzIconProviderHandle_toDbgString(&inner_));
}

inline String VideoModeVecSlice::toDbgString() const {
    return String(AzVideoModeVecSlice_toDbgString(&inner_));
}

inline String MonitorVecSlice::toDbgString() const {
    return String(AzMonitorVecSlice_toDbgString(&inner_));
}

inline String MimeTypeDataVecSlice::toDbgString() const {
    return String(AzMimeTypeDataVecSlice_toDbgString(&inner_));
}

inline String TouchPointVecSlice::toDbgString() const {
    return String(AzTouchPointVecSlice_toDbgString(&inner_));
}

inline AudioSink AudioSink::open(AudioConfig config) {
    return AudioSink(AzAudioSink_open(config.release()));
}

inline AudioSink AudioSink::default_() {
    return AudioSink(AzAudioSink_default());
}

inline bool AudioSink::is_open() const {
    return AzAudioSink_isOpen(&inner_);
}

inline void AudioSink::play(AudioFrame frame) const {
    AzAudioSink_play(&inner_, frame.release());
}

inline uint64_t AudioSink::frames_played() const {
    return AzAudioSink_framesPlayed(&inner_);
}

inline void AudioSink::close() {
    AzAudioSink_close(&inner_);
}

inline void AudioSink::delete_() {
    AzAudioSink_delete(&inner_);
}

inline AudioSink AudioSink::clone() const {
    return AudioSink(AzAudioSink_clone(&inner_));
}

inline String HttpHeaderVecSlice::toDbgString() const {
    return String(AzHttpHeaderVecSlice_toDbgString(&inner_));
}

inline MsgBox MsgBox::new_() {
    return MsgBox(AzMsgBox_new());
}

inline void MsgBox::ok(String title, String message, AzMsgBoxIcon icon) {
    AzMsgBox_ok(title.release(), message.release(), icon);
}

inline AzOkCancel MsgBox::ok_cancel(String title, String message, AzMsgBoxIcon icon, AzOkCancel default_) {
    return AzMsgBox_okCancel(title.release(), message.release(), icon, default_);
}

inline AzYesNo MsgBox::yes_no(String title, String message, AzMsgBoxIcon icon, AzYesNo default_) {
    return AzMsgBox_yesNo(title.release(), message.release(), icon, default_);
}

inline void MsgBox::info(String content) {
    AzMsgBox_info(content.release());
}

inline bool MsgBox::partialEq(const MsgBox& b) const {
    return AzMsgBox_partialEq(&inner_, b.ptr());
}

inline uint64_t MsgBox::hash() const {
    return AzMsgBox_hash(&inner_);
}

inline String MsgBox::toDbgString() const {
    return String(AzMsgBox_toDbgString(&inner_));
}

inline FileDialog FileDialog::new_() {
    return FileDialog(AzFileDialog_new());
}

inline OptionString FileDialog::open_file(String title, OptionString default_path, OptionFileTypeList filter_list) {
    return OptionString(AzFileDialog_openFile(title.release(), default_path.release(), filter_list.release()));
}

inline OptionString FileDialog::open_directory(String title, OptionString default_path) {
    return OptionString(AzFileDialog_openDirectory(title.release(), default_path.release()));
}

inline OptionStringVec FileDialog::open_multiple_files(String title, OptionString default_path, OptionFileTypeList filter_list) {
    return OptionStringVec(AzFileDialog_openMultipleFiles(title.release(), default_path.release(), filter_list.release()));
}

inline OptionString FileDialog::save_file(String title, OptionString default_path) {
    return OptionString(AzFileDialog_saveFile(title.release(), default_path.release()));
}

inline bool FileDialog::partialEq(const FileDialog& b) const {
    return AzFileDialog_partialEq(&inner_, b.ptr());
}

inline uint64_t FileDialog::hash() const {
    return AzFileDialog_hash(&inner_);
}

inline String FileDialog::toDbgString() const {
    return String(AzFileDialog_toDbgString(&inner_));
}

inline ColorPickerDialog ColorPickerDialog::new_() {
    return ColorPickerDialog(AzColorPickerDialog_new());
}

inline OptionColorU ColorPickerDialog::open(String title, OptionColorU default_value) {
    return OptionColorU(AzColorPickerDialog_open(title.release(), default_value.release()));
}

inline bool ColorPickerDialog::partialEq(const ColorPickerDialog& b) const {
    return AzColorPickerDialog_partialEq(&inner_, b.ptr());
}

inline uint64_t ColorPickerDialog::hash() const {
    return AzColorPickerDialog_hash(&inner_);
}

inline String ColorPickerDialog::toDbgString() const {
    return String(AzColorPickerDialog_toDbgString(&inner_));
}

inline bool RefCount::can_be_shared() const {
    return AzRefCount_canBeShared(&inner_);
}

inline bool RefCount::can_be_shared_mut() const {
    return AzRefCount_canBeSharedMut(&inner_);
}

inline void RefCount::increase_ref() const {
    AzRefCount_increaseRef(&inner_);
}

inline void RefCount::decrease_ref() const {
    AzRefCount_decreaseRef(&inner_);
}

inline void RefCount::increase_refmut() const {
    AzRefCount_increaseRefmut(&inner_);
}

inline void RefCount::decrease_refmut() const {
    AzRefCount_decreaseRefmut(&inner_);
}

inline void RefCount::delete_() {
    AzRefCount_delete(&inner_);
}

inline RefCount RefCount::clone() const {
    return RefCount(AzRefCount_clone(&inner_));
}

inline bool RefCount::partialEq(const RefCount& b) const {
    return AzRefCount_partialEq(&inner_, b.ptr());
}

inline uint64_t RefCount::hash() const {
    return AzRefCount_hash(&inner_);
}

inline uint8_t RefCount::partialCmp(const RefCount& b) const {
    return AzRefCount_partialCmp(&inner_, b.ptr());
}

inline uint8_t RefCount::cmp(const RefCount& b) const {
    return AzRefCount_cmp(&inner_, b.ptr());
}

inline String RefCount::toDbgString() const {
    return String(AzRefCount_toDbgString(&inner_));
}

inline bool GraphemeClusterId::partialEq(const GraphemeClusterId& b) const {
    return AzGraphemeClusterId_partialEq(&inner_, b.ptr());
}

inline uint64_t GraphemeClusterId::hash() const {
    return AzGraphemeClusterId_hash(&inner_);
}

inline uint8_t GraphemeClusterId::partialCmp(const GraphemeClusterId& b) const {
    return AzGraphemeClusterId_partialCmp(&inner_, b.ptr());
}

inline uint8_t GraphemeClusterId::cmp(const GraphemeClusterId& b) const {
    return AzGraphemeClusterId_cmp(&inner_, b.ptr());
}

inline String GraphemeClusterId::toDbgString() const {
    return String(AzGraphemeClusterId_toDbgString(&inner_));
}

inline bool PenTilt::partialEq(const PenTilt& b) const {
    return AzPenTilt_partialEq(&inner_, b.ptr());
}

inline uint8_t PenTilt::partialCmp(const PenTilt& b) const {
    return AzPenTilt_partialCmp(&inner_, b.ptr());
}

inline String PenTilt::toDbgString() const {
    return String(AzPenTilt_toDbgString(&inner_));
}

inline NodeFlags NodeFlags::default_() {
    return NodeFlags(AzNodeFlags_default());
}

inline bool NodeFlags::partialEq(const NodeFlags& b) const {
    return AzNodeFlags_partialEq(&inner_, b.ptr());
}

inline uint64_t NodeFlags::hash() const {
    return AzNodeFlags_hash(&inner_);
}

inline uint8_t NodeFlags::partialCmp(const NodeFlags& b) const {
    return AzNodeFlags_partialCmp(&inner_, b.ptr());
}

inline uint8_t NodeFlags::cmp(const NodeFlags& b) const {
    return AzNodeFlags_cmp(&inner_, b.ptr());
}

inline String NodeFlags::toDbgString() const {
    return String(AzNodeFlags_toDbgString(&inner_));
}

inline DomId DomId::default_() {
    return DomId(AzDomId_default());
}

inline bool DomId::partialEq(const DomId& b) const {
    return AzDomId_partialEq(&inner_, b.ptr());
}

inline uint64_t DomId::hash() const {
    return AzDomId_hash(&inner_);
}

inline uint8_t DomId::partialCmp(const DomId& b) const {
    return AzDomId_partialCmp(&inner_, b.ptr());
}

inline uint8_t DomId::cmp(const DomId& b) const {
    return AzDomId_cmp(&inner_, b.ptr());
}

inline String DomId::toDbgString() const {
    return String(AzDomId_toDbgString(&inner_));
}

inline NodeHierarchyItemId NodeHierarchyItemId::from_raw(size_t value) {
    return NodeHierarchyItemId(AzNodeHierarchyItemId_fromRaw(value));
}

inline size_t NodeHierarchyItemId::into_raw() const {
    return AzNodeHierarchyItemId_intoRaw(&inner_);
}

inline bool NodeHierarchyItemId::partialEq(const NodeHierarchyItemId& b) const {
    return AzNodeHierarchyItemId_partialEq(&inner_, b.ptr());
}

inline uint64_t NodeHierarchyItemId::hash() const {
    return AzNodeHierarchyItemId_hash(&inner_);
}

inline uint8_t NodeHierarchyItemId::partialCmp(const NodeHierarchyItemId& b) const {
    return AzNodeHierarchyItemId_partialCmp(&inner_, b.ptr());
}

inline uint8_t NodeHierarchyItemId::cmp(const NodeHierarchyItemId& b) const {
    return AzNodeHierarchyItemId_cmp(&inner_, b.ptr());
}

inline String NodeHierarchyItemId::toDbgString() const {
    return String(AzNodeHierarchyItemId_toDbgString(&inner_));
}

inline bool NodeHierarchyItem::partialEq(const NodeHierarchyItem& b) const {
    return AzNodeHierarchyItem_partialEq(&inner_, b.ptr());
}

inline uint64_t NodeHierarchyItem::hash() const {
    return AzNodeHierarchyItem_hash(&inner_);
}

inline uint8_t NodeHierarchyItem::partialCmp(const NodeHierarchyItem& b) const {
    return AzNodeHierarchyItem_partialCmp(&inner_, b.ptr());
}

inline uint8_t NodeHierarchyItem::cmp(const NodeHierarchyItem& b) const {
    return AzNodeHierarchyItem_cmp(&inner_, b.ptr());
}

inline String NodeHierarchyItem::toDbgString() const {
    return String(AzNodeHierarchyItem_toDbgString(&inner_));
}

inline bool TagId::partialEq(const TagId& b) const {
    return AzTagId_partialEq(&inner_, b.ptr());
}

inline uint64_t TagId::hash() const {
    return AzTagId_hash(&inner_);
}

inline uint8_t TagId::partialCmp(const TagId& b) const {
    return AzTagId_partialCmp(&inner_, b.ptr());
}

inline uint8_t TagId::cmp(const TagId& b) const {
    return AzTagId_cmp(&inner_, b.ptr());
}

inline String TagId::toDbgString() const {
    return String(AzTagId_toDbgString(&inner_));
}

inline DebugState DebugState::default_() {
    return DebugState(AzDebugState_default());
}

inline bool DebugState::partialEq(const DebugState& b) const {
    return AzDebugState_partialEq(&inner_, b.ptr());
}

inline uint64_t DebugState::hash() const {
    return AzDebugState_hash(&inner_);
}

inline uint8_t DebugState::partialCmp(const DebugState& b) const {
    return AzDebugState_partialCmp(&inner_, b.ptr());
}

inline uint8_t DebugState::cmp(const DebugState& b) const {
    return AzDebugState_cmp(&inner_, b.ptr());
}

inline String DebugState::toDbgString() const {
    return String(AzDebugState_toDbgString(&inner_));
}

inline GeolocationProbeConfig GeolocationProbeConfig::default_() {
    return GeolocationProbeConfig(AzGeolocationProbeConfig_default());
}

inline bool GeolocationProbeConfig::partialEq(const GeolocationProbeConfig& b) const {
    return AzGeolocationProbeConfig_partialEq(&inner_, b.ptr());
}

inline uint64_t GeolocationProbeConfig::hash() const {
    return AzGeolocationProbeConfig_hash(&inner_);
}

inline uint8_t GeolocationProbeConfig::partialCmp(const GeolocationProbeConfig& b) const {
    return AzGeolocationProbeConfig_partialCmp(&inner_, b.ptr());
}

inline uint8_t GeolocationProbeConfig::cmp(const GeolocationProbeConfig& b) const {
    return AzGeolocationProbeConfig_cmp(&inner_, b.ptr());
}

inline String GeolocationProbeConfig::toDbgString() const {
    return String(AzGeolocationProbeConfig_toDbgString(&inner_));
}

inline bool LocationFix::partialEq(const LocationFix& b) const {
    return AzLocationFix_partialEq(&inner_, b.ptr());
}

inline String LocationFix::toDbgString() const {
    return String(AzLocationFix_toDbgString(&inner_));
}

inline NodeId NodeId::create(size_t value) {
    return NodeId(AzNodeId_create(value));
}

inline size_t NodeId::index() const {
    return AzNodeId_index(&inner_);
}

inline bool NodeId::partialEq(const NodeId& b) const {
    return AzNodeId_partialEq(&inner_, b.ptr());
}

inline uint64_t NodeId::hash() const {
    return AzNodeId_hash(&inner_);
}

inline uint8_t NodeId::partialCmp(const NodeId& b) const {
    return AzNodeId_partialCmp(&inner_, b.ptr());
}

inline uint8_t NodeId::cmp(const NodeId& b) const {
    return AzNodeId_cmp(&inner_, b.ptr());
}

inline String NodeId::toDbgString() const {
    return String(AzNodeId_toDbgString(&inner_));
}

inline SelectionId SelectionId::default_() {
    return SelectionId(AzSelectionId_default());
}

inline bool SelectionId::partialEq(const SelectionId& b) const {
    return AzSelectionId_partialEq(&inner_, b.ptr());
}

inline uint64_t SelectionId::hash() const {
    return AzSelectionId_hash(&inner_);
}

inline uint8_t SelectionId::partialCmp(const SelectionId& b) const {
    return AzSelectionId_partialCmp(&inner_, b.ptr());
}

inline uint8_t SelectionId::cmp(const SelectionId& b) const {
    return AzSelectionId_cmp(&inner_, b.ptr());
}

inline String SelectionId::toDbgString() const {
    return String(AzSelectionId_toDbgString(&inner_));
}

inline void TextInputSelectionRange::delete_() {
    AzTextInputSelectionRange_delete(&inner_);
}

inline TextInputSelectionRange TextInputSelectionRange::clone() const {
    return TextInputSelectionRange(AzTextInputSelectionRange_clone(&inner_));
}

inline bool TextInputSelectionRange::partialEq(const TextInputSelectionRange& b) const {
    return AzTextInputSelectionRange_partialEq(&inner_, b.ptr());
}

inline uint64_t TextInputSelectionRange::hash() const {
    return AzTextInputSelectionRange_hash(&inner_);
}

inline String TextInputSelectionRange::toDbgString() const {
    return String(AzTextInputSelectionRange_toDbgString(&inner_));
}

inline void TextSelectionStartEnd::delete_() {
    AzTextSelectionStartEnd_delete(&inner_);
}

inline TextSelectionStartEnd TextSelectionStartEnd::clone() const {
    return TextSelectionStartEnd(AzTextSelectionStartEnd_clone(&inner_));
}

inline bool TextSelectionStartEnd::partialEq(const TextSelectionStartEnd& b) const {
    return AzTextSelectionStartEnd_partialEq(&inner_, b.ptr());
}

inline uint64_t TextSelectionStartEnd::hash() const {
    return AzTextSelectionStartEnd_hash(&inner_);
}

inline uint8_t TextSelectionStartEnd::partialCmp(const TextSelectionStartEnd& b) const {
    return AzTextSelectionStartEnd_partialCmp(&inner_, b.ptr());
}

inline uint8_t TextSelectionStartEnd::cmp(const TextSelectionStartEnd& b) const {
    return AzTextSelectionStartEnd_cmp(&inner_, b.ptr());
}

inline String TextSelectionStartEnd::toDbgString() const {
    return String(AzTextSelectionStartEnd_toDbgString(&inner_));
}

inline String NodeDataVecSlice::toDbgString() const {
    return String(AzNodeDataVecSlice_toDbgString(&inner_));
}

inline String NodeHierarchyItemVecSlice::toDbgString() const {
    return String(AzNodeHierarchyItemVecSlice_toDbgString(&inner_));
}

inline String DomIdVecSlice::toDbgString() const {
    return String(AzDomIdVecSlice_toDbgString(&inner_));
}

inline String TagIdToNodeIdMappingVecSlice::toDbgString() const {
    return String(AzTagIdToNodeIdMappingVecSlice_toDbgString(&inner_));
}

inline String VertexAttributeVecSlice::toDbgString() const {
    return String(AzVertexAttributeVecSlice_toDbgString(&inner_));
}

inline String NodeHierarchyItemIdVecSlice::toDbgString() const {
    return String(AzNodeHierarchyItemIdVecSlice_toDbgString(&inner_));
}

inline String IdOrClassVecSlice::toDbgString() const {
    return String(AzIdOrClassVecSlice_toDbgString(&inner_));
}

inline String SelectionRangeVecSlice::toDbgString() const {
    return String(AzSelectionRangeVecSlice_toDbgString(&inner_));
}

inline String SelectionVecSlice::toDbgString() const {
    return String(AzSelectionVecSlice_toDbgString(&inner_));
}

inline String DomVecSlice::toDbgString() const {
    return String(AzDomVecSlice_toDbgString(&inner_));
}

inline String AttributeTypeVecSlice::toDbgString() const {
    return String(AzAttributeTypeVecSlice_toDbgString(&inner_));
}

inline String AccessibilityActionVecSlice::toDbgString() const {
    return String(AzAccessibilityActionVecSlice_toDbgString(&inner_));
}

inline String CoreCallbackDataVecSlice::toDbgString() const {
    return String(AzCoreCallbackDataVecSlice_toDbgString(&inner_));
}

inline String ParentWithNodeDepthVecSlice::toDbgString() const {
    return String(AzParentWithNodeDepthVecSlice_toDbgString(&inner_));
}

inline String XmlNodeChildVecSlice::toDbgString() const {
    return String(AzXmlNodeChildVecSlice_toDbgString(&inner_));
}

inline AccessibilitySettings AccessibilitySettings::default_() {
    return AccessibilitySettings(AzAccessibilitySettings_default());
}

inline void AccessibilitySettings::delete_() {
    AzAccessibilitySettings_delete(&inner_);
}

inline AccessibilitySettings AccessibilitySettings::clone() const {
    return AccessibilitySettings(AzAccessibilitySettings_clone(&inner_));
}

inline bool AccessibilitySettings::partialEq(const AccessibilitySettings& b) const {
    return AzAccessibilitySettings_partialEq(&inner_, b.ptr());
}

inline String AccessibilitySettings::toDbgString() const {
    return String(AzAccessibilitySettings_toDbgString(&inner_));
}

inline InputMetrics InputMetrics::default_() {
    return InputMetrics(AzInputMetrics_default());
}

inline bool InputMetrics::partialEq(const InputMetrics& b) const {
    return AzInputMetrics_partialEq(&inner_, b.ptr());
}

inline String InputMetrics::toDbgString() const {
    return String(AzInputMetrics_toDbgString(&inner_));
}

inline DragDelta DragDelta::create(float dx, float dy) {
    return DragDelta(AzDragDelta_create(dx, dy));
}

inline DragDelta DragDelta::zero() {
    return DragDelta(AzDragDelta_zero());
}

inline DragDelta DragDelta::default_() {
    return DragDelta(AzDragDelta_default());
}

inline bool DragDelta::partialEq(const DragDelta& b) const {
    return AzDragDelta_partialEq(&inner_, b.ptr());
}

inline uint8_t DragDelta::partialCmp(const DragDelta& b) const {
    return AzDragDelta_partialCmp(&inner_, b.ptr());
}

inline String DragDelta::toDbgString() const {
    return String(AzDragDelta_toDbgString(&inner_));
}

inline String MenuItemVecSlice::toDbgString() const {
    return String(AzMenuItemVecSlice_toDbgString(&inner_));
}

inline bool CssNthChildPattern::partialEq(const CssNthChildPattern& b) const {
    return AzCssNthChildPattern_partialEq(&inner_, b.ptr());
}

inline uint64_t CssNthChildPattern::hash() const {
    return AzCssNthChildPattern_hash(&inner_);
}

inline uint8_t CssNthChildPattern::partialCmp(const CssNthChildPattern& b) const {
    return AzCssNthChildPattern_partialCmp(&inner_, b.ptr());
}

inline uint8_t CssNthChildPattern::cmp(const CssNthChildPattern& b) const {
    return AzCssNthChildPattern_cmp(&inner_, b.ptr());
}

inline String CssNthChildPattern::toDbgString() const {
    return String(AzCssNthChildPattern_toDbgString(&inner_));
}

inline ColorU ColorU::from_str(String string) {
    return ColorU(AzColorU_fromStr(string.release()));
}

inline ColorU ColorU::transparent() {
    return ColorU(AzColorU_transparent());
}

inline ColorU ColorU::white() {
    return ColorU(AzColorU_white());
}

inline ColorU ColorU::black() {
    return ColorU(AzColorU_black());
}

inline ColorU ColorU::create(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
    return ColorU(AzColorU_create(r, g, b, a));
}

inline ColorU ColorU::rgb(uint8_t r, uint8_t g, uint8_t b) {
    return ColorU(AzColorU_rgb(r, g, b));
}

inline ColorU ColorU::red() {
    return ColorU(AzColorU_red());
}

inline ColorU ColorU::green() {
    return ColorU(AzColorU_green());
}

inline ColorU ColorU::blue() {
    return ColorU(AzColorU_blue());
}

inline ColorU ColorU::yellow() {
    return ColorU(AzColorU_yellow());
}

inline ColorU ColorU::cyan() {
    return ColorU(AzColorU_cyan());
}

inline ColorU ColorU::magenta() {
    return ColorU(AzColorU_magenta());
}

inline ColorU ColorU::orange() {
    return ColorU(AzColorU_orange());
}

inline ColorU ColorU::pink() {
    return ColorU(AzColorU_pink());
}

inline ColorU ColorU::purple() {
    return ColorU(AzColorU_purple());
}

inline ColorU ColorU::brown() {
    return ColorU(AzColorU_brown());
}

inline ColorU ColorU::gray() {
    return ColorU(AzColorU_gray());
}

inline ColorU ColorU::light_gray() {
    return ColorU(AzColorU_lightGray());
}

inline ColorU ColorU::dark_gray() {
    return ColorU(AzColorU_darkGray());
}

inline ColorU ColorU::navy() {
    return ColorU(AzColorU_navy());
}

inline ColorU ColorU::teal() {
    return ColorU(AzColorU_teal());
}

inline ColorU ColorU::olive() {
    return ColorU(AzColorU_olive());
}

inline ColorU ColorU::maroon() {
    return ColorU(AzColorU_maroon());
}

inline ColorU ColorU::lime() {
    return ColorU(AzColorU_lime());
}

inline ColorU ColorU::aqua() {
    return ColorU(AzColorU_aqua());
}

inline ColorU ColorU::silver() {
    return ColorU(AzColorU_silver());
}

inline ColorU ColorU::fuchsia() {
    return ColorU(AzColorU_fuchsia());
}

inline ColorU ColorU::indigo() {
    return ColorU(AzColorU_indigo());
}

inline ColorU ColorU::gold() {
    return ColorU(AzColorU_gold());
}

inline ColorU ColorU::coral() {
    return ColorU(AzColorU_coral());
}

inline ColorU ColorU::salmon() {
    return ColorU(AzColorU_salmon());
}

inline ColorU ColorU::turquoise() {
    return ColorU(AzColorU_turquoise());
}

inline ColorU ColorU::violet() {
    return ColorU(AzColorU_violet());
}

inline ColorU ColorU::crimson() {
    return ColorU(AzColorU_crimson());
}

inline ColorU ColorU::chocolate() {
    return ColorU(AzColorU_chocolate());
}

inline ColorU ColorU::sky_blue() {
    return ColorU(AzColorU_skyBlue());
}

inline ColorU ColorU::forest_green() {
    return ColorU(AzColorU_forestGreen());
}

inline ColorU ColorU::sea_green() {
    return ColorU(AzColorU_seaGreen());
}

inline ColorU ColorU::slate_gray() {
    return ColorU(AzColorU_slateGray());
}

inline ColorU ColorU::midnight_blue() {
    return ColorU(AzColorU_midnightBlue());
}

inline ColorU ColorU::dark_red() {
    return ColorU(AzColorU_darkRed());
}

inline ColorU ColorU::dark_green() {
    return ColorU(AzColorU_darkGreen());
}

inline ColorU ColorU::dark_blue() {
    return ColorU(AzColorU_darkBlue());
}

inline ColorU ColorU::light_blue() {
    return ColorU(AzColorU_lightBlue());
}

inline ColorU ColorU::light_green() {
    return ColorU(AzColorU_lightGreen());
}

inline ColorU ColorU::light_yellow() {
    return ColorU(AzColorU_lightYellow());
}

inline ColorU ColorU::light_pink() {
    return ColorU(AzColorU_lightPink());
}

inline ColorU ColorU::rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
    return ColorU(AzColorU_rgba(r, g, b, a));
}

inline ColorU ColorU::new_(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
    return ColorU(AzColorU_new(r, g, b, a));
}

inline ColorU ColorU::new_rgb(uint8_t r, uint8_t g, uint8_t b) {
    return ColorU(AzColorU_newRgb(r, g, b));
}

inline ColorU ColorU::strawberry(size_t shade) {
    return ColorU(AzColorU_strawberry(shade));
}

inline ColorU ColorU::palette_orange(size_t shade) {
    return ColorU(AzColorU_paletteOrange(shade));
}

inline ColorU ColorU::banana(size_t shade) {
    return ColorU(AzColorU_banana(shade));
}

inline ColorU ColorU::palette_lime(size_t shade) {
    return ColorU(AzColorU_paletteLime(shade));
}

inline ColorU ColorU::mint(size_t shade) {
    return ColorU(AzColorU_mint(shade));
}

inline ColorU ColorU::blueberry(size_t shade) {
    return ColorU(AzColorU_blueberry(shade));
}

inline ColorU ColorU::grape(size_t shade) {
    return ColorU(AzColorU_grape(shade));
}

inline ColorU ColorU::bubblegum(size_t shade) {
    return ColorU(AzColorU_bubblegum(shade));
}

inline ColorU ColorU::cocoa(size_t shade) {
    return ColorU(AzColorU_cocoa(shade));
}

inline ColorU ColorU::palette_silver(size_t shade) {
    return ColorU(AzColorU_paletteSilver(shade));
}

inline ColorU ColorU::slate(size_t shade) {
    return ColorU(AzColorU_slate(shade));
}

inline ColorU ColorU::dark(size_t shade) {
    return ColorU(AzColorU_dark(shade));
}

inline ColorU ColorU::apple_red() {
    return ColorU(AzColorU_appleRed());
}

inline ColorU ColorU::apple_red_dark() {
    return ColorU(AzColorU_appleRedDark());
}

inline ColorU ColorU::apple_orange() {
    return ColorU(AzColorU_appleOrange());
}

inline ColorU ColorU::apple_orange_dark() {
    return ColorU(AzColorU_appleOrangeDark());
}

inline ColorU ColorU::apple_yellow() {
    return ColorU(AzColorU_appleYellow());
}

inline ColorU ColorU::apple_yellow_dark() {
    return ColorU(AzColorU_appleYellowDark());
}

inline ColorU ColorU::apple_green() {
    return ColorU(AzColorU_appleGreen());
}

inline ColorU ColorU::apple_green_dark() {
    return ColorU(AzColorU_appleGreenDark());
}

inline ColorU ColorU::apple_mint() {
    return ColorU(AzColorU_appleMint());
}

inline ColorU ColorU::apple_mint_dark() {
    return ColorU(AzColorU_appleMintDark());
}

inline ColorU ColorU::apple_teal() {
    return ColorU(AzColorU_appleTeal());
}

inline ColorU ColorU::apple_teal_dark() {
    return ColorU(AzColorU_appleTealDark());
}

inline ColorU ColorU::apple_cyan() {
    return ColorU(AzColorU_appleCyan());
}

inline ColorU ColorU::apple_cyan_dark() {
    return ColorU(AzColorU_appleCyanDark());
}

inline ColorU ColorU::apple_blue() {
    return ColorU(AzColorU_appleBlue());
}

inline ColorU ColorU::apple_blue_dark() {
    return ColorU(AzColorU_appleBlueDark());
}

inline ColorU ColorU::apple_indigo() {
    return ColorU(AzColorU_appleIndigo());
}

inline ColorU ColorU::apple_indigo_dark() {
    return ColorU(AzColorU_appleIndigoDark());
}

inline ColorU ColorU::apple_purple() {
    return ColorU(AzColorU_applePurple());
}

inline ColorU ColorU::apple_purple_dark() {
    return ColorU(AzColorU_applePurpleDark());
}

inline ColorU ColorU::apple_pink() {
    return ColorU(AzColorU_applePink());
}

inline ColorU ColorU::apple_pink_dark() {
    return ColorU(AzColorU_applePinkDark());
}

inline ColorU ColorU::apple_brown() {
    return ColorU(AzColorU_appleBrown());
}

inline ColorU ColorU::apple_brown_dark() {
    return ColorU(AzColorU_appleBrownDark());
}

inline ColorU ColorU::apple_gray() {
    return ColorU(AzColorU_appleGray());
}

inline ColorU ColorU::apple_gray_dark() {
    return ColorU(AzColorU_appleGrayDark());
}

inline ColorU ColorU::bootstrap_primary() {
    return ColorU(AzColorU_bootstrapPrimary());
}

inline ColorU ColorU::bootstrap_primary_hover() {
    return ColorU(AzColorU_bootstrapPrimaryHover());
}

inline ColorU ColorU::bootstrap_primary_active() {
    return ColorU(AzColorU_bootstrapPrimaryActive());
}

inline ColorU ColorU::bootstrap_secondary() {
    return ColorU(AzColorU_bootstrapSecondary());
}

inline ColorU ColorU::bootstrap_secondary_hover() {
    return ColorU(AzColorU_bootstrapSecondaryHover());
}

inline ColorU ColorU::bootstrap_secondary_active() {
    return ColorU(AzColorU_bootstrapSecondaryActive());
}

inline ColorU ColorU::bootstrap_success() {
    return ColorU(AzColorU_bootstrapSuccess());
}

inline ColorU ColorU::bootstrap_success_hover() {
    return ColorU(AzColorU_bootstrapSuccessHover());
}

inline ColorU ColorU::bootstrap_success_active() {
    return ColorU(AzColorU_bootstrapSuccessActive());
}

inline ColorU ColorU::bootstrap_danger() {
    return ColorU(AzColorU_bootstrapDanger());
}

inline ColorU ColorU::bootstrap_danger_hover() {
    return ColorU(AzColorU_bootstrapDangerHover());
}

inline ColorU ColorU::bootstrap_danger_active() {
    return ColorU(AzColorU_bootstrapDangerActive());
}

inline ColorU ColorU::bootstrap_warning() {
    return ColorU(AzColorU_bootstrapWarning());
}

inline ColorU ColorU::bootstrap_warning_hover() {
    return ColorU(AzColorU_bootstrapWarningHover());
}

inline ColorU ColorU::bootstrap_warning_active() {
    return ColorU(AzColorU_bootstrapWarningActive());
}

inline ColorU ColorU::bootstrap_info() {
    return ColorU(AzColorU_bootstrapInfo());
}

inline ColorU ColorU::bootstrap_info_hover() {
    return ColorU(AzColorU_bootstrapInfoHover());
}

inline ColorU ColorU::bootstrap_info_active() {
    return ColorU(AzColorU_bootstrapInfoActive());
}

inline ColorU ColorU::bootstrap_light() {
    return ColorU(AzColorU_bootstrapLight());
}

inline ColorU ColorU::bootstrap_light_hover() {
    return ColorU(AzColorU_bootstrapLightHover());
}

inline ColorU ColorU::bootstrap_light_active() {
    return ColorU(AzColorU_bootstrapLightActive());
}

inline ColorU ColorU::bootstrap_dark() {
    return ColorU(AzColorU_bootstrapDark());
}

inline ColorU ColorU::bootstrap_dark_hover() {
    return ColorU(AzColorU_bootstrapDarkHover());
}

inline ColorU ColorU::bootstrap_dark_active() {
    return ColorU(AzColorU_bootstrapDarkActive());
}

inline ColorU ColorU::bootstrap_link() {
    return ColorU(AzColorU_bootstrapLink());
}

inline ColorU ColorU::bootstrap_link_hover() {
    return ColorU(AzColorU_bootstrapLinkHover());
}

inline ColorU ColorU::default_() {
    return ColorU(AzColorU_default());
}

inline String ColorU::to_hash() const {
    return String(AzColorU_toHash(&inner_));
}

inline bool ColorU::has_alpha() const {
    return AzColorU_hasAlpha(&inner_);
}

inline ColorU ColorU::interpolate(ColorU other, float t) const {
    return ColorU(AzColorU_interpolate(&inner_, other.release(), t));
}

inline ColorU ColorU::lighten(float amount) const {
    return ColorU(AzColorU_lighten(&inner_, amount));
}

inline ColorU ColorU::darken(float amount) const {
    return ColorU(AzColorU_darken(&inner_, amount));
}

inline ColorU ColorU::mix(ColorU other, float ratio) const {
    return ColorU(AzColorU_mix(&inner_, other.release(), ratio));
}

inline ColorU ColorU::hover_variant() const {
    return ColorU(AzColorU_hoverVariant(&inner_));
}

inline ColorU ColorU::active_variant() const {
    return ColorU(AzColorU_activeVariant(&inner_));
}

inline float ColorU::luminance() const {
    return AzColorU_luminance(&inner_);
}

inline float ColorU::relative_luminance() const {
    return AzColorU_relativeLuminance(&inner_);
}

inline ColorU ColorU::contrast_text() const {
    return ColorU(AzColorU_contrastText(&inner_));
}

inline ColorU ColorU::best_contrast_text() const {
    return ColorU(AzColorU_bestContrastText(&inner_));
}

inline float ColorU::contrast_ratio(ColorU other) const {
    return AzColorU_contrastRatio(&inner_, other.release());
}

inline bool ColorU::meets_wcag_aa(ColorU other) const {
    return AzColorU_meetsWcagAa(&inner_, other.release());
}

inline bool ColorU::meets_wcag_aa_large(ColorU other) const {
    return AzColorU_meetsWcagAaLarge(&inner_, other.release());
}

inline bool ColorU::meets_wcag_aaa(ColorU other) const {
    return AzColorU_meetsWcagAaa(&inner_, other.release());
}

inline bool ColorU::meets_wcag_aaa_large(ColorU other) const {
    return AzColorU_meetsWcagAaaLarge(&inner_, other.release());
}

inline float ColorU::apca_contrast(ColorU background) const {
    return AzColorU_apcaContrast(&inner_, background.release());
}

inline bool ColorU::meets_apca_body(ColorU background) const {
    return AzColorU_meetsApcaBody(&inner_, background.release());
}

inline bool ColorU::meets_apca_large(ColorU background) const {
    return AzColorU_meetsApcaLarge(&inner_, background.release());
}

inline bool ColorU::is_light() const {
    return AzColorU_isLight(&inner_);
}

inline bool ColorU::is_dark() const {
    return AzColorU_isDark(&inner_);
}

inline ColorU ColorU::ensure_contrast(ColorU background, float min_ratio) const {
    return ColorU(AzColorU_ensureContrast(&inner_, background.release(), min_ratio));
}

inline ColorU ColorU::with_alpha(uint8_t a) const {
    return ColorU(AzColorU_withAlpha(&inner_, a));
}

inline ColorU ColorU::with_alpha_f32(float a) const {
    return ColorU(AzColorU_withAlphaF32(&inner_, a));
}

inline ColorU ColorU::invert() const {
    return ColorU(AzColorU_invert(&inner_));
}

inline ColorU ColorU::to_grayscale() const {
    return ColorU(AzColorU_toGrayscale(&inner_));
}

inline bool ColorU::partialEq(const ColorU& b) const {
    return AzColorU_partialEq(&inner_, b.ptr());
}

inline uint64_t ColorU::hash() const {
    return AzColorU_hash(&inner_);
}

inline uint8_t ColorU::partialCmp(const ColorU& b) const {
    return AzColorU_partialCmp(&inner_, b.ptr());
}

inline uint8_t ColorU::cmp(const ColorU& b) const {
    return AzColorU_cmp(&inner_, b.ptr());
}

inline String ColorU::toDbgString() const {
    return String(AzColorU_toDbgString(&inner_));
}

inline FloatValue FloatValue::create(float value) {
    return FloatValue(AzFloatValue_create(value));
}

inline FloatValue FloatValue::default_() {
    return FloatValue(AzFloatValue_default());
}

inline float FloatValue::get() const {
    return AzFloatValue_get(&inner_);
}

inline bool FloatValue::partialEq(const FloatValue& b) const {
    return AzFloatValue_partialEq(&inner_, b.ptr());
}

inline uint64_t FloatValue::hash() const {
    return AzFloatValue_hash(&inner_);
}

inline uint8_t FloatValue::partialCmp(const FloatValue& b) const {
    return AzFloatValue_partialCmp(&inner_, b.ptr());
}

inline uint8_t FloatValue::cmp(const FloatValue& b) const {
    return AzFloatValue_cmp(&inner_, b.ptr());
}

inline String FloatValue::toDbgString() const {
    return String(AzFloatValue_toDbgString(&inner_));
}

inline LayoutSize LayoutSize::create(ptrdiff_t width, ptrdiff_t height) {
    return LayoutSize(AzLayoutSize_create(width, height));
}

inline LayoutSize LayoutSize::zero() {
    return LayoutSize(AzLayoutSize_zero());
}

inline LayoutSize LayoutSize::default_() {
    return LayoutSize(AzLayoutSize_default());
}

inline bool LayoutSize::partialEq(const LayoutSize& b) const {
    return AzLayoutSize_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutSize::hash() const {
    return AzLayoutSize_hash(&inner_);
}

inline uint8_t LayoutSize::partialCmp(const LayoutSize& b) const {
    return AzLayoutSize_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutSize::cmp(const LayoutSize& b) const {
    return AzLayoutSize_cmp(&inner_, b.ptr());
}

inline String LayoutSize::toDbgString() const {
    return String(AzLayoutSize_toDbgString(&inner_));
}

inline bool StyleLineClamp::partialEq(const StyleLineClamp& b) const {
    return AzStyleLineClamp_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleLineClamp::hash() const {
    return AzStyleLineClamp_hash(&inner_);
}

inline uint8_t StyleLineClamp::partialCmp(const StyleLineClamp& b) const {
    return AzStyleLineClamp_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleLineClamp::cmp(const StyleLineClamp& b) const {
    return AzStyleLineClamp_cmp(&inner_, b.ptr());
}

inline String StyleLineClamp::toDbgString() const {
    return String(AzStyleLineClamp_toDbgString(&inner_));
}

inline Orphans Orphans::default_() {
    return Orphans(AzOrphans_default());
}

inline bool Orphans::partialEq(const Orphans& b) const {
    return AzOrphans_partialEq(&inner_, b.ptr());
}

inline uint64_t Orphans::hash() const {
    return AzOrphans_hash(&inner_);
}

inline uint8_t Orphans::partialCmp(const Orphans& b) const {
    return AzOrphans_partialCmp(&inner_, b.ptr());
}

inline uint8_t Orphans::cmp(const Orphans& b) const {
    return AzOrphans_cmp(&inner_, b.ptr());
}

inline String Orphans::toDbgString() const {
    return String(AzOrphans_toDbgString(&inner_));
}

inline Widows Widows::default_() {
    return Widows(AzWidows_default());
}

inline bool Widows::partialEq(const Widows& b) const {
    return AzWidows_partialEq(&inner_, b.ptr());
}

inline uint64_t Widows::hash() const {
    return AzWidows_hash(&inner_);
}

inline uint8_t Widows::partialCmp(const Widows& b) const {
    return AzWidows_partialCmp(&inner_, b.ptr());
}

inline uint8_t Widows::cmp(const Widows& b) const {
    return AzWidows_cmp(&inner_, b.ptr());
}

inline String Widows::toDbgString() const {
    return String(AzWidows_toDbgString(&inner_));
}

inline StyleHangingPunctuation StyleHangingPunctuation::default_() {
    return StyleHangingPunctuation(AzStyleHangingPunctuation_default());
}

inline bool StyleHangingPunctuation::partialEq(const StyleHangingPunctuation& b) const {
    return AzStyleHangingPunctuation_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleHangingPunctuation::hash() const {
    return AzStyleHangingPunctuation_hash(&inner_);
}

inline uint8_t StyleHangingPunctuation::partialCmp(const StyleHangingPunctuation& b) const {
    return AzStyleHangingPunctuation_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleHangingPunctuation::cmp(const StyleHangingPunctuation& b) const {
    return AzStyleHangingPunctuation_cmp(&inner_, b.ptr());
}

inline String StyleHangingPunctuation::toDbgString() const {
    return String(AzStyleHangingPunctuation_toDbgString(&inner_));
}

inline void XmlTextPos::delete_() {
    AzXmlTextPos_delete(&inner_);
}

inline XmlTextPos XmlTextPos::clone() const {
    return XmlTextPos(AzXmlTextPos_clone(&inner_));
}

inline bool XmlTextPos::partialEq(const XmlTextPos& b) const {
    return AzXmlTextPos_partialEq(&inner_, b.ptr());
}

inline uint64_t XmlTextPos::hash() const {
    return AzXmlTextPos_hash(&inner_);
}

inline uint8_t XmlTextPos::partialCmp(const XmlTextPos& b) const {
    return AzXmlTextPos_partialCmp(&inner_, b.ptr());
}

inline uint8_t XmlTextPos::cmp(const XmlTextPos& b) const {
    return AzXmlTextPos_cmp(&inner_, b.ptr());
}

inline String XmlTextPos::toDbgString() const {
    return String(AzXmlTextPos_toDbgString(&inner_));
}

inline LogicalSize LogicalSize::create(float width, float height) {
    return LogicalSize(AzLogicalSize_create(width, height));
}

inline LogicalSize LogicalSize::zero() {
    return LogicalSize(AzLogicalSize_zero());
}

inline LogicalSize LogicalSize::default_() {
    return LogicalSize(AzLogicalSize_default());
}

inline bool LogicalSize::partialEq(const LogicalSize& b) const {
    return AzLogicalSize_partialEq(&inner_, b.ptr());
}

inline uint64_t LogicalSize::hash() const {
    return AzLogicalSize_hash(&inner_);
}

inline uint8_t LogicalSize::partialCmp(const LogicalSize& b) const {
    return AzLogicalSize_partialCmp(&inner_, b.ptr());
}

inline uint8_t LogicalSize::cmp(const LogicalSize& b) const {
    return AzLogicalSize_cmp(&inner_, b.ptr());
}

inline String LogicalSize::toDbgString() const {
    return String(AzLogicalSize_toDbgString(&inner_));
}

inline StyledNodeState StyledNodeState::default_() {
    return StyledNodeState(AzStyledNodeState_default());
}

inline bool StyledNodeState::partialEq(const StyledNodeState& b) const {
    return AzStyledNodeState_partialEq(&inner_, b.ptr());
}

inline uint64_t StyledNodeState::hash() const {
    return AzStyledNodeState_hash(&inner_);
}

inline uint8_t StyledNodeState::partialCmp(const StyledNodeState& b) const {
    return AzStyledNodeState_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyledNodeState::cmp(const StyledNodeState& b) const {
    return AzStyledNodeState_cmp(&inner_, b.ptr());
}

inline String StyledNodeState::toDbgString() const {
    return String(AzStyledNodeState_toDbgString(&inner_));
}

inline void CssPropertyCachePtr::delete_() {
    AzCssPropertyCachePtr_delete(&inner_);
}

inline CssPropertyCachePtr CssPropertyCachePtr::clone() const {
    return CssPropertyCachePtr(AzCssPropertyCachePtr_clone(&inner_));
}

inline bool CssPropertyCachePtr::partialEq(const CssPropertyCachePtr& b) const {
    return AzCssPropertyCachePtr_partialEq(&inner_, b.ptr());
}

inline String CssPropertyCachePtr::toDbgString() const {
    return String(AzCssPropertyCachePtr_toDbgString(&inner_));
}

inline SvgRenderTransform SvgRenderTransform::default_() {
    return SvgRenderTransform(AzSvgRenderTransform_default());
}

inline bool SvgRenderTransform::partialEq(const SvgRenderTransform& b) const {
    return AzSvgRenderTransform_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgRenderTransform::partialCmp(const SvgRenderTransform& b) const {
    return AzSvgRenderTransform_partialCmp(&inner_, b.ptr());
}

inline String SvgRenderTransform::toDbgString() const {
    return String(AzSvgRenderTransform_toDbgString(&inner_));
}

inline LogicalPosition LogicalPosition::create(float x, float y) {
    return LogicalPosition(AzLogicalPosition_create(x, y));
}

inline LogicalPosition LogicalPosition::zero() {
    return LogicalPosition(AzLogicalPosition_zero());
}

inline LogicalPosition LogicalPosition::default_() {
    return LogicalPosition(AzLogicalPosition_default());
}

inline bool LogicalPosition::partialEq(const LogicalPosition& b) const {
    return AzLogicalPosition_partialEq(&inner_, b.ptr());
}

inline uint64_t LogicalPosition::hash() const {
    return AzLogicalPosition_hash(&inner_);
}

inline uint8_t LogicalPosition::partialCmp(const LogicalPosition& b) const {
    return AzLogicalPosition_partialCmp(&inner_, b.ptr());
}

inline uint8_t LogicalPosition::cmp(const LogicalPosition& b) const {
    return AzLogicalPosition_cmp(&inner_, b.ptr());
}

inline String LogicalPosition::toDbgString() const {
    return String(AzLogicalPosition_toDbgString(&inner_));
}

inline ScreenPosition ScreenPosition::create(float x, float y) {
    return ScreenPosition(AzScreenPosition_create(x, y));
}

inline ScreenPosition ScreenPosition::zero() {
    return ScreenPosition(AzScreenPosition_zero());
}

inline ScreenPosition ScreenPosition::default_() {
    return ScreenPosition(AzScreenPosition_default());
}

inline bool ScreenPosition::partialEq(const ScreenPosition& b) const {
    return AzScreenPosition_partialEq(&inner_, b.ptr());
}

inline uint8_t ScreenPosition::partialCmp(const ScreenPosition& b) const {
    return AzScreenPosition_partialCmp(&inner_, b.ptr());
}

inline String ScreenPosition::toDbgString() const {
    return String(AzScreenPosition_toDbgString(&inner_));
}

inline CursorNodePosition CursorNodePosition::create(float x, float y) {
    return CursorNodePosition(AzCursorNodePosition_create(x, y));
}

inline CursorNodePosition CursorNodePosition::zero() {
    return CursorNodePosition(AzCursorNodePosition_zero());
}

inline CursorNodePosition CursorNodePosition::default_() {
    return CursorNodePosition(AzCursorNodePosition_default());
}

inline bool CursorNodePosition::partialEq(const CursorNodePosition& b) const {
    return AzCursorNodePosition_partialEq(&inner_, b.ptr());
}

inline uint8_t CursorNodePosition::partialCmp(const CursorNodePosition& b) const {
    return AzCursorNodePosition_partialCmp(&inner_, b.ptr());
}

inline String CursorNodePosition::toDbgString() const {
    return String(AzCursorNodePosition_toDbgString(&inner_));
}

inline void GridMinMax::delete_() {
    AzGridMinMax_delete(&inner_);
}

inline GridMinMax GridMinMax::clone() const {
    return GridMinMax(AzGridMinMax_clone(&inner_));
}

inline bool GridMinMax::partialEq(const GridMinMax& b) const {
    return AzGridMinMax_partialEq(&inner_, b.ptr());
}

inline uint64_t GridMinMax::hash() const {
    return AzGridMinMax_hash(&inner_);
}

inline uint8_t GridMinMax::partialCmp(const GridMinMax& b) const {
    return AzGridMinMax_partialCmp(&inner_, b.ptr());
}

inline uint8_t GridMinMax::cmp(const GridMinMax& b) const {
    return AzGridMinMax_cmp(&inner_, b.ptr());
}

inline String GridMinMax::toDbgString() const {
    return String(AzGridMinMax_toDbgString(&inner_));
}

inline bool ShapePoint::partialEq(const ShapePoint& b) const {
    return AzShapePoint_partialEq(&inner_, b.ptr());
}

inline uint64_t ShapePoint::hash() const {
    return AzShapePoint_hash(&inner_);
}

inline uint8_t ShapePoint::partialCmp(const ShapePoint& b) const {
    return AzShapePoint_partialCmp(&inner_, b.ptr());
}

inline uint8_t ShapePoint::cmp(const ShapePoint& b) const {
    return AzShapePoint_cmp(&inner_, b.ptr());
}

inline String ShapePoint::toDbgString() const {
    return String(AzShapePoint_toDbgString(&inner_));
}

inline String LayoutRectVecSlice::toDbgString() const {
    return String(AzLayoutRectVecSlice_toDbgString(&inner_));
}

inline LayoutPoint LayoutPoint::create(ptrdiff_t x, ptrdiff_t y) {
    return LayoutPoint(AzLayoutPoint_create(x, y));
}

inline LayoutPoint LayoutPoint::zero() {
    return LayoutPoint(AzLayoutPoint_zero());
}

inline LayoutPoint LayoutPoint::default_() {
    return LayoutPoint(AzLayoutPoint_default());
}

inline bool LayoutPoint::partialEq(const LayoutPoint& b) const {
    return AzLayoutPoint_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutPoint::hash() const {
    return AzLayoutPoint_hash(&inner_);
}

inline uint8_t LayoutPoint::partialCmp(const LayoutPoint& b) const {
    return AzLayoutPoint_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutPoint::cmp(const LayoutPoint& b) const {
    return AzLayoutPoint_cmp(&inner_, b.ptr());
}

inline String LayoutPoint::toDbgString() const {
    return String(AzLayoutPoint_toDbgString(&inner_));
}

inline LinuxDecorationsState LinuxDecorationsState::default_() {
    return LinuxDecorationsState(AzLinuxDecorationsState_default());
}

inline bool LinuxDecorationsState::partialEq(const LinuxDecorationsState& b) const {
    return AzLinuxDecorationsState_partialEq(&inner_, b.ptr());
}

inline uint64_t LinuxDecorationsState::hash() const {
    return AzLinuxDecorationsState_hash(&inner_);
}

inline uint8_t LinuxDecorationsState::partialCmp(const LinuxDecorationsState& b) const {
    return AzLinuxDecorationsState_partialCmp(&inner_, b.ptr());
}

inline uint8_t LinuxDecorationsState::cmp(const LinuxDecorationsState& b) const {
    return AzLinuxDecorationsState_cmp(&inner_, b.ptr());
}

inline String LinuxDecorationsState::toDbgString() const {
    return String(AzLinuxDecorationsState_toDbgString(&inner_));
}

inline CascadeInfo CascadeInfo::default_() {
    return CascadeInfo(AzCascadeInfo_default());
}

inline bool CascadeInfo::partialEq(const CascadeInfo& b) const {
    return AzCascadeInfo_partialEq(&inner_, b.ptr());
}

inline uint64_t CascadeInfo::hash() const {
    return AzCascadeInfo_hash(&inner_);
}

inline uint8_t CascadeInfo::partialCmp(const CascadeInfo& b) const {
    return AzCascadeInfo_partialCmp(&inner_, b.ptr());
}

inline uint8_t CascadeInfo::cmp(const CascadeInfo& b) const {
    return AzCascadeInfo_cmp(&inner_, b.ptr());
}

inline String CascadeInfo::toDbgString() const {
    return String(AzCascadeInfo_toDbgString(&inner_));
}

inline String GridTrackSizingVecSlice::toDbgString() const {
    return String(AzGridTrackSizingVecSlice_toDbgString(&inner_));
}

inline String ContentGroupVecSlice::toDbgString() const {
    return String(AzContentGroupVecSlice_toDbgString(&inner_));
}

inline String StyledTextRunVecSlice::toDbgString() const {
    return String(AzStyledTextRunVecSlice_toDbgString(&inner_));
}

inline String CssRuleBlockVecSlice::toDbgString() const {
    return String(AzCssRuleBlockVecSlice_toDbgString(&inner_));
}

inline String CascadeInfoVecSlice::toDbgString() const {
    return String(AzCascadeInfoVecSlice_toDbgString(&inner_));
}

inline String NormalizedRadialColorStopVecSlice::toDbgString() const {
    return String(AzNormalizedRadialColorStopVecSlice_toDbgString(&inner_));
}

inline String StyleFontFamilyVecSlice::toDbgString() const {
    return String(AzStyleFontFamilyVecSlice_toDbgString(&inner_));
}

inline String StyleFilterVecSlice::toDbgString() const {
    return String(AzStyleFilterVecSlice_toDbgString(&inner_));
}

inline String StyleBackgroundSizeVecSlice::toDbgString() const {
    return String(AzStyleBackgroundSizeVecSlice_toDbgString(&inner_));
}

inline String StyleBackgroundContentVecSlice::toDbgString() const {
    return String(AzStyleBackgroundContentVecSlice_toDbgString(&inner_));
}

inline String CssDeclarationVecSlice::toDbgString() const {
    return String(AzCssDeclarationVecSlice_toDbgString(&inner_));
}

inline String StyleBackgroundPositionVecSlice::toDbgString() const {
    return String(AzStyleBackgroundPositionVecSlice_toDbgString(&inner_));
}

inline String NormalizedLinearColorStopVecSlice::toDbgString() const {
    return String(AzNormalizedLinearColorStopVecSlice_toDbgString(&inner_));
}

inline String CssPropertyWithConditionsVecSlice::toDbgString() const {
    return String(AzCssPropertyWithConditionsVecSlice_toDbgString(&inner_));
}

inline String CssVecSlice::toDbgString() const {
    return String(AzCssVecSlice_toDbgString(&inner_));
}

inline String StyleTransformVecSlice::toDbgString() const {
    return String(AzStyleTransformVecSlice_toDbgString(&inner_));
}

inline String StyledNodeVecSlice::toDbgString() const {
    return String(AzStyledNodeVecSlice_toDbgString(&inner_));
}

inline String ShapePointVecSlice::toDbgString() const {
    return String(AzShapePointVecSlice_toDbgString(&inner_));
}

inline String NamedFontVecSlice::toDbgString() const {
    return String(AzNamedFontVecSlice_toDbgString(&inner_));
}

inline String GridAreaDefinitionVecSlice::toDbgString() const {
    return String(AzGridAreaDefinitionVecSlice_toDbgString(&inner_));
}

inline SvgTransform SvgTransform::default_() {
    return SvgTransform(AzSvgTransform_default());
}

inline bool SvgTransform::partialEq(const SvgTransform& b) const {
    return AzSvgTransform_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgTransform::partialCmp(const SvgTransform& b) const {
    return AzSvgTransform_partialCmp(&inner_, b.ptr());
}

inline String SvgTransform::toDbgString() const {
    return String(AzSvgTransform_toDbgString(&inner_));
}

inline ScrollbarFadeDuration ScrollbarFadeDuration::default_() {
    return ScrollbarFadeDuration(AzScrollbarFadeDuration_default());
}

inline bool ScrollbarFadeDuration::partialEq(const ScrollbarFadeDuration& b) const {
    return AzScrollbarFadeDuration_partialEq(&inner_, b.ptr());
}

inline uint64_t ScrollbarFadeDuration::hash() const {
    return AzScrollbarFadeDuration_hash(&inner_);
}

inline uint8_t ScrollbarFadeDuration::partialCmp(const ScrollbarFadeDuration& b) const {
    return AzScrollbarFadeDuration_partialCmp(&inner_, b.ptr());
}

inline uint8_t ScrollbarFadeDuration::cmp(const ScrollbarFadeDuration& b) const {
    return AzScrollbarFadeDuration_cmp(&inner_, b.ptr());
}

inline String ScrollbarFadeDuration::toDbgString() const {
    return String(AzScrollbarFadeDuration_toDbgString(&inner_));
}

inline ScrollbarFadeDelay ScrollbarFadeDelay::default_() {
    return ScrollbarFadeDelay(AzScrollbarFadeDelay_default());
}

inline bool ScrollbarFadeDelay::partialEq(const ScrollbarFadeDelay& b) const {
    return AzScrollbarFadeDelay_partialEq(&inner_, b.ptr());
}

inline uint64_t ScrollbarFadeDelay::hash() const {
    return AzScrollbarFadeDelay_hash(&inner_);
}

inline uint8_t ScrollbarFadeDelay::partialCmp(const ScrollbarFadeDelay& b) const {
    return AzScrollbarFadeDelay_partialCmp(&inner_, b.ptr());
}

inline uint8_t ScrollbarFadeDelay::cmp(const ScrollbarFadeDelay& b) const {
    return AzScrollbarFadeDelay_cmp(&inner_, b.ptr());
}

inline String ScrollbarFadeDelay::toDbgString() const {
    return String(AzScrollbarFadeDelay_toDbgString(&inner_));
}

inline String U16VecSlice::toDbgString() const {
    return String(AzU16VecSlice_toDbgString(&inner_));
}

inline AudioMetrics AudioMetrics::default_() {
    return AudioMetrics(AzAudioMetrics_default());
}

inline bool AudioMetrics::partialEq(const AudioMetrics& b) const {
    return AzAudioMetrics_partialEq(&inner_, b.ptr());
}

inline String AudioMetrics::toDbgString() const {
    return String(AzAudioMetrics_toDbgString(&inner_));
}

inline ScrollPhysics ScrollPhysics::default_() {
    return ScrollPhysics(AzScrollPhysics_default());
}

inline void ScrollPhysics::delete_() {
    AzScrollPhysics_delete(&inner_);
}

inline ScrollPhysics ScrollPhysics::clone() const {
    return ScrollPhysics(AzScrollPhysics_clone(&inner_));
}

inline bool ScrollPhysics::partialEq(const ScrollPhysics& b) const {
    return AzScrollPhysics_partialEq(&inner_, b.ptr());
}

inline uint8_t ScrollPhysics::partialCmp(const ScrollPhysics& b) const {
    return AzScrollPhysics_partialCmp(&inner_, b.ptr());
}

inline String ScrollPhysics::toDbgString() const {
    return String(AzScrollPhysics_toDbgString(&inner_));
}

inline String CalcAstItemVecSlice::toDbgString() const {
    return String(AzCalcAstItemVecSlice_toDbgString(&inner_));
}

inline bool MinMaxRange::partialEq(const MinMaxRange& b) const {
    return AzMinMaxRange_partialEq(&inner_, b.ptr());
}

inline uint8_t MinMaxRange::partialCmp(const MinMaxRange& b) const {
    return AzMinMaxRange_partialCmp(&inner_, b.ptr());
}

inline String MinMaxRange::toDbgString() const {
    return String(AzMinMaxRange_toDbgString(&inner_));
}

inline bool AspectRatioValue::partialEq(const AspectRatioValue& b) const {
    return AzAspectRatioValue_partialEq(&inner_, b.ptr());
}

inline uint64_t AspectRatioValue::hash() const {
    return AzAspectRatioValue_hash(&inner_);
}

inline uint8_t AspectRatioValue::partialCmp(const AspectRatioValue& b) const {
    return AzAspectRatioValue_partialCmp(&inner_, b.ptr());
}

inline uint8_t AspectRatioValue::cmp(const AspectRatioValue& b) const {
    return AzAspectRatioValue_cmp(&inner_, b.ptr());
}

inline String AspectRatioValue::toDbgString() const {
    return String(AzAspectRatioValue_toDbgString(&inner_));
}

inline String F32VecSlice::toDbgString() const {
    return String(AzF32VecSlice_toDbgString(&inner_));
}

inline EmptyStruct EmptyStruct::create() {
    return EmptyStruct(AzEmptyStruct_create());
}

inline EmptyStruct EmptyStruct::default_() {
    return EmptyStruct(AzEmptyStruct_default());
}

inline bool EmptyStruct::partialEq(const EmptyStruct& b) const {
    return AzEmptyStruct_partialEq(&inner_, b.ptr());
}

inline uint64_t EmptyStruct::hash() const {
    return AzEmptyStruct_hash(&inner_);
}

inline uint8_t EmptyStruct::partialCmp(const EmptyStruct& b) const {
    return AzEmptyStruct_partialCmp(&inner_, b.ptr());
}

inline uint8_t EmptyStruct::cmp(const EmptyStruct& b) const {
    return AzEmptyStruct_cmp(&inner_, b.ptr());
}

inline String EmptyStruct::toDbgString() const {
    return String(AzEmptyStruct_toDbgString(&inner_));
}

inline String U32VecSlice::toDbgString() const {
    return String(AzU32VecSlice_toDbgString(&inner_));
}

inline String DynamicSelectorVecSlice::toDbgString() const {
    return String(AzDynamicSelectorVecSlice_toDbgString(&inner_));
}

inline String U8VecSlice::toDbgString() const {
    return String(AzU8VecSlice_toDbgString(&inner_));
}

inline bool MapTileId::partialEq(const MapTileId& b) const {
    return AzMapTileId_partialEq(&inner_, b.ptr());
}

inline uint64_t MapTileId::hash() const {
    return AzMapTileId_hash(&inner_);
}

inline uint8_t MapTileId::partialCmp(const MapTileId& b) const {
    return AzMapTileId_partialCmp(&inner_, b.ptr());
}

inline uint8_t MapTileId::cmp(const MapTileId& b) const {
    return AzMapTileId_cmp(&inner_, b.ptr());
}

inline String MapTileId::toDbgString() const {
    return String(AzMapTileId_toDbgString(&inner_));
}

inline MapViewport MapViewport::default_() {
    return MapViewport(AzMapViewport_default());
}

inline bool MapViewport::partialEq(const MapViewport& b) const {
    return AzMapViewport_partialEq(&inner_, b.ptr());
}

inline String MapViewport::toDbgString() const {
    return String(AzMapViewport_toDbgString(&inner_));
}

inline CheckBoxState CheckBoxState::default_() {
    return CheckBoxState(AzCheckBoxState_default());
}

inline void CheckBoxState::delete_() {
    AzCheckBoxState_delete(&inner_);
}

inline CheckBoxState CheckBoxState::clone() const {
    return CheckBoxState(AzCheckBoxState_clone(&inner_));
}

inline bool CheckBoxState::partialEq(const CheckBoxState& b) const {
    return AzCheckBoxState_partialEq(&inner_, b.ptr());
}

inline String CheckBoxState::toDbgString() const {
    return String(AzCheckBoxState_toDbgString(&inner_));
}

inline NumberInputState NumberInputState::default_() {
    return NumberInputState(AzNumberInputState_default());
}

inline void NumberInputState::delete_() {
    AzNumberInputState_delete(&inner_);
}

inline NumberInputState NumberInputState::clone() const {
    return NumberInputState(AzNumberInputState_clone(&inner_));
}

inline bool NumberInputState::partialEq(const NumberInputState& b) const {
    return AzNumberInputState_partialEq(&inner_, b.ptr());
}

inline String NumberInputState::toDbgString() const {
    return String(AzNumberInputState_toDbgString(&inner_));
}

inline void ProgressBarState::delete_() {
    AzProgressBarState_delete(&inner_);
}

inline ProgressBarState ProgressBarState::clone() const {
    return ProgressBarState(AzProgressBarState_clone(&inner_));
}

inline String ProgressBarState::toDbgString() const {
    return String(AzProgressBarState_toDbgString(&inner_));
}

inline bool TabHeaderState::partialEq(const TabHeaderState& b) const {
    return AzTabHeaderState_partialEq(&inner_, b.ptr());
}

inline String TabHeaderState::toDbgString() const {
    return String(AzTabHeaderState_toDbgString(&inner_));
}

inline String ListViewRowVecSlice::toDbgString() const {
    return String(AzListViewRowVecSlice_toDbgString(&inner_));
}

inline TitlebarButtons TitlebarButtons::default_() {
    return TitlebarButtons(AzTitlebarButtons_default());
}

inline bool TitlebarButtons::partialEq(const TitlebarButtons& b) const {
    return AzTitlebarButtons_partialEq(&inner_, b.ptr());
}

inline uint64_t TitlebarButtons::hash() const {
    return AzTitlebarButtons_hash(&inner_);
}

inline uint8_t TitlebarButtons::partialCmp(const TitlebarButtons& b) const {
    return AzTitlebarButtons_partialCmp(&inner_, b.ptr());
}

inline uint8_t TitlebarButtons::cmp(const TitlebarButtons& b) const {
    return AzTitlebarButtons_cmp(&inner_, b.ptr());
}

inline String TitlebarButtons::toDbgString() const {
    return String(AzTitlebarButtons_toDbgString(&inner_));
}

inline String RibbonSectionVecSlice::toDbgString() const {
    return String(AzRibbonSectionVecSlice_toDbgString(&inner_));
}

inline String RibbonTabVecSlice::toDbgString() const {
    return String(AzRibbonTabVecSlice_toDbgString(&inner_));
}

inline String TreeViewNodeVecSlice::toDbgString() const {
    return String(AzTreeViewNodeVecSlice_toDbgString(&inner_));
}

inline bool MapLatLon::partialEq(const MapLatLon& b) const {
    return AzMapLatLon_partialEq(&inner_, b.ptr());
}

inline String MapLatLon::toDbgString() const {
    return String(AzMapLatLon_toDbgString(&inner_));
}

inline void GlVoidPtrConst::delete_() {
    AzGlVoidPtrConst_delete(&inner_);
}

inline GlVoidPtrConst GlVoidPtrConst::clone() const {
    return GlVoidPtrConst(AzGlVoidPtrConst_clone(&inner_));
}

inline String GlVoidPtrConst::toDbgString() const {
    return String(AzGlVoidPtrConst_toDbgString(&inner_));
}

inline void GlVoidPtrMut::delete_() {
    AzGlVoidPtrMut_delete(&inner_);
}

inline GlVoidPtrMut GlVoidPtrMut::clone() const {
    return GlVoidPtrMut(AzGlVoidPtrMut_clone(&inner_));
}

inline String GlVoidPtrMut::toDbgString() const {
    return String(AzGlVoidPtrMut_toDbgString(&inner_));
}

inline TextureFlags TextureFlags::default_() {
    return TextureFlags(AzTextureFlags_default());
}

inline bool TextureFlags::partialEq(const TextureFlags& b) const {
    return AzTextureFlags_partialEq(&inner_, b.ptr());
}

inline uint64_t TextureFlags::hash() const {
    return AzTextureFlags_hash(&inner_);
}

inline uint8_t TextureFlags::partialCmp(const TextureFlags& b) const {
    return AzTextureFlags_partialCmp(&inner_, b.ptr());
}

inline uint8_t TextureFlags::cmp(const TextureFlags& b) const {
    return AzTextureFlags_cmp(&inner_, b.ptr());
}

inline String TextureFlags::toDbgString() const {
    return String(AzTextureFlags_toDbgString(&inner_));
}

inline void GLsyncPtr::delete_() {
    AzGLsyncPtr_delete(&inner_);
}

inline GLsyncPtr GLsyncPtr::clone() const {
    return GLsyncPtr(AzGLsyncPtr_clone(&inner_));
}

inline String GLsyncPtr::toDbgString() const {
    return String(AzGLsyncPtr_toDbgString(&inner_));
}

inline bool SvgVertex::partialEq(const SvgVertex& b) const {
    return AzSvgVertex_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgVertex::partialCmp(const SvgVertex& b) const {
    return AzSvgVertex_partialCmp(&inner_, b.ptr());
}

inline String SvgVertex::toDbgString() const {
    return String(AzSvgVertex_toDbgString(&inner_));
}

inline String SvgVertexVecSlice::toDbgString() const {
    return String(AzSvgVertexVecSlice_toDbgString(&inner_));
}

inline String DebugMessageVecSlice::toDbgString() const {
    return String(AzDebugMessageVecSlice_toDbgString(&inner_));
}

inline ImageRef ImageRef::gl_texture(Texture texture) {
    return ImageRef(AzImageRef_glTexture(texture.release()));
}

inline ImageRef ImageRef::callback(CoreRenderImageCallback callback, RefAny data) {
    return ImageRef(AzImageRef_callback(callback.release(), data.release()));
}

inline ImageRef ImageRef::new_gltexture(Texture texture) {
    return ImageRef(AzImageRef_newGltexture(texture.release()));
}

inline ImageRef ImageRef::null_image(size_t width, size_t height, AzRawImageFormat format, U8VecRef tag) {
    return ImageRef(AzImageRef_nullImage(width, height, format, tag.release()));
}

inline OptionImageRef ImageRef::raw_image(RawImage data) {
    return OptionImageRef(AzImageRef_rawImage(data.release()));
}

inline OptionImageRef ImageRef::new_rawimage(RawImage image_data) {
    return OptionImageRef(AzImageRef_newRawimage(image_data.release()));
}

inline bool ImageRef::is_invalid() const {
    return AzImageRef_isInvalid(&inner_);
}

inline bool ImageRef::is_gl_texture() const {
    return AzImageRef_isGlTexture(&inner_);
}

inline bool ImageRef::is_raw_image() const {
    return AzImageRef_isRawImage(&inner_);
}

inline bool ImageRef::is_callback() const {
    return AzImageRef_isCallback(&inner_);
}

inline OptionRawImage ImageRef::get_raw_image() const {
    return OptionRawImage(AzImageRef_getRawImage(&inner_));
}

inline bool ImageRef::is_null_image() const {
    return AzImageRef_isNullImage(&inner_);
}

inline OptionRawImage ImageRef::get_rawimage() const {
    return OptionRawImage(AzImageRef_getRawimage(&inner_));
}

inline OptionU8VecRef ImageRef::get_bytes() const {
    return OptionU8VecRef(AzImageRef_getBytes(&inner_));
}

inline LogicalSize ImageRef::get_size() const {
    return LogicalSize(AzImageRef_getSize(&inner_));
}

inline ImageRefHash ImageRef::get_hash() const {
    return ImageRefHash(AzImageRef_getHash(&inner_));
}

inline OptionCoreImageCallback ImageRef::get_image_callback() const {
    return OptionCoreImageCallback(AzImageRef_getImageCallback(&inner_));
}

inline OptionCoreImageCallback ImageRef::get_image_callback_mut() {
    return OptionCoreImageCallback(AzImageRef_getImageCallbackMut(&inner_));
}

inline ImageRef ImageRef::deep_copy() const {
    return ImageRef(AzImageRef_deepCopy(&inner_));
}

inline const uint8_t* ImageRef::get_bytes_ptr() const {
    return AzImageRef_getBytesPtr(&inner_);
}

inline void ImageRef::delete_() {
    AzImageRef_delete(&inner_);
}

inline ImageRef ImageRef::clone() const {
    return ImageRef(AzImageRef_clone(&inner_));
}

inline bool ImageRef::partialEq(const ImageRef& b) const {
    return AzImageRef_partialEq(&inner_, b.ptr());
}

inline uint64_t ImageRef::hash() const {
    return AzImageRef_hash(&inner_);
}

inline uint8_t ImageRef::partialCmp(const ImageRef& b) const {
    return AzImageRef_partialCmp(&inner_, b.ptr());
}

inline uint8_t ImageRef::cmp(const ImageRef& b) const {
    return AzImageRef_cmp(&inner_, b.ptr());
}

inline String ImageRef::toDbgString() const {
    return String(AzImageRef_toDbgString(&inner_));
}

inline bool ImageDescriptorFlags::partialEq(const ImageDescriptorFlags& b) const {
    return AzImageDescriptorFlags_partialEq(&inner_, b.ptr());
}

inline uint64_t ImageDescriptorFlags::hash() const {
    return AzImageDescriptorFlags_hash(&inner_);
}

inline uint8_t ImageDescriptorFlags::partialCmp(const ImageDescriptorFlags& b) const {
    return AzImageDescriptorFlags_partialCmp(&inner_, b.ptr());
}

inline uint8_t ImageDescriptorFlags::cmp(const ImageDescriptorFlags& b) const {
    return AzImageDescriptorFlags_cmp(&inner_, b.ptr());
}

inline String ImageDescriptorFlags::toDbgString() const {
    return String(AzImageDescriptorFlags_toDbgString(&inner_));
}

inline bool ImageRefHash::partialEq(const ImageRefHash& b) const {
    return AzImageRefHash_partialEq(&inner_, b.ptr());
}

inline uint64_t ImageRefHash::hash() const {
    return AzImageRefHash_hash(&inner_);
}

inline uint8_t ImageRefHash::partialCmp(const ImageRefHash& b) const {
    return AzImageRefHash_partialCmp(&inner_, b.ptr());
}

inline uint8_t ImageRefHash::cmp(const ImageRefHash& b) const {
    return AzImageRefHash_cmp(&inner_, b.ptr());
}

inline String ImageRefHash::toDbgString() const {
    return String(AzImageRefHash_toDbgString(&inner_));
}

inline String RouteVecSlice::toDbgString() const {
    return String(AzRouteVecSlice_toDbgString(&inner_));
}

inline VideoEncoder VideoEncoder::open(uint32_t width, uint32_t height, bool h265, uint32_t bitrate_kbps) {
    return VideoEncoder(AzVideoEncoder_open(width, height, h265, bitrate_kbps));
}

inline VideoEncoder VideoEncoder::default_() {
    return VideoEncoder(AzVideoEncoder_default());
}

inline String VideoEncoder::backend_name() {
    return String(AzVideoEncoder_backendName());
}

inline bool VideoEncoder::is_open() const {
    return AzVideoEncoder_isOpen(&inner_);
}

inline U8Vec VideoEncoder::encode(VideoFrame frame, bool force_keyframe) const {
    return U8Vec(AzVideoEncoder_encode(&inner_, frame.release(), force_keyframe));
}

inline uint64_t VideoEncoder::frames_encoded() const {
    return AzVideoEncoder_framesEncoded(&inner_);
}

inline void VideoEncoder::close() {
    AzVideoEncoder_close(&inner_);
}

inline void VideoEncoder::delete_() {
    AzVideoEncoder_delete(&inner_);
}

inline VideoEncoder VideoEncoder::clone() const {
    return VideoEncoder(AzVideoEncoder_clone(&inner_));
}

inline VideoDecoder VideoDecoder::open(bool h265) {
    return VideoDecoder(AzVideoDecoder_open(h265));
}

inline VideoDecoder VideoDecoder::default_() {
    return VideoDecoder(AzVideoDecoder_default());
}

inline bool VideoDecoder::is_open() const {
    return AzVideoDecoder_isOpen(&inner_);
}

inline OptionVideoFrame VideoDecoder::decode(U8Vec data) const {
    return OptionVideoFrame(AzVideoDecoder_decode(&inner_, data.release()));
}

inline void VideoDecoder::close() {
    AzVideoDecoder_close(&inner_);
}

inline void VideoDecoder::delete_() {
    AzVideoDecoder_delete(&inner_);
}

inline VideoDecoder VideoDecoder::clone() const {
    return VideoDecoder(AzVideoDecoder_clone(&inner_));
}

inline Panose Panose::default_() {
    return Panose(AzPanose_default());
}

inline bool Panose::partialEq(const Panose& b) const {
    return AzPanose_partialEq(&inner_, b.ptr());
}

inline uint64_t Panose::hash() const {
    return AzPanose_hash(&inner_);
}

inline uint8_t Panose::partialCmp(const Panose& b) const {
    return AzPanose_partialCmp(&inner_, b.ptr());
}

inline uint8_t Panose::cmp(const Panose& b) const {
    return AzPanose_cmp(&inner_, b.ptr());
}

inline String Panose::toDbgString() const {
    return String(AzPanose_toDbgString(&inner_));
}

inline String LoadedFontVecSlice::toDbgString() const {
    return String(AzLoadedFontVecSlice_toDbgString(&inner_));
}

inline ResultSvgSvgParseError Svg::from_string(String svg_string, SvgParseOptions parse_options) {
    return ResultSvgSvgParseError(AzSvg_fromString(svg_string.release(), parse_options.release()));
}

inline ResultSvgSvgParseError Svg::from_bytes(U8VecRef svg_bytes, SvgParseOptions parse_options) {
    return ResultSvgSvgParseError(AzSvg_fromBytes(svg_bytes.release(), parse_options.release()));
}

inline void Svg::delete_() {
    AzSvg_delete(&inner_);
}

inline Svg Svg::clone() const {
    return Svg(AzSvg_clone(&inner_));
}

inline String Svg::toDbgString() const {
    return String(AzSvg_toDbgString(&inner_));
}

inline String CssPathSelectorVecSlice::toDbgString() const {
    return String(AzCssPathSelectorVecSlice_toDbgString(&inner_));
}

inline bool SvgDashPattern::partialEq(const SvgDashPattern& b) const {
    return AzSvgDashPattern_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgDashPattern::partialCmp(const SvgDashPattern& b) const {
    return AzSvgDashPattern_partialCmp(&inner_, b.ptr());
}

inline String SvgDashPattern::toDbgString() const {
    return String(AzSvgDashPattern_toDbgString(&inner_));
}

inline double SvgVector::angle_degrees() const {
    return AzSvgVector_angleDegrees(&inner_);
}

inline SvgVector SvgVector::rotate_90deg_ccw() const {
    return SvgVector(AzSvgVector_rotate90degCcw(&inner_));
}

inline bool SvgVector::partialEq(const SvgVector& b) const {
    return AzSvgVector_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgVector::partialCmp(const SvgVector& b) const {
    return AzSvgVector_partialCmp(&inner_, b.ptr());
}

inline String SvgVector::toDbgString() const {
    return String(AzSvgVector_toDbgString(&inner_));
}

inline SvgRect SvgRect::default_() {
    return SvgRect(AzSvgRect_default());
}

inline SvgRect SvgRect::expand(float padding_top, float padding_bottom, float padding_left, float padding_right) const {
    return SvgRect(AzSvgRect_expand(&inner_, padding_top, padding_bottom, padding_left, padding_right));
}

inline SvgPoint SvgRect::get_center() const {
    return SvgPoint(AzSvgRect_getCenter(&inner_));
}

inline bool SvgRect::partialEq(const SvgRect& b) const {
    return AzSvgRect_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgRect::partialCmp(const SvgRect& b) const {
    return AzSvgRect_partialCmp(&inner_, b.ptr());
}

inline String SvgRect::toDbgString() const {
    return String(AzSvgRect_toDbgString(&inner_));
}

inline SvgPoint SvgPoint::default_() {
    return SvgPoint(AzSvgPoint_default());
}

inline bool SvgPoint::partialEq(const SvgPoint& b) const {
    return AzSvgPoint_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgPoint::partialCmp(const SvgPoint& b) const {
    return AzSvgPoint_partialCmp(&inner_, b.ptr());
}

inline String SvgPoint::toDbgString() const {
    return String(AzSvgPoint_toDbgString(&inner_));
}

inline String SvgPathVecSlice::toDbgString() const {
    return String(AzSvgPathVecSlice_toDbgString(&inner_));
}

inline String SvgPathElementVecSlice::toDbgString() const {
    return String(AzSvgPathElementVecSlice_toDbgString(&inner_));
}

inline double SystemTickDiff::div(SystemTickDiff other) const {
    return AzSystemTickDiff_div(&inner_, other.release());
}

inline bool SystemTickDiff::partialEq(const SystemTickDiff& b) const {
    return AzSystemTickDiff_partialEq(&inner_, b.ptr());
}

inline uint64_t SystemTickDiff::hash() const {
    return AzSystemTickDiff_hash(&inner_);
}

inline uint8_t SystemTickDiff::partialCmp(const SystemTickDiff& b) const {
    return AzSystemTickDiff_partialCmp(&inner_, b.ptr());
}

inline uint8_t SystemTickDiff::cmp(const SystemTickDiff& b) const {
    return AzSystemTickDiff_cmp(&inner_, b.ptr());
}

inline String SystemTickDiff::toDbgString() const {
    return String(AzSystemTickDiff_toDbgString(&inner_));
}

inline bool SystemTick::partialEq(const SystemTick& b) const {
    return AzSystemTick_partialEq(&inner_, b.ptr());
}

inline uint64_t SystemTick::hash() const {
    return AzSystemTick_hash(&inner_);
}

inline uint8_t SystemTick::partialCmp(const SystemTick& b) const {
    return AzSystemTick_partialCmp(&inner_, b.ptr());
}

inline uint8_t SystemTick::cmp(const SystemTick& b) const {
    return AzSystemTick_cmp(&inner_, b.ptr());
}

inline String SystemTick::toDbgString() const {
    return String(AzSystemTick_toDbgString(&inner_));
}

inline SystemTimeDiff SystemTimeDiff::from_secs(uint64_t secs) {
    return SystemTimeDiff(AzSystemTimeDiff_fromSecs(secs));
}

inline SystemTimeDiff SystemTimeDiff::from_millis(uint64_t millis) {
    return SystemTimeDiff(AzSystemTimeDiff_fromMillis(millis));
}

inline SystemTimeDiff SystemTimeDiff::from_nanos(uint64_t nanos) {
    return SystemTimeDiff(AzSystemTimeDiff_fromNanos(nanos));
}

inline uint64_t SystemTimeDiff::millis() const {
    return AzSystemTimeDiff_millis(&inner_);
}

inline double SystemTimeDiff::div(SystemTimeDiff other) const {
    return AzSystemTimeDiff_div(&inner_, other.release());
}

inline bool SystemTimeDiff::partialEq(const SystemTimeDiff& b) const {
    return AzSystemTimeDiff_partialEq(&inner_, b.ptr());
}

inline uint64_t SystemTimeDiff::hash() const {
    return AzSystemTimeDiff_hash(&inner_);
}

inline uint8_t SystemTimeDiff::partialCmp(const SystemTimeDiff& b) const {
    return AzSystemTimeDiff_partialCmp(&inner_, b.ptr());
}

inline uint8_t SystemTimeDiff::cmp(const SystemTimeDiff& b) const {
    return AzSystemTimeDiff_cmp(&inner_, b.ptr());
}

inline String SystemTimeDiff::toDbgString() const {
    return String(AzSystemTimeDiff_toDbgString(&inner_));
}

inline CssDuration CssDuration::default_() {
    return CssDuration(AzCssDuration_default());
}

inline bool CssDuration::partialEq(const CssDuration& b) const {
    return AzCssDuration_partialEq(&inner_, b.ptr());
}

inline uint64_t CssDuration::hash() const {
    return AzCssDuration_hash(&inner_);
}

inline uint8_t CssDuration::partialCmp(const CssDuration& b) const {
    return AzCssDuration_partialCmp(&inner_, b.ptr());
}

inline uint8_t CssDuration::cmp(const CssDuration& b) const {
    return AzCssDuration_cmp(&inner_, b.ptr());
}

inline String CssDuration::toDbgString() const {
    return String(AzCssDuration_toDbgString(&inner_));
}

inline bool IcuTime::partialEq(const IcuTime& b) const {
    return AzIcuTime_partialEq(&inner_, b.ptr());
}

inline String IcuTime::toDbgString() const {
    return String(AzIcuTime_toDbgString(&inner_));
}

inline String StringPairVecSlice::toDbgString() const {
    return String(AzStringPairVecSlice_toDbgString(&inner_));
}

inline String StringVecSlice::toDbgString() const {
    return String(AzStringVecSlice_toDbgString(&inner_));
}

inline void GLbooleanVecRefMut::delete_() {
    AzGLbooleanVecRefMut_delete(&inner_);
}

inline GLbooleanVecRefMut GLbooleanVecRefMut::clone() const {
    return GLbooleanVecRefMut(AzGLbooleanVecRefMut_clone(&inner_));
}

inline String GLbooleanVecRefMut::toDbgString() const {
    return String(AzGLbooleanVecRefMut_toDbgString(&inner_));
}

inline void GLfloatVecRefMut::delete_() {
    AzGLfloatVecRefMut_delete(&inner_);
}

inline GLfloatVecRefMut GLfloatVecRefMut::clone() const {
    return GLfloatVecRefMut(AzGLfloatVecRefMut_clone(&inner_));
}

inline String GLfloatVecRefMut::toDbgString() const {
    return String(AzGLfloatVecRefMut_toDbgString(&inner_));
}

inline void U8VecRefMut::delete_() {
    AzU8VecRefMut_delete(&inner_);
}

inline U8VecRefMut U8VecRefMut::clone() const {
    return U8VecRefMut(AzU8VecRefMut_clone(&inner_));
}

inline String U8VecRefMut::toDbgString() const {
    return String(AzU8VecRefMut_toDbgString(&inner_));
}

inline void TessellatedSvgNodeVecRef::delete_() {
    AzTessellatedSvgNodeVecRef_delete(&inner_);
}

inline TessellatedSvgNodeVecRef TessellatedSvgNodeVecRef::clone() const {
    return TessellatedSvgNodeVecRef(AzTessellatedSvgNodeVecRef_clone(&inner_));
}

inline String TessellatedSvgNodeVecRef::toDbgString() const {
    return String(AzTessellatedSvgNodeVecRef_toDbgString(&inner_));
}

inline void F32VecRef::delete_() {
    AzF32VecRef_delete(&inner_);
}

inline F32VecRef F32VecRef::clone() const {
    return F32VecRef(AzF32VecRef_clone(&inner_));
}

inline String F32VecRef::toDbgString() const {
    return String(AzF32VecRef_toDbgString(&inner_));
}

inline void GLuintVecRef::delete_() {
    AzGLuintVecRef_delete(&inner_);
}

inline GLuintVecRef GLuintVecRef::clone() const {
    return GLuintVecRef(AzGLuintVecRef_clone(&inner_));
}

inline String GLuintVecRef::toDbgString() const {
    return String(AzGLuintVecRef_toDbgString(&inner_));
}

inline void I32VecRef::delete_() {
    AzI32VecRef_delete(&inner_);
}

inline I32VecRef I32VecRef::clone() const {
    return I32VecRef(AzI32VecRef_clone(&inner_));
}

inline String I32VecRef::toDbgString() const {
    return String(AzI32VecRef_toDbgString(&inner_));
}

inline void U8VecRef::delete_() {
    AzU8VecRef_delete(&inner_);
}

inline U8VecRef U8VecRef::clone() const {
    return U8VecRef(AzU8VecRef_clone(&inner_));
}

inline bool U8VecRef::partialEq(const U8VecRef& b) const {
    return AzU8VecRef_partialEq(&inner_, b.ptr());
}

inline uint64_t U8VecRef::hash() const {
    return AzU8VecRef_hash(&inner_);
}

inline uint8_t U8VecRef::partialCmp(const U8VecRef& b) const {
    return AzU8VecRef_partialCmp(&inner_, b.ptr());
}

inline uint8_t U8VecRef::cmp(const U8VecRef& b) const {
    return AzU8VecRef_cmp(&inner_, b.ptr());
}

inline String U8VecRef::toDbgString() const {
    return String(AzU8VecRef_toDbgString(&inner_));
}

inline void GLintVecRefMut::delete_() {
    AzGLintVecRefMut_delete(&inner_);
}

inline GLintVecRefMut GLintVecRefMut::clone() const {
    return GLintVecRefMut(AzGLintVecRefMut_clone(&inner_));
}

inline String GLintVecRefMut::toDbgString() const {
    return String(AzGLintVecRefMut_toDbgString(&inner_));
}

inline void GLenumVecRef::delete_() {
    AzGLenumVecRef_delete(&inner_);
}

inline GLenumVecRef GLenumVecRef::clone() const {
    return GLenumVecRef(AzGLenumVecRef_clone(&inner_));
}

inline String GLenumVecRef::toDbgString() const {
    return String(AzGLenumVecRef_toDbgString(&inner_));
}

inline void GLint64VecRefMut::delete_() {
    AzGLint64VecRefMut_delete(&inner_);
}

inline GLint64VecRefMut GLint64VecRefMut::clone() const {
    return GLint64VecRefMut(AzGLint64VecRefMut_clone(&inner_));
}

inline String GLint64VecRefMut::toDbgString() const {
    return String(AzGLint64VecRefMut_toDbgString(&inner_));
}

inline void RefstrVecRef::delete_() {
    AzRefstrVecRef_delete(&inner_);
}

inline RefstrVecRef RefstrVecRef::clone() const {
    return RefstrVecRef(AzRefstrVecRef_clone(&inner_));
}

inline String RefstrVecRef::toDbgString() const {
    return String(AzRefstrVecRef_toDbgString(&inner_));
}

inline void HttpResponseTooLargeError::delete_() {
    AzHttpResponseTooLargeError_delete(&inner_);
}

inline HttpResponseTooLargeError HttpResponseTooLargeError::clone() const {
    return HttpResponseTooLargeError(AzHttpResponseTooLargeError_clone(&inner_));
}

inline bool HttpResponseTooLargeError::partialEq(const HttpResponseTooLargeError& b) const {
    return AzHttpResponseTooLargeError_partialEq(&inner_, b.ptr());
}

inline String HttpResponseTooLargeError::toDbgString() const {
    return String(AzHttpResponseTooLargeError_toDbgString(&inner_));
}

inline ErrorLocation ErrorLocation::default_() {
    return ErrorLocation(AzErrorLocation_default());
}

inline bool ErrorLocation::partialEq(const ErrorLocation& b) const {
    return AzErrorLocation_partialEq(&inner_, b.ptr());
}

inline uint64_t ErrorLocation::hash() const {
    return AzErrorLocation_hash(&inner_);
}

inline uint8_t ErrorLocation::partialCmp(const ErrorLocation& b) const {
    return AzErrorLocation_partialCmp(&inner_, b.ptr());
}

inline uint8_t ErrorLocation::cmp(const ErrorLocation& b) const {
    return AzErrorLocation_cmp(&inner_, b.ptr());
}

inline String ErrorLocation::toDbgString() const {
    return String(AzErrorLocation_toDbgString(&inner_));
}

inline bool CssSyntaxErrorPos::partialEq(const CssSyntaxErrorPos& b) const {
    return AzCssSyntaxErrorPos_partialEq(&inner_, b.ptr());
}

inline String CssSyntaxErrorPos::toDbgString() const {
    return String(AzCssSyntaxErrorPos_toDbgString(&inner_));
}

inline App App::create(RefAny initial_data, AppConfig app_config) {
    return App(AzApp_create(initial_data.release(), app_config.release()));
}

inline App App::default_() {
    return App(AzApp_default());
}

inline void App::add_window(WindowCreateOptions create_options) {
    AzApp_addWindow(&inner_, create_options.release());
}

inline MonitorVec App::get_monitors() const {
    return MonitorVec(AzApp_getMonitors(&inner_));
}

inline void App::run(WindowCreateOptions root_window) const {
    AzApp_run(&inner_, root_window.release());
}

inline void App::delete_() {
    AzApp_delete(&inner_);
}

inline App App::clone() const {
    return App(AzApp_clone(&inner_));
}

inline String App::toDbgString() const {
    return String(AzApp_toDbgString(&inner_));
}

inline TimerId TimerId::unique() {
    return TimerId(AzTimerId_unique());
}

inline bool TimerId::partialEq(const TimerId& b) const {
    return AzTimerId_partialEq(&inner_, b.ptr());
}

inline uint64_t TimerId::hash() const {
    return AzTimerId_hash(&inner_);
}

inline uint8_t TimerId::partialCmp(const TimerId& b) const {
    return AzTimerId_partialCmp(&inner_, b.ptr());
}

inline uint8_t TimerId::cmp(const TimerId& b) const {
    return AzTimerId_cmp(&inner_, b.ptr());
}

inline String TimerId::toDbgString() const {
    return String(AzTimerId_toDbgString(&inner_));
}

inline Thread Thread::create(RefAny thread_initialize_data, RefAny writeback_data, AzThreadCallbackType callback) {
    return Thread(AzThread_create(thread_initialize_data.release(), writeback_data.release(), callback));
}

inline EmptyStruct Thread::sleep_ms(uint64_t milliseconds) {
    return EmptyStruct(AzThread_sleepMs(milliseconds));
}

inline EmptyStruct Thread::sleep_us(uint64_t microseconds) {
    return EmptyStruct(AzThread_sleepUs(microseconds));
}

inline EmptyStruct Thread::sleep_ns(uint64_t nanoseconds) {
    return EmptyStruct(AzThread_sleepNs(nanoseconds));
}

inline void Thread::delete_() {
    AzThread_delete(&inner_);
}

inline Thread Thread::clone() const {
    return Thread(AzThread_clone(&inner_));
}

inline String Thread::toDbgString() const {
    return String(AzThread_toDbgString(&inner_));
}

inline ThreadId ThreadId::unique() {
    return ThreadId(AzThreadId_unique());
}

inline bool ThreadId::partialEq(const ThreadId& b) const {
    return AzThreadId_partialEq(&inner_, b.ptr());
}

inline uint64_t ThreadId::hash() const {
    return AzThreadId_hash(&inner_);
}

inline uint8_t ThreadId::partialCmp(const ThreadId& b) const {
    return AzThreadId_partialCmp(&inner_, b.ptr());
}

inline uint8_t ThreadId::cmp(const ThreadId& b) const {
    return AzThreadId_cmp(&inner_, b.ptr());
}

inline String ThreadId::toDbgString() const {
    return String(AzThreadId_toDbgString(&inner_));
}

inline String TimerIdVecSlice::toDbgString() const {
    return String(AzTimerIdVecSlice_toDbgString(&inner_));
}

inline String ThreadIdVecSlice::toDbgString() const {
    return String(AzThreadIdVecSlice_toDbgString(&inner_));
}

inline String ExternalResourceVecSlice::toDbgString() const {
    return String(AzExternalResourceVecSlice_toDbgString(&inner_));
}

inline String DirEntryVecSlice::toDbgString() const {
    return String(AzDirEntryVecSlice_toDbgString(&inner_));
}

inline String FmtArgVecSlice::toDbgString() const {
    return String(AzFmtArgVecSlice_toDbgString(&inner_));
}

inline String JsonKeyValueVecSlice::toDbgString() const {
    return String(AzJsonKeyValueVecSlice_toDbgString(&inner_));
}

inline String JsonVecSlice::toDbgString() const {
    return String(AzJsonVecSlice_toDbgString(&inner_));
}

inline Db Db::open(String path) {
    return Db(AzDb_open(path.release()));
}

inline Db Db::default_() {
    return Db(AzDb_default());
}

inline bool Db::is_open() const {
    return AzDb_isOpen(&inner_);
}

inline size_t Db::execute(String sql, DbValueVec params) const {
    return AzDb_execute(&inner_, sql.release(), params.release());
}

inline DbRows Db::query(String sql, DbValueVec params) const {
    return DbRows(AzDb_query(&inner_, sql.release(), params.release()));
}

inline void Db::delete_() {
    AzDb_delete(&inner_);
}

inline Db Db::clone() const {
    return Db(AzDb_clone(&inner_));
}

inline String Db::toDbgString() const {
    return String(AzDb_toDbgString(&inner_));
}

inline Pdf Pdf::new_() {
    return Pdf(AzPdf_new());
}

inline Pdf Pdf::default_() {
    return Pdf(AzPdf_default());
}

inline U8Vec Pdf::write_json(Json json) const {
    return U8Vec(AzPdf_writeJson(&inner_, json.release()));
}

inline Json Pdf::read_json(U8Vec bytes) const {
    return Json(AzPdf_readJson(&inner_, bytes.release()));
}

inline U8Vec Pdf::from_dom(Dom dom, float page_width_px, float page_height_px) const {
    return U8Vec(AzPdf_fromDom(&inner_, dom.release(), page_width_px, page_height_px));
}

inline bool Pdf::partialEq(const Pdf& b) const {
    return AzPdf_partialEq(&inner_, b.ptr());
}

inline String Pdf::toDbgString() const {
    return String(AzPdf_toDbgString(&inner_));
}

inline bool GamepadId::partialEq(const GamepadId& b) const {
    return AzGamepadId_partialEq(&inner_, b.ptr());
}

inline uint64_t GamepadId::hash() const {
    return AzGamepadId_hash(&inner_);
}

inline uint8_t GamepadId::partialCmp(const GamepadId& b) const {
    return AzGamepadId_partialCmp(&inner_, b.ptr());
}

inline uint8_t GamepadId::cmp(const GamepadId& b) const {
    return AzGamepadId_cmp(&inner_, b.ptr());
}

inline String GamepadId::toDbgString() const {
    return String(AzGamepadId_toDbgString(&inner_));
}

inline WacomPadState WacomPadState::default_() {
    return WacomPadState(AzWacomPadState_default());
}

inline bool WacomPadState::partialEq(const WacomPadState& b) const {
    return AzWacomPadState_partialEq(&inner_, b.ptr());
}

inline String WacomPadState::toDbgString() const {
    return String(AzWacomPadState_toDbgString(&inner_));
}

inline AudioConfig AudioConfig::default_() {
    return AudioConfig(AzAudioConfig_default());
}

inline bool AudioConfig::partialEq(const AudioConfig& b) const {
    return AzAudioConfig_partialEq(&inner_, b.ptr());
}

inline uint64_t AudioConfig::hash() const {
    return AzAudioConfig_hash(&inner_);
}

inline String AudioConfig::toDbgString() const {
    return String(AzAudioConfig_toDbgString(&inner_));
}

inline Udp Udp::bind(String local_addr) {
    return Udp(AzUdp_bind(local_addr.release()));
}

inline Udp Udp::default_() {
    return Udp(AzUdp_default());
}

inline void Udp::close() {
    AzUdp_close(&inner_);
}

inline size_t Udp::send_to(String remote_addr, U8Vec data) const {
    return AzUdp_sendTo(&inner_, remote_addr.release(), data.release());
}

inline OptionU8Vec Udp::recv() const {
    return OptionU8Vec(AzUdp_recv(&inner_));
}

inline bool Udp::is_open() const {
    return AzUdp_isOpen(&inner_);
}

inline String Udp::local_addr() const {
    return String(AzUdp_localAddr(&inner_));
}

inline size_t Udp::send_chunked(String remote_addr, U8Vec data) const {
    return AzUdp_sendChunked(&inner_, remote_addr.release(), data.release());
}

inline OptionU8Vec Udp::recv_chunked() const {
    return OptionU8Vec(AzUdp_recvChunked(&inner_));
}

inline void Udp::delete_() {
    AzUdp_delete(&inner_);
}

inline Udp Udp::clone() const {
    return Udp(AzUdp_clone(&inner_));
}

inline String DbValueVecSlice::toDbgString() const {
    return String(AzDbValueVecSlice_toDbgString(&inner_));
}

inline bool IcuDate::partialEq(const IcuDate& b) const {
    return AzIcuDate_partialEq(&inner_, b.ptr());
}

inline String IcuDate::toDbgString() const {
    return String(AzIcuDate_toDbgString(&inner_));
}

inline IcuLocalizerHandle IcuLocalizerHandle::from_system_language(String language) {
    return IcuLocalizerHandle(AzIcuLocalizerHandle_fromSystemLanguage(language.release()));
}

inline IcuLocalizerHandle IcuLocalizerHandle::create(String default_locale) {
    return IcuLocalizerHandle(AzIcuLocalizerHandle_create(default_locale.release()));
}

inline IcuLocalizerHandle IcuLocalizerHandle::default_() {
    return IcuLocalizerHandle(AzIcuLocalizerHandle_default());
}

inline String IcuLocalizerHandle::get_default_locale() const {
    return String(AzIcuLocalizerHandle_getDefaultLocale(&inner_));
}

inline void IcuLocalizerHandle::set_default_locale(String locale) {
    AzIcuLocalizerHandle_setDefaultLocale(&inner_, locale.release());
}

inline void IcuLocalizerHandle::set_locale(String locale) {
    AzIcuLocalizerHandle_setLocale(&inner_, locale.release());
}

inline bool IcuLocalizerHandle::load_data_blob(U8VecRef data) const {
    return AzIcuLocalizerHandle_loadDataBlob(&inner_, data.release());
}

inline String IcuLocalizerHandle::get_language(String locale) const {
    return String(AzIcuLocalizerHandle_getLanguage(&inner_, locale.release()));
}

inline String IcuLocalizerHandle::format_integer(String locale, int64_t value) const {
    return String(AzIcuLocalizerHandle_formatInteger(&inner_, locale.release(), value));
}

inline String IcuLocalizerHandle::format_decimal(String locale, int64_t integer_part, int16_t decimal_places) const {
    return String(AzIcuLocalizerHandle_formatDecimal(&inner_, locale.release(), integer_part, decimal_places));
}

inline AzPluralCategory IcuLocalizerHandle::get_plural_category(String locale, int64_t value) const {
    return AzIcuLocalizerHandle_getPluralCategory(&inner_, locale.release(), value);
}

inline String IcuLocalizerHandle::pluralize(String locale, int64_t value, String zero, String one, String two, String few, String many, String other) const {
    return String(AzIcuLocalizerHandle_pluralize(&inner_, locale.release(), value, zero.release(), one.release(), two.release(), few.release(), many.release(), other.release()));
}

inline AzIcuResult IcuLocalizerHandle::format_date(String locale, IcuDate date, AzFormatLength length) const {
    return AzIcuLocalizerHandle_formatDate(&inner_, locale.release(), date.release(), length);
}

inline AzIcuResult IcuLocalizerHandle::format_time(String locale, IcuTime time, bool include_seconds) const {
    return AzIcuLocalizerHandle_formatTime(&inner_, locale.release(), time.release(), include_seconds);
}

inline AzIcuResult IcuLocalizerHandle::format_datetime(String locale, IcuDateTime datetime, AzFormatLength length) const {
    return AzIcuLocalizerHandle_formatDatetime(&inner_, locale.release(), datetime.release(), length);
}

inline int32_t IcuLocalizerHandle::compare_strings(String locale, String a, String b) const {
    return AzIcuLocalizerHandle_compareStrings(&inner_, locale.release(), a.release(), b.release());
}

inline bool IcuLocalizerHandle::strings_equal(String locale, String a, String b) const {
    return AzIcuLocalizerHandle_stringsEqual(&inner_, locale.release(), a.release(), b.release());
}

inline String IcuLocalizerHandle::format_plural(String locale, int64_t value, String zero, String one, String other) const {
    return String(AzIcuLocalizerHandle_formatPlural(&inner_, locale.release(), value, zero.release(), one.release(), other.release()));
}

inline void IcuLocalizerHandle::clear_cache() const {
    AzIcuLocalizerHandle_clearCache(&inner_);
}

inline size_t IcuLocalizerHandle::cached_locale_count() const {
    return AzIcuLocalizerHandle_cachedLocaleCount(&inner_);
}

inline void IcuLocalizerHandle::delete_() {
    AzIcuLocalizerHandle_delete(&inner_);
}

inline IcuLocalizerHandle IcuLocalizerHandle::clone() const {
    return IcuLocalizerHandle(AzIcuLocalizerHandle_clone(&inner_));
}

inline String IcuLocalizerHandle::toDbgString() const {
    return String(AzIcuLocalizerHandle_toDbgString(&inner_));
}

inline FluentLocalizerHandle FluentLocalizerHandle::create(String default_locale) {
    return FluentLocalizerHandle(AzFluentLocalizerHandle_create(default_locale.release()));
}

inline FluentLocalizerHandle FluentLocalizerHandle::default_() {
    return FluentLocalizerHandle(AzFluentLocalizerHandle_default());
}

inline String FluentLocalizerHandle::get_default_locale() const {
    return String(AzFluentLocalizerHandle_getDefaultLocale(&inner_));
}

inline void FluentLocalizerHandle::set_default_locale(String locale) const {
    AzFluentLocalizerHandle_setDefaultLocale(&inner_, locale.release());
}

inline bool FluentLocalizerHandle::add_resource(String locale, String source) const {
    return AzFluentLocalizerHandle_addResource(&inner_, locale.release(), source.release());
}

inline bool FluentLocalizerHandle::add_resource_from_bytes(String locale, U8VecRef data) const {
    return AzFluentLocalizerHandle_addResourceFromBytes(&inner_, locale.release(), data.release());
}

inline FluentZipLoadResult FluentLocalizerHandle::load_from_zip(U8VecRef data) const {
    return FluentZipLoadResult(AzFluentLocalizerHandle_loadFromZip(&inner_, data.release()));
}

inline String FluentLocalizerHandle::translate(String locale, String message_id, FmtArgVec args) const {
    return String(AzFluentLocalizerHandle_translate(&inner_, locale.release(), message_id.release(), args.release()));
}

inline bool FluentLocalizerHandle::has_message(String locale, String message_id) const {
    return AzFluentLocalizerHandle_hasMessage(&inner_, locale.release(), message_id.release());
}

inline StringVec FluentLocalizerHandle::get_loaded_locales() const {
    return StringVec(AzFluentLocalizerHandle_getLoadedLocales(&inner_));
}

inline void FluentLocalizerHandle::clear_locale(String locale) const {
    AzFluentLocalizerHandle_clearLocale(&inner_, locale.release());
}

inline void FluentLocalizerHandle::clear_all() const {
    AzFluentLocalizerHandle_clearAll(&inner_);
}

inline void FluentLocalizerHandle::delete_() {
    AzFluentLocalizerHandle_delete(&inner_);
}

inline FluentLocalizerHandle FluentLocalizerHandle::clone() const {
    return FluentLocalizerHandle(AzFluentLocalizerHandle_clone(&inner_));
}

inline String FluentLocalizerHandle::toDbgString() const {
    return String(AzFluentLocalizerHandle_toDbgString(&inner_));
}

inline String ComponentDataFieldVecSlice::toDbgString() const {
    return String(AzComponentDataFieldVecSlice_toDbgString(&inner_));
}

inline String ComponentLibraryVecSlice::toDbgString() const {
    return String(AzComponentLibraryVecSlice_toDbgString(&inner_));
}

inline String ComponentDefVecSlice::toDbgString() const {
    return String(AzComponentDefVecSlice_toDbgString(&inner_));
}

inline String ComponentDataModelVecSlice::toDbgString() const {
    return String(AzComponentDataModelVecSlice_toDbgString(&inner_));
}

inline String ComponentEnumVariantVecSlice::toDbgString() const {
    return String(AzComponentEnumVariantVecSlice_toDbgString(&inner_));
}

inline void ComponentFieldTypeBox::delete_() {
    AzComponentFieldTypeBox_delete(&inner_);
}

inline ComponentFieldTypeBox ComponentFieldTypeBox::clone() const {
    return ComponentFieldTypeBox(AzComponentFieldTypeBox_clone(&inner_));
}

inline bool ComponentFieldTypeBox::partialEq(const ComponentFieldTypeBox& b) const {
    return AzComponentFieldTypeBox_partialEq(&inner_, b.ptr());
}

inline uint64_t ComponentFieldTypeBox::hash() const {
    return AzComponentFieldTypeBox_hash(&inner_);
}

inline uint8_t ComponentFieldTypeBox::partialCmp(const ComponentFieldTypeBox& b) const {
    return AzComponentFieldTypeBox_partialCmp(&inner_, b.ptr());
}

inline uint8_t ComponentFieldTypeBox::cmp(const ComponentFieldTypeBox& b) const {
    return AzComponentFieldTypeBox_cmp(&inner_, b.ptr());
}

inline String ComponentFieldTypeBox::toDbgString() const {
    return String(AzComponentFieldTypeBox_toDbgString(&inner_));
}

inline String ComponentEnumModelVecSlice::toDbgString() const {
    return String(AzComponentEnumModelVecSlice_toDbgString(&inner_));
}

inline String ComponentFieldOverrideVecSlice::toDbgString() const {
    return String(AzComponentFieldOverrideVecSlice_toDbgString(&inner_));
}

inline String ComponentCallbackArgVecSlice::toDbgString() const {
    return String(AzComponentCallbackArgVecSlice_toDbgString(&inner_));
}

inline bool DpiScaleFactor::partialEq(const DpiScaleFactor& b) const {
    return AzDpiScaleFactor_partialEq(&inner_, b.ptr());
}

inline uint64_t DpiScaleFactor::hash() const {
    return AzDpiScaleFactor_hash(&inner_);
}

inline uint8_t DpiScaleFactor::partialCmp(const DpiScaleFactor& b) const {
    return AzDpiScaleFactor_partialCmp(&inner_, b.ptr());
}

inline uint8_t DpiScaleFactor::cmp(const DpiScaleFactor& b) const {
    return AzDpiScaleFactor_cmp(&inner_, b.ptr());
}

inline String DpiScaleFactor::toDbgString() const {
    return String(AzDpiScaleFactor_toDbgString(&inner_));
}

inline WindowFlags WindowFlags::default_() {
    return WindowFlags(AzWindowFlags_default());
}

inline bool WindowFlags::partialEq(const WindowFlags& b) const {
    return AzWindowFlags_partialEq(&inner_, b.ptr());
}

inline uint64_t WindowFlags::hash() const {
    return AzWindowFlags_hash(&inner_);
}

inline uint8_t WindowFlags::partialCmp(const WindowFlags& b) const {
    return AzWindowFlags_partialCmp(&inner_, b.ptr());
}

inline uint8_t WindowFlags::cmp(const WindowFlags& b) const {
    return AzWindowFlags_cmp(&inner_, b.ptr());
}

inline String WindowFlags::toDbgString() const {
    return String(AzWindowFlags_toDbgString(&inner_));
}

inline bool VideoMode::partialEq(const VideoMode& b) const {
    return AzVideoMode_partialEq(&inner_, b.ptr());
}

inline uint64_t VideoMode::hash() const {
    return AzVideoMode_hash(&inner_);
}

inline uint8_t VideoMode::partialCmp(const VideoMode& b) const {
    return AzVideoMode_partialCmp(&inner_, b.ptr());
}

inline uint8_t VideoMode::cmp(const VideoMode& b) const {
    return AzVideoMode_cmp(&inner_, b.ptr());
}

inline String VideoMode::toDbgString() const {
    return String(AzVideoMode_toDbgString(&inner_));
}

inline bool TextCursor::partialEq(const TextCursor& b) const {
    return AzTextCursor_partialEq(&inner_, b.ptr());
}

inline uint64_t TextCursor::hash() const {
    return AzTextCursor_hash(&inner_);
}

inline uint8_t TextCursor::partialCmp(const TextCursor& b) const {
    return AzTextCursor_partialCmp(&inner_, b.ptr());
}

inline uint8_t TextCursor::cmp(const TextCursor& b) const {
    return AzTextCursor_cmp(&inner_, b.ptr());
}

inline String TextCursor::toDbgString() const {
    return String(AzTextCursor_toDbgString(&inner_));
}

inline String XWindowTypeVecSlice::toDbgString() const {
    return String(AzXWindowTypeVecSlice_toDbgString(&inner_));
}

inline bool TouchPoint::partialEq(const TouchPoint& b) const {
    return AzTouchPoint_partialEq(&inner_, b.ptr());
}

inline uint8_t TouchPoint::partialCmp(const TouchPoint& b) const {
    return AzTouchPoint_partialCmp(&inner_, b.ptr());
}

inline String TouchPoint::toDbgString() const {
    return String(AzTouchPoint_toDbgString(&inner_));
}

inline bool DetectedPinch::partialEq(const DetectedPinch& b) const {
    return AzDetectedPinch_partialEq(&inner_, b.ptr());
}

inline String DetectedPinch::toDbgString() const {
    return String(AzDetectedPinch_toDbgString(&inner_));
}

inline TimerCallbackReturn TimerCallbackReturn::create(AzUpdate should_update, AzTerminateTimer should_terminate) {
    return TimerCallbackReturn(AzTimerCallbackReturn_create(should_update, should_terminate));
}

inline TimerCallbackReturn TimerCallbackReturn::continue_unchanged() {
    return TimerCallbackReturn(AzTimerCallbackReturn_continueUnchanged());
}

inline TimerCallbackReturn TimerCallbackReturn::continue_and_refresh_dom() {
    return TimerCallbackReturn(AzTimerCallbackReturn_continueAndRefreshDom());
}

inline TimerCallbackReturn TimerCallbackReturn::terminate_unchanged() {
    return TimerCallbackReturn(AzTimerCallbackReturn_terminateUnchanged());
}

inline TimerCallbackReturn TimerCallbackReturn::terminate_and_refresh_dom() {
    return TimerCallbackReturn(AzTimerCallbackReturn_terminateAndRefreshDom());
}

inline TimerCallbackReturn TimerCallbackReturn::default_() {
    return TimerCallbackReturn(AzTimerCallbackReturn_default());
}

inline bool TimerCallbackReturn::partialEq(const TimerCallbackReturn& b) const {
    return AzTimerCallbackReturn_partialEq(&inner_, b.ptr());
}

inline uint64_t TimerCallbackReturn::hash() const {
    return AzTimerCallbackReturn_hash(&inner_);
}

inline uint8_t TimerCallbackReturn::partialCmp(const TimerCallbackReturn& b) const {
    return AzTimerCallbackReturn_partialCmp(&inner_, b.ptr());
}

inline uint8_t TimerCallbackReturn::cmp(const TimerCallbackReturn& b) const {
    return AzTimerCallbackReturn_cmp(&inner_, b.ptr());
}

inline String TimerCallbackReturn::toDbgString() const {
    return String(AzTimerCallbackReturn_toDbgString(&inner_));
}

inline RefAny RefAny::new_c(GlVoidPtrConst ptr, size_t len, size_t align, uint64_t type_id, String type_name, AzRefAnyDestructorType destructor, size_t serialize_fn, size_t deserialize_fn) {
    return RefAny(AzRefAny_newC(ptr.release(), len, align, type_id, type_name.release(), destructor, serialize_fn, deserialize_fn));
}

inline const void* RefAny::get_data_ptr() const {
    return AzRefAny_getDataPtr(&inner_);
}

inline uint64_t RefAny::get_type_id() const {
    return AzRefAny_getTypeId(&inner_);
}

inline bool RefAny::is_type(uint64_t type_id) const {
    return AzRefAny_isType(&inner_, type_id);
}

inline void RefAny::set_serialize_fn(size_t serialize_fn) {
    AzRefAny_setSerializeFn(&inner_, serialize_fn);
}

inline void RefAny::set_deserialize_fn(size_t deserialize_fn) {
    AzRefAny_setDeserializeFn(&inner_, deserialize_fn);
}

inline bool RefAny::replace_contents(RefAny new_value) {
    return AzRefAny_replaceContents(&inner_, new_value.release());
}

inline bool RefAny::can_serialize() const {
    return AzRefAny_canSerialize(&inner_);
}

inline bool RefAny::can_deserialize() const {
    return AzRefAny_canDeserialize(&inner_);
}

inline size_t RefAny::get_serialize_fn() const {
    return AzRefAny_getSerializeFn(&inner_);
}

inline size_t RefAny::get_deserialize_fn() const {
    return AzRefAny_getDeserializeFn(&inner_);
}

inline OptionJson RefAny::serialize_to_json() const {
    return OptionJson(AzRefAny_serializeToJson(&inner_));
}

inline void RefAny::delete_() {
    AzRefAny_delete(&inner_);
}

inline RefAny RefAny::clone() const {
    return RefAny(AzRefAny_clone(&inner_));
}

inline bool RefAny::partialEq(const RefAny& b) const {
    return AzRefAny_partialEq(&inner_, b.ptr());
}

inline uint64_t RefAny::hash() const {
    return AzRefAny_hash(&inner_);
}

inline uint8_t RefAny::partialCmp(const RefAny& b) const {
    return AzRefAny_partialCmp(&inner_, b.ptr());
}

inline uint8_t RefAny::cmp(const RefAny& b) const {
    return AzRefAny_cmp(&inner_, b.ptr());
}

inline String RefAny::toDbgString() const {
    return String(AzRefAny_toDbgString(&inner_));
}

inline PenState PenState::default_() {
    return PenState(AzPenState_default());
}

inline bool PenState::partialEq(const PenState& b) const {
    return AzPenState_partialEq(&inner_, b.ptr());
}

inline String PenState::toDbgString() const {
    return String(AzPenState_toDbgString(&inner_));
}

inline ScrollState ScrollState::default_() {
    return ScrollState(AzScrollState_default());
}

inline bool ScrollState::partialEq(const ScrollState& b) const {
    return AzScrollState_partialEq(&inner_, b.ptr());
}

inline uint8_t ScrollState::partialCmp(const ScrollState& b) const {
    return AzScrollState_partialCmp(&inner_, b.ptr());
}

inline String ScrollState::toDbgString() const {
    return String(AzScrollState_toDbgString(&inner_));
}

inline bool DomNodeId::partialEq(const DomNodeId& b) const {
    return AzDomNodeId_partialEq(&inner_, b.ptr());
}

inline uint64_t DomNodeId::hash() const {
    return AzDomNodeId_hash(&inner_);
}

inline uint8_t DomNodeId::partialCmp(const DomNodeId& b) const {
    return AzDomNodeId_partialCmp(&inner_, b.ptr());
}

inline uint8_t DomNodeId::cmp(const DomNodeId& b) const {
    return AzDomNodeId_cmp(&inner_, b.ptr());
}

inline String DomNodeId::toDbgString() const {
    return String(AzDomNodeId_toDbgString(&inner_));
}

inline bool ParentWithNodeDepth::partialEq(const ParentWithNodeDepth& b) const {
    return AzParentWithNodeDepth_partialEq(&inner_, b.ptr());
}

inline uint64_t ParentWithNodeDepth::hash() const {
    return AzParentWithNodeDepth_hash(&inner_);
}

inline uint8_t ParentWithNodeDepth::partialCmp(const ParentWithNodeDepth& b) const {
    return AzParentWithNodeDepth_partialCmp(&inner_, b.ptr());
}

inline uint8_t ParentWithNodeDepth::cmp(const ParentWithNodeDepth& b) const {
    return AzParentWithNodeDepth_cmp(&inner_, b.ptr());
}

inline String ParentWithNodeDepth::toDbgString() const {
    return String(AzParentWithNodeDepth_toDbgString(&inner_));
}

inline SelectionColor SelectionColor::default_() {
    return SelectionColor(AzSelectionColor_default());
}

inline bool SelectionColor::partialEq(const SelectionColor& b) const {
    return AzSelectionColor_partialEq(&inner_, b.ptr());
}

inline uint64_t SelectionColor::hash() const {
    return AzSelectionColor_hash(&inner_);
}

inline uint8_t SelectionColor::partialCmp(const SelectionColor& b) const {
    return AzSelectionColor_partialCmp(&inner_, b.ptr());
}

inline uint8_t SelectionColor::cmp(const SelectionColor& b) const {
    return AzSelectionColor_cmp(&inner_, b.ptr());
}

inline String SelectionColor::toDbgString() const {
    return String(AzSelectionColor_toDbgString(&inner_));
}

inline String VirtualKeyCodeVecSlice::toDbgString() const {
    return String(AzVirtualKeyCodeVecSlice_toDbgString(&inner_));
}

inline String AccessibilityStateVecSlice::toDbgString() const {
    return String(AzAccessibilityStateVecSlice_toDbgString(&inner_));
}

inline String ScanCodeVecSlice::toDbgString() const {
    return String(AzScanCodeVecSlice_toDbgString(&inner_));
}

inline PixelValue PixelValue::zero() {
    return PixelValue(AzPixelValue_zero());
}

inline PixelValue PixelValue::px(float value) {
    return PixelValue(AzPixelValue_px(value));
}

inline PixelValue PixelValue::em(float value) {
    return PixelValue(AzPixelValue_em(value));
}

inline PixelValue PixelValue::rem(float value) {
    return PixelValue(AzPixelValue_rem(value));
}

inline PixelValue PixelValue::pt(float value) {
    return PixelValue(AzPixelValue_pt(value));
}

inline PixelValue PixelValue::percent(float value) {
    return PixelValue(AzPixelValue_percent(value));
}

inline PixelValue PixelValue::from_metric(AzSizeMetric metric, float value) {
    return PixelValue(AzPixelValue_fromMetric(metric, value));
}

inline PixelValue PixelValue::default_() {
    return PixelValue(AzPixelValue_default());
}

inline bool PixelValue::partialEq(const PixelValue& b) const {
    return AzPixelValue_partialEq(&inner_, b.ptr());
}

inline uint64_t PixelValue::hash() const {
    return AzPixelValue_hash(&inner_);
}

inline uint8_t PixelValue::partialCmp(const PixelValue& b) const {
    return AzPixelValue_partialCmp(&inner_, b.ptr());
}

inline uint8_t PixelValue::cmp(const PixelValue& b) const {
    return AzPixelValue_cmp(&inner_, b.ptr());
}

inline String PixelValue::toDbgString() const {
    return String(AzPixelValue_toDbgString(&inner_));
}

inline void StyleColorMatrix::delete_() {
    AzStyleColorMatrix_delete(&inner_);
}

inline StyleColorMatrix StyleColorMatrix::clone() const {
    return StyleColorMatrix(AzStyleColorMatrix_clone(&inner_));
}

inline bool StyleColorMatrix::partialEq(const StyleColorMatrix& b) const {
    return AzStyleColorMatrix_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleColorMatrix::hash() const {
    return AzStyleColorMatrix_hash(&inner_);
}

inline uint8_t StyleColorMatrix::partialCmp(const StyleColorMatrix& b) const {
    return AzStyleColorMatrix_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleColorMatrix::cmp(const StyleColorMatrix& b) const {
    return AzStyleColorMatrix_cmp(&inner_, b.ptr());
}

inline String StyleColorMatrix::toDbgString() const {
    return String(AzStyleColorMatrix_toDbgString(&inner_));
}

inline LayoutFlexGrow LayoutFlexGrow::create(float value) {
    return LayoutFlexGrow(AzLayoutFlexGrow_create(value));
}

inline LayoutFlexGrow LayoutFlexGrow::default_() {
    return LayoutFlexGrow(AzLayoutFlexGrow_default());
}

inline bool LayoutFlexGrow::partialEq(const LayoutFlexGrow& b) const {
    return AzLayoutFlexGrow_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutFlexGrow::hash() const {
    return AzLayoutFlexGrow_hash(&inner_);
}

inline uint8_t LayoutFlexGrow::partialCmp(const LayoutFlexGrow& b) const {
    return AzLayoutFlexGrow_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutFlexGrow::cmp(const LayoutFlexGrow& b) const {
    return AzLayoutFlexGrow_cmp(&inner_, b.ptr());
}

inline String LayoutFlexGrow::toDbgString() const {
    return String(AzLayoutFlexGrow_toDbgString(&inner_));
}

inline LayoutFlexShrink LayoutFlexShrink::default_() {
    return LayoutFlexShrink(AzLayoutFlexShrink_default());
}

inline bool LayoutFlexShrink::partialEq(const LayoutFlexShrink& b) const {
    return AzLayoutFlexShrink_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutFlexShrink::hash() const {
    return AzLayoutFlexShrink_hash(&inner_);
}

inline uint8_t LayoutFlexShrink::partialCmp(const LayoutFlexShrink& b) const {
    return AzLayoutFlexShrink_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutFlexShrink::cmp(const LayoutFlexShrink& b) const {
    return AzLayoutFlexShrink_cmp(&inner_, b.ptr());
}

inline String LayoutFlexShrink::toDbgString() const {
    return String(AzLayoutFlexShrink_toDbgString(&inner_));
}

inline PercentageValue PercentageValue::default_() {
    return PercentageValue(AzPercentageValue_default());
}

inline bool PercentageValue::partialEq(const PercentageValue& b) const {
    return AzPercentageValue_partialEq(&inner_, b.ptr());
}

inline uint64_t PercentageValue::hash() const {
    return AzPercentageValue_hash(&inner_);
}

inline uint8_t PercentageValue::partialCmp(const PercentageValue& b) const {
    return AzPercentageValue_partialCmp(&inner_, b.ptr());
}

inline uint8_t PercentageValue::cmp(const PercentageValue& b) const {
    return AzPercentageValue_cmp(&inner_, b.ptr());
}

inline String PercentageValue::toDbgString() const {
    return String(AzPercentageValue_toDbgString(&inner_));
}

inline AngleValue AngleValue::default_() {
    return AngleValue(AzAngleValue_default());
}

inline AngleValue AngleValue::zero() {
    return AngleValue(AzAngleValue_zero());
}

inline AngleValue AngleValue::deg(float value) {
    return AngleValue(AzAngleValue_deg(value));
}

inline AngleValue AngleValue::rad(float value) {
    return AngleValue(AzAngleValue_rad(value));
}

inline AngleValue AngleValue::grad(float value) {
    return AngleValue(AzAngleValue_grad(value));
}

inline AngleValue AngleValue::turn(float value) {
    return AngleValue(AzAngleValue_turn(value));
}

inline float AngleValue::get_degrees() const {
    return AzAngleValue_getDegrees(&inner_);
}

inline bool AngleValue::partialEq(const AngleValue& b) const {
    return AzAngleValue_partialEq(&inner_, b.ptr());
}

inline uint64_t AngleValue::hash() const {
    return AzAngleValue_hash(&inner_);
}

inline uint8_t AngleValue::partialCmp(const AngleValue& b) const {
    return AzAngleValue_partialCmp(&inner_, b.ptr());
}

inline uint8_t AngleValue::cmp(const AngleValue& b) const {
    return AzAngleValue_cmp(&inner_, b.ptr());
}

inline String AngleValue::toDbgString() const {
    return String(AzAngleValue_toDbgString(&inner_));
}

inline bool DirectionCorners::partialEq(const DirectionCorners& b) const {
    return AzDirectionCorners_partialEq(&inner_, b.ptr());
}

inline uint64_t DirectionCorners::hash() const {
    return AzDirectionCorners_hash(&inner_);
}

inline uint8_t DirectionCorners::partialCmp(const DirectionCorners& b) const {
    return AzDirectionCorners_partialCmp(&inner_, b.ptr());
}

inline uint8_t DirectionCorners::cmp(const DirectionCorners& b) const {
    return AzDirectionCorners_cmp(&inner_, b.ptr());
}

inline String DirectionCorners::toDbgString() const {
    return String(AzDirectionCorners_toDbgString(&inner_));
}

inline bool StyleBorderBottomColor::partialEq(const StyleBorderBottomColor& b) const {
    return AzStyleBorderBottomColor_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBorderBottomColor::hash() const {
    return AzStyleBorderBottomColor_hash(&inner_);
}

inline uint8_t StyleBorderBottomColor::partialCmp(const StyleBorderBottomColor& b) const {
    return AzStyleBorderBottomColor_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBorderBottomColor::cmp(const StyleBorderBottomColor& b) const {
    return AzStyleBorderBottomColor_cmp(&inner_, b.ptr());
}

inline bool StyleBorderBottomStyle::partialEq(const StyleBorderBottomStyle& b) const {
    return AzStyleBorderBottomStyle_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBorderBottomStyle::hash() const {
    return AzStyleBorderBottomStyle_hash(&inner_);
}

inline uint8_t StyleBorderBottomStyle::partialCmp(const StyleBorderBottomStyle& b) const {
    return AzStyleBorderBottomStyle_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBorderBottomStyle::cmp(const StyleBorderBottomStyle& b) const {
    return AzStyleBorderBottomStyle_cmp(&inner_, b.ptr());
}

inline bool StyleBorderLeftColor::partialEq(const StyleBorderLeftColor& b) const {
    return AzStyleBorderLeftColor_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBorderLeftColor::hash() const {
    return AzStyleBorderLeftColor_hash(&inner_);
}

inline uint8_t StyleBorderLeftColor::partialCmp(const StyleBorderLeftColor& b) const {
    return AzStyleBorderLeftColor_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBorderLeftColor::cmp(const StyleBorderLeftColor& b) const {
    return AzStyleBorderLeftColor_cmp(&inner_, b.ptr());
}

inline bool StyleBorderLeftStyle::partialEq(const StyleBorderLeftStyle& b) const {
    return AzStyleBorderLeftStyle_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBorderLeftStyle::hash() const {
    return AzStyleBorderLeftStyle_hash(&inner_);
}

inline uint8_t StyleBorderLeftStyle::partialCmp(const StyleBorderLeftStyle& b) const {
    return AzStyleBorderLeftStyle_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBorderLeftStyle::cmp(const StyleBorderLeftStyle& b) const {
    return AzStyleBorderLeftStyle_cmp(&inner_, b.ptr());
}

inline bool StyleBorderRightColor::partialEq(const StyleBorderRightColor& b) const {
    return AzStyleBorderRightColor_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBorderRightColor::hash() const {
    return AzStyleBorderRightColor_hash(&inner_);
}

inline uint8_t StyleBorderRightColor::partialCmp(const StyleBorderRightColor& b) const {
    return AzStyleBorderRightColor_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBorderRightColor::cmp(const StyleBorderRightColor& b) const {
    return AzStyleBorderRightColor_cmp(&inner_, b.ptr());
}

inline bool StyleBorderRightStyle::partialEq(const StyleBorderRightStyle& b) const {
    return AzStyleBorderRightStyle_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBorderRightStyle::hash() const {
    return AzStyleBorderRightStyle_hash(&inner_);
}

inline uint8_t StyleBorderRightStyle::partialCmp(const StyleBorderRightStyle& b) const {
    return AzStyleBorderRightStyle_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBorderRightStyle::cmp(const StyleBorderRightStyle& b) const {
    return AzStyleBorderRightStyle_cmp(&inner_, b.ptr());
}

inline bool StyleBorderTopColor::partialEq(const StyleBorderTopColor& b) const {
    return AzStyleBorderTopColor_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBorderTopColor::hash() const {
    return AzStyleBorderTopColor_hash(&inner_);
}

inline uint8_t StyleBorderTopColor::partialCmp(const StyleBorderTopColor& b) const {
    return AzStyleBorderTopColor_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBorderTopColor::cmp(const StyleBorderTopColor& b) const {
    return AzStyleBorderTopColor_cmp(&inner_, b.ptr());
}

inline bool StyleBorderTopStyle::partialEq(const StyleBorderTopStyle& b) const {
    return AzStyleBorderTopStyle_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBorderTopStyle::hash() const {
    return AzStyleBorderTopStyle_hash(&inner_);
}

inline uint8_t StyleBorderTopStyle::partialCmp(const StyleBorderTopStyle& b) const {
    return AzStyleBorderTopStyle_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBorderTopStyle::cmp(const StyleBorderTopStyle& b) const {
    return AzStyleBorderTopStyle_cmp(&inner_, b.ptr());
}

inline StyleTransformMatrix2D StyleTransformMatrix2D::default_() {
    return StyleTransformMatrix2D(AzStyleTransformMatrix2D_default());
}

inline bool StyleTransformMatrix2D::partialEq(const StyleTransformMatrix2D& b) const {
    return AzStyleTransformMatrix2D_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleTransformMatrix2D::hash() const {
    return AzStyleTransformMatrix2D_hash(&inner_);
}

inline uint8_t StyleTransformMatrix2D::partialCmp(const StyleTransformMatrix2D& b) const {
    return AzStyleTransformMatrix2D_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleTransformMatrix2D::cmp(const StyleTransformMatrix2D& b) const {
    return AzStyleTransformMatrix2D_cmp(&inner_, b.ptr());
}

inline String StyleTransformMatrix2D::toDbgString() const {
    return String(AzStyleTransformMatrix2D_toDbgString(&inner_));
}

inline StyleTransformMatrix3D StyleTransformMatrix3D::default_() {
    return StyleTransformMatrix3D(AzStyleTransformMatrix3D_default());
}

inline bool StyleTransformMatrix3D::partialEq(const StyleTransformMatrix3D& b) const {
    return AzStyleTransformMatrix3D_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleTransformMatrix3D::hash() const {
    return AzStyleTransformMatrix3D_hash(&inner_);
}

inline uint8_t StyleTransformMatrix3D::partialCmp(const StyleTransformMatrix3D& b) const {
    return AzStyleTransformMatrix3D_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleTransformMatrix3D::cmp(const StyleTransformMatrix3D& b) const {
    return AzStyleTransformMatrix3D_cmp(&inner_, b.ptr());
}

inline String StyleTransformMatrix3D::toDbgString() const {
    return String(AzStyleTransformMatrix3D_toDbgString(&inner_));
}

inline bool StyleTransformScale2D::partialEq(const StyleTransformScale2D& b) const {
    return AzStyleTransformScale2D_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleTransformScale2D::hash() const {
    return AzStyleTransformScale2D_hash(&inner_);
}

inline uint8_t StyleTransformScale2D::partialCmp(const StyleTransformScale2D& b) const {
    return AzStyleTransformScale2D_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleTransformScale2D::cmp(const StyleTransformScale2D& b) const {
    return AzStyleTransformScale2D_cmp(&inner_, b.ptr());
}

inline String StyleTransformScale2D::toDbgString() const {
    return String(AzStyleTransformScale2D_toDbgString(&inner_));
}

inline bool StyleTransformScale3D::partialEq(const StyleTransformScale3D& b) const {
    return AzStyleTransformScale3D_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleTransformScale3D::hash() const {
    return AzStyleTransformScale3D_hash(&inner_);
}

inline uint8_t StyleTransformScale3D::partialCmp(const StyleTransformScale3D& b) const {
    return AzStyleTransformScale3D_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleTransformScale3D::cmp(const StyleTransformScale3D& b) const {
    return AzStyleTransformScale3D_cmp(&inner_, b.ptr());
}

inline String StyleTransformScale3D::toDbgString() const {
    return String(AzStyleTransformScale3D_toDbgString(&inner_));
}

inline StyleTextColor StyleTextColor::default_() {
    return StyleTextColor(AzStyleTextColor_default());
}

inline bool StyleTextColor::partialEq(const StyleTextColor& b) const {
    return AzStyleTextColor_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleTextColor::hash() const {
    return AzStyleTextColor_hash(&inner_);
}

inline uint8_t StyleTextColor::partialCmp(const StyleTextColor& b) const {
    return AzStyleTextColor_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleTextColor::cmp(const StyleTextColor& b) const {
    return AzStyleTextColor_cmp(&inner_, b.ptr());
}

inline String StyleTextColor::toDbgString() const {
    return String(AzStyleTextColor_toDbgString(&inner_));
}

inline SelectionBackgroundColor SelectionBackgroundColor::default_() {
    return SelectionBackgroundColor(AzSelectionBackgroundColor_default());
}

inline bool SelectionBackgroundColor::partialEq(const SelectionBackgroundColor& b) const {
    return AzSelectionBackgroundColor_partialEq(&inner_, b.ptr());
}

inline uint64_t SelectionBackgroundColor::hash() const {
    return AzSelectionBackgroundColor_hash(&inner_);
}

inline uint8_t SelectionBackgroundColor::partialCmp(const SelectionBackgroundColor& b) const {
    return AzSelectionBackgroundColor_partialCmp(&inner_, b.ptr());
}

inline uint8_t SelectionBackgroundColor::cmp(const SelectionBackgroundColor& b) const {
    return AzSelectionBackgroundColor_cmp(&inner_, b.ptr());
}

inline String SelectionBackgroundColor::toDbgString() const {
    return String(AzSelectionBackgroundColor_toDbgString(&inner_));
}

inline ColumnRuleColor ColumnRuleColor::default_() {
    return ColumnRuleColor(AzColumnRuleColor_default());
}

inline bool ColumnRuleColor::partialEq(const ColumnRuleColor& b) const {
    return AzColumnRuleColor_partialEq(&inner_, b.ptr());
}

inline uint64_t ColumnRuleColor::hash() const {
    return AzColumnRuleColor_hash(&inner_);
}

inline uint8_t ColumnRuleColor::partialCmp(const ColumnRuleColor& b) const {
    return AzColumnRuleColor_partialCmp(&inner_, b.ptr());
}

inline uint8_t ColumnRuleColor::cmp(const ColumnRuleColor& b) const {
    return AzColumnRuleColor_cmp(&inner_, b.ptr());
}

inline String ColumnRuleColor::toDbgString() const {
    return String(AzColumnRuleColor_toDbgString(&inner_));
}

inline CaretAnimationDuration CaretAnimationDuration::default_() {
    return CaretAnimationDuration(AzCaretAnimationDuration_default());
}

inline bool CaretAnimationDuration::partialEq(const CaretAnimationDuration& b) const {
    return AzCaretAnimationDuration_partialEq(&inner_, b.ptr());
}

inline uint64_t CaretAnimationDuration::hash() const {
    return AzCaretAnimationDuration_hash(&inner_);
}

inline uint8_t CaretAnimationDuration::partialCmp(const CaretAnimationDuration& b) const {
    return AzCaretAnimationDuration_partialCmp(&inner_, b.ptr());
}

inline uint8_t CaretAnimationDuration::cmp(const CaretAnimationDuration& b) const {
    return AzCaretAnimationDuration_cmp(&inner_, b.ptr());
}

inline String CaretAnimationDuration::toDbgString() const {
    return String(AzCaretAnimationDuration_toDbgString(&inner_));
}

inline ColumnRuleStyle ColumnRuleStyle::default_() {
    return ColumnRuleStyle(AzColumnRuleStyle_default());
}

inline bool ColumnRuleStyle::partialEq(const ColumnRuleStyle& b) const {
    return AzColumnRuleStyle_partialEq(&inner_, b.ptr());
}

inline uint64_t ColumnRuleStyle::hash() const {
    return AzColumnRuleStyle_hash(&inner_);
}

inline uint8_t ColumnRuleStyle::partialCmp(const ColumnRuleStyle& b) const {
    return AzColumnRuleStyle_partialCmp(&inner_, b.ptr());
}

inline uint8_t ColumnRuleStyle::cmp(const ColumnRuleStyle& b) const {
    return AzColumnRuleStyle_cmp(&inner_, b.ptr());
}

inline String ColumnRuleStyle::toDbgString() const {
    return String(AzColumnRuleStyle_toDbgString(&inner_));
}

inline ShapeImageThreshold ShapeImageThreshold::default_() {
    return ShapeImageThreshold(AzShapeImageThreshold_default());
}

inline bool ShapeImageThreshold::partialEq(const ShapeImageThreshold& b) const {
    return AzShapeImageThreshold_partialEq(&inner_, b.ptr());
}

inline uint64_t ShapeImageThreshold::hash() const {
    return AzShapeImageThreshold_hash(&inner_);
}

inline uint8_t ShapeImageThreshold::partialCmp(const ShapeImageThreshold& b) const {
    return AzShapeImageThreshold_partialCmp(&inner_, b.ptr());
}

inline uint8_t ShapeImageThreshold::cmp(const ShapeImageThreshold& b) const {
    return AzShapeImageThreshold_cmp(&inner_, b.ptr());
}

inline String ShapeImageThreshold::toDbgString() const {
    return String(AzShapeImageThreshold_toDbgString(&inner_));
}

inline CaretColor CaretColor::default_() {
    return CaretColor(AzCaretColor_default());
}

inline bool CaretColor::partialEq(const CaretColor& b) const {
    return AzCaretColor_partialEq(&inner_, b.ptr());
}

inline uint64_t CaretColor::hash() const {
    return AzCaretColor_hash(&inner_);
}

inline uint8_t CaretColor::partialCmp(const CaretColor& b) const {
    return AzCaretColor_partialCmp(&inner_, b.ptr());
}

inline uint8_t CaretColor::cmp(const CaretColor& b) const {
    return AzCaretColor_cmp(&inner_, b.ptr());
}

inline String CaretColor::toDbgString() const {
    return String(AzCaretColor_toDbgString(&inner_));
}

inline StyleExclusionMargin StyleExclusionMargin::default_() {
    return StyleExclusionMargin(AzStyleExclusionMargin_default());
}

inline bool StyleExclusionMargin::partialEq(const StyleExclusionMargin& b) const {
    return AzStyleExclusionMargin_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleExclusionMargin::hash() const {
    return AzStyleExclusionMargin_hash(&inner_);
}

inline uint8_t StyleExclusionMargin::partialCmp(const StyleExclusionMargin& b) const {
    return AzStyleExclusionMargin_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleExclusionMargin::cmp(const StyleExclusionMargin& b) const {
    return AzStyleExclusionMargin_cmp(&inner_, b.ptr());
}

inline String StyleExclusionMargin::toDbgString() const {
    return String(AzStyleExclusionMargin_toDbgString(&inner_));
}

inline bool StyleInitialLetter::partialEq(const StyleInitialLetter& b) const {
    return AzStyleInitialLetter_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleInitialLetter::hash() const {
    return AzStyleInitialLetter_hash(&inner_);
}

inline uint8_t StyleInitialLetter::partialCmp(const StyleInitialLetter& b) const {
    return AzStyleInitialLetter_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleInitialLetter::cmp(const StyleInitialLetter& b) const {
    return AzStyleInitialLetter_cmp(&inner_, b.ptr());
}

inline String StyleInitialLetter::toDbgString() const {
    return String(AzStyleInitialLetter_toDbgString(&inner_));
}

inline bool ScrollbarColorCustom::partialEq(const ScrollbarColorCustom& b) const {
    return AzScrollbarColorCustom_partialEq(&inner_, b.ptr());
}

inline uint64_t ScrollbarColorCustom::hash() const {
    return AzScrollbarColorCustom_hash(&inner_);
}

inline uint8_t ScrollbarColorCustom::partialCmp(const ScrollbarColorCustom& b) const {
    return AzScrollbarColorCustom_partialCmp(&inner_, b.ptr());
}

inline uint8_t ScrollbarColorCustom::cmp(const ScrollbarColorCustom& b) const {
    return AzScrollbarColorCustom_cmp(&inner_, b.ptr());
}

inline String ScrollbarColorCustom::toDbgString() const {
    return String(AzScrollbarColorCustom_toDbgString(&inner_));
}

inline void ShapeInset::delete_() {
    AzShapeInset_delete(&inner_);
}

inline ShapeInset ShapeInset::clone() const {
    return ShapeInset(AzShapeInset_clone(&inner_));
}

inline bool ShapeInset::partialEq(const ShapeInset& b) const {
    return AzShapeInset_partialEq(&inner_, b.ptr());
}

inline uint64_t ShapeInset::hash() const {
    return AzShapeInset_hash(&inner_);
}

inline uint8_t ShapeInset::partialCmp(const ShapeInset& b) const {
    return AzShapeInset_partialCmp(&inner_, b.ptr());
}

inline uint8_t ShapeInset::cmp(const ShapeInset& b) const {
    return AzShapeInset_cmp(&inner_, b.ptr());
}

inline String ShapeInset::toDbgString() const {
    return String(AzShapeInset_toDbgString(&inner_));
}

inline void ShapeEllipse::delete_() {
    AzShapeEllipse_delete(&inner_);
}

inline ShapeEllipse ShapeEllipse::clone() const {
    return ShapeEllipse(AzShapeEllipse_clone(&inner_));
}

inline bool ShapeEllipse::partialEq(const ShapeEllipse& b) const {
    return AzShapeEllipse_partialEq(&inner_, b.ptr());
}

inline uint64_t ShapeEllipse::hash() const {
    return AzShapeEllipse_hash(&inner_);
}

inline uint8_t ShapeEllipse::partialCmp(const ShapeEllipse& b) const {
    return AzShapeEllipse_partialCmp(&inner_, b.ptr());
}

inline uint8_t ShapeEllipse::cmp(const ShapeEllipse& b) const {
    return AzShapeEllipse_cmp(&inner_, b.ptr());
}

inline String ShapeEllipse::toDbgString() const {
    return String(AzShapeEllipse_toDbgString(&inner_));
}

inline LayoutRect LayoutRect::create(LayoutPoint origin, LayoutSize size) {
    return LayoutRect(AzLayoutRect_create(origin.release(), size.release()));
}

inline LayoutRect LayoutRect::zero() {
    return LayoutRect(AzLayoutRect_zero());
}

inline bool LayoutRect::contains_f32(float x, float y) const {
    return AzLayoutRect_containsF32(&inner_, x, y);
}

inline bool LayoutRect::contains_rect(LayoutRect other) const {
    return AzLayoutRect_containsRect(&inner_, other.release());
}

inline OptionLayoutRect LayoutRect::union_(LayoutRectVecSlice rects) {
    return OptionLayoutRect(AzLayoutRect_union(rects.release()));
}

inline bool LayoutRect::partialEq(const LayoutRect& b) const {
    return AzLayoutRect_partialEq(&inner_, b.ptr());
}

inline uint8_t LayoutRect::partialCmp(const LayoutRect& b) const {
    return AzLayoutRect_partialCmp(&inner_, b.ptr());
}

inline String LayoutRect::toDbgString() const {
    return String(AzLayoutRect_toDbgString(&inner_));
}

inline StyledNode StyledNode::default_() {
    return StyledNode(AzStyledNode_default());
}

inline void StyledNode::delete_() {
    AzStyledNode_delete(&inner_);
}

inline StyledNode StyledNode::clone() const {
    return StyledNode(AzStyledNode_clone(&inner_));
}

inline bool StyledNode::partialEq(const StyledNode& b) const {
    return AzStyledNode_partialEq(&inner_, b.ptr());
}

inline uint8_t StyledNode::partialCmp(const StyledNode& b) const {
    return AzStyledNode_partialCmp(&inner_, b.ptr());
}

inline String StyledNode::toDbgString() const {
    return String(AzStyledNode_toDbgString(&inner_));
}

inline void ArithmeticCoefficients::delete_() {
    AzArithmeticCoefficients_delete(&inner_);
}

inline ArithmeticCoefficients ArithmeticCoefficients::clone() const {
    return ArithmeticCoefficients(AzArithmeticCoefficients_clone(&inner_));
}

inline bool ArithmeticCoefficients::partialEq(const ArithmeticCoefficients& b) const {
    return AzArithmeticCoefficients_partialEq(&inner_, b.ptr());
}

inline uint64_t ArithmeticCoefficients::hash() const {
    return AzArithmeticCoefficients_hash(&inner_);
}

inline uint8_t ArithmeticCoefficients::partialCmp(const ArithmeticCoefficients& b) const {
    return AzArithmeticCoefficients_partialCmp(&inner_, b.ptr());
}

inline uint8_t ArithmeticCoefficients::cmp(const ArithmeticCoefficients& b) const {
    return AzArithmeticCoefficients_cmp(&inner_, b.ptr());
}

inline String ArithmeticCoefficients::toDbgString() const {
    return String(AzArithmeticCoefficients_toDbgString(&inner_));
}

inline String StyleBackgroundRepeatVecSlice::toDbgString() const {
    return String(AzStyleBackgroundRepeatVecSlice_toDbgString(&inner_));
}

inline ScrollbarPreferences ScrollbarPreferences::default_() {
    return ScrollbarPreferences(AzScrollbarPreferences_default());
}

inline bool ScrollbarPreferences::partialEq(const ScrollbarPreferences& b) const {
    return AzScrollbarPreferences_partialEq(&inner_, b.ptr());
}

inline String ScrollbarPreferences::toDbgString() const {
    return String(AzScrollbarPreferences_toDbgString(&inner_));
}

inline TextRenderingHints TextRenderingHints::default_() {
    return TextRenderingHints(AzTextRenderingHints_default());
}

inline bool TextRenderingHints::partialEq(const TextRenderingHints& b) const {
    return AzTextRenderingHints_partialEq(&inner_, b.ptr());
}

inline String TextRenderingHints::toDbgString() const {
    return String(AzTextRenderingHints_toDbgString(&inner_));
}

inline AnimationMetrics AnimationMetrics::default_() {
    return AnimationMetrics(AzAnimationMetrics_default());
}

inline bool AnimationMetrics::partialEq(const AnimationMetrics& b) const {
    return AzAnimationMetrics_partialEq(&inner_, b.ptr());
}

inline String AnimationMetrics::toDbgString() const {
    return String(AzAnimationMetrics_toDbgString(&inner_));
}

inline bool CssSyntaxInvalidAdvance::partialEq(const CssSyntaxInvalidAdvance& b) const {
    return AzCssSyntaxInvalidAdvance_partialEq(&inner_, b.ptr());
}

inline String CssSyntaxInvalidAdvance::toDbgString() const {
    return String(AzCssSyntaxInvalidAdvance_toDbgString(&inner_));
}

inline SvgFillStyle SvgFillStyle::default_() {
    return SvgFillStyle(AzSvgFillStyle_default());
}

inline bool SvgFillStyle::partialEq(const SvgFillStyle& b) const {
    return AzSvgFillStyle_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgFillStyle::partialCmp(const SvgFillStyle& b) const {
    return AzSvgFillStyle_partialCmp(&inner_, b.ptr());
}

inline String SvgFillStyle::toDbgString() const {
    return String(AzSvgFillStyle_toDbgString(&inner_));
}

inline OsVersion OsVersion::default_() {
    return OsVersion(AzOsVersion_default());
}

inline bool OsVersion::partialEq(const OsVersion& b) const {
    return AzOsVersion_partialEq(&inner_, b.ptr());
}

inline uint64_t OsVersion::hash() const {
    return AzOsVersion_hash(&inner_);
}

inline String OsVersion::toDbgString() const {
    return String(AzOsVersion_toDbgString(&inner_));
}

inline VisualHints VisualHints::default_() {
    return VisualHints(AzVisualHints_default());
}

inline bool VisualHints::partialEq(const VisualHints& b) const {
    return AzVisualHints_partialEq(&inner_, b.ptr());
}

inline String VisualHints::toDbgString() const {
    return String(AzVisualHints_toDbgString(&inner_));
}

inline StyleClipRect StyleClipRect::default_() {
    return StyleClipRect(AzStyleClipRect_default());
}

inline bool StyleClipRect::partialEq(const StyleClipRect& b) const {
    return AzStyleClipRect_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleClipRect::hash() const {
    return AzStyleClipRect_hash(&inner_);
}

inline uint8_t StyleClipRect::partialCmp(const StyleClipRect& b) const {
    return AzStyleClipRect_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleClipRect::cmp(const StyleClipRect& b) const {
    return AzStyleClipRect_cmp(&inner_, b.ptr());
}

inline String StyleClipRect::toDbgString() const {
    return String(AzStyleClipRect_toDbgString(&inner_));
}

inline bool DesktopEnvVersion::partialEq(const DesktopEnvVersion& b) const {
    return AzDesktopEnvVersion_partialEq(&inner_, b.ptr());
}

inline uint64_t DesktopEnvVersion::hash() const {
    return AzDesktopEnvVersion_hash(&inner_);
}

inline String DesktopEnvVersion::toDbgString() const {
    return String(AzDesktopEnvVersion_toDbgString(&inner_));
}

inline ColorInputState ColorInputState::default_() {
    return ColorInputState(AzColorInputState_default());
}

inline void ColorInputState::delete_() {
    AzColorInputState_delete(&inner_);
}

inline ColorInputState ColorInputState::clone() const {
    return ColorInputState(AzColorInputState_clone(&inner_));
}

inline bool ColorInputState::partialEq(const ColorInputState& b) const {
    return AzColorInputState_partialEq(&inner_, b.ptr());
}

inline uint64_t ColorInputState::hash() const {
    return AzColorInputState_hash(&inner_);
}

inline uint8_t ColorInputState::partialCmp(const ColorInputState& b) const {
    return AzColorInputState_partialCmp(&inner_, b.ptr());
}

inline uint8_t ColorInputState::cmp(const ColorInputState& b) const {
    return AzColorInputState_cmp(&inner_, b.ptr());
}

inline String ColorInputState::toDbgString() const {
    return String(AzColorInputState_toDbgString(&inner_));
}

inline bool OnTextInputReturn::partialEq(const OnTextInputReturn& b) const {
    return AzOnTextInputReturn_partialEq(&inner_, b.ptr());
}

inline String OnTextInputReturn::toDbgString() const {
    return String(AzOnTextInputReturn_toDbgString(&inner_));
}

inline bool GlShaderPrecisionFormatReturn::partialEq(const GlShaderPrecisionFormatReturn& b) const {
    return AzGlShaderPrecisionFormatReturn_partialEq(&inner_, b.ptr());
}

inline uint8_t GlShaderPrecisionFormatReturn::partialCmp(const GlShaderPrecisionFormatReturn& b) const {
    return AzGlShaderPrecisionFormatReturn_partialCmp(&inner_, b.ptr());
}

inline String GlShaderPrecisionFormatReturn::toDbgString() const {
    return String(AzGlShaderPrecisionFormatReturn_toDbgString(&inner_));
}

inline AzGlType GlContextPtr::get_type() const {
    return AzGlContextPtr_getType(&inner_);
}

inline void GlContextPtr::buffer_data_untyped(AzGLenum target, AzGLsizeiptr size, GlVoidPtrConst data, AzGLenum usage) const {
    AzGlContextPtr_bufferDataUntyped(&inner_, target, size, data.release(), usage);
}

inline void GlContextPtr::buffer_sub_data_untyped(AzGLenum target, ptrdiff_t offset, AzGLsizeiptr size, GlVoidPtrConst data) const {
    AzGlContextPtr_bufferSubDataUntyped(&inner_, target, offset, size, data.release());
}

inline GlVoidPtrMut GlContextPtr::map_buffer(AzGLenum target, AzGLbitfield access) const {
    return GlVoidPtrMut(AzGlContextPtr_mapBuffer(&inner_, target, access));
}

inline GlVoidPtrMut GlContextPtr::map_buffer_range(AzGLenum target, AzGLintptr offset, AzGLsizeiptr length, AzGLbitfield access) const {
    return GlVoidPtrMut(AzGlContextPtr_mapBufferRange(&inner_, target, offset, length, access));
}

inline AzGLboolean GlContextPtr::unmap_buffer(AzGLenum target) const {
    return AzGlContextPtr_unmapBuffer(&inner_, target);
}

inline void GlContextPtr::tex_buffer(AzGLenum target, AzGLenum internal_format, AzGLuint buffer) const {
    AzGlContextPtr_texBuffer(&inner_, target, internal_format, buffer);
}

inline void GlContextPtr::read_buffer(AzGLenum mode) const {
    AzGlContextPtr_readBuffer(&inner_, mode);
}

inline void GlContextPtr::read_pixels_into_buffer(AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height, AzGLenum format, AzGLenum pixel_type, U8VecRefMut dst_buffer) const {
    AzGlContextPtr_readPixelsIntoBuffer(&inner_, x, y, width, height, format, pixel_type, dst_buffer.release());
}

inline U8Vec GlContextPtr::read_pixels(AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height, AzGLenum format, AzGLenum pixel_type) const {
    return U8Vec(AzGlContextPtr_readPixels(&inner_, x, y, width, height, format, pixel_type));
}

inline void GlContextPtr::read_pixels_into_pbo(AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height, AzGLenum format, AzGLenum pixel_type) const {
    AzGlContextPtr_readPixelsIntoPbo(&inner_, x, y, width, height, format, pixel_type);
}

inline void GlContextPtr::sample_coverage(AzGLclampf value, bool invert) const {
    AzGlContextPtr_sampleCoverage(&inner_, value, invert);
}

inline void GlContextPtr::polygon_offset(AzGLfloat factor, AzGLfloat units) const {
    AzGlContextPtr_polygonOffset(&inner_, factor, units);
}

inline void GlContextPtr::pixel_store_i(AzGLenum name, AzGLint param) const {
    AzGlContextPtr_pixelStoreI(&inner_, name, param);
}

inline GLuintVec GlContextPtr::gen_buffers(AzGLsizei n) const {
    return GLuintVec(AzGlContextPtr_genBuffers(&inner_, n));
}

inline GLuintVec GlContextPtr::gen_renderbuffers(AzGLsizei n) const {
    return GLuintVec(AzGlContextPtr_genRenderbuffers(&inner_, n));
}

inline GLuintVec GlContextPtr::gen_framebuffers(AzGLsizei n) const {
    return GLuintVec(AzGlContextPtr_genFramebuffers(&inner_, n));
}

inline GLuintVec GlContextPtr::gen_textures(AzGLsizei n) const {
    return GLuintVec(AzGlContextPtr_genTextures(&inner_, n));
}

inline GLuintVec GlContextPtr::gen_vertex_arrays(AzGLsizei n) const {
    return GLuintVec(AzGlContextPtr_genVertexArrays(&inner_, n));
}

inline GLuintVec GlContextPtr::gen_queries(AzGLsizei n) const {
    return GLuintVec(AzGlContextPtr_genQueries(&inner_, n));
}

inline void GlContextPtr::begin_query(AzGLenum target, AzGLuint id) const {
    AzGlContextPtr_beginQuery(&inner_, target, id);
}

inline void GlContextPtr::end_query(AzGLenum target) const {
    AzGlContextPtr_endQuery(&inner_, target);
}

inline void GlContextPtr::query_counter(AzGLuint id, AzGLenum target) const {
    AzGlContextPtr_queryCounter(&inner_, id, target);
}

inline int32_t GlContextPtr::get_query_object_iv(AzGLuint id, AzGLenum pname) const {
    return AzGlContextPtr_getQueryObjectIv(&inner_, id, pname);
}

inline uint32_t GlContextPtr::get_query_object_uiv(AzGLuint id, AzGLenum pname) const {
    return AzGlContextPtr_getQueryObjectUiv(&inner_, id, pname);
}

inline int64_t GlContextPtr::get_query_object_i64v(AzGLuint id, AzGLenum pname) const {
    return AzGlContextPtr_getQueryObjectI64v(&inner_, id, pname);
}

inline uint64_t GlContextPtr::get_query_object_ui64v(AzGLuint id, AzGLenum pname) const {
    return AzGlContextPtr_getQueryObjectUi64v(&inner_, id, pname);
}

inline void GlContextPtr::delete_queries(GLuintVecRef queries) const {
    AzGlContextPtr_deleteQueries(&inner_, queries.release());
}

inline void GlContextPtr::delete_vertex_arrays(GLuintVecRef vertex_arrays) const {
    AzGlContextPtr_deleteVertexArrays(&inner_, vertex_arrays.release());
}

inline void GlContextPtr::delete_buffers(GLuintVecRef buffers) const {
    AzGlContextPtr_deleteBuffers(&inner_, buffers.release());
}

inline void GlContextPtr::delete_renderbuffers(GLuintVecRef renderbuffers) const {
    AzGlContextPtr_deleteRenderbuffers(&inner_, renderbuffers.release());
}

inline void GlContextPtr::delete_framebuffers(GLuintVecRef framebuffers) const {
    AzGlContextPtr_deleteFramebuffers(&inner_, framebuffers.release());
}

inline void GlContextPtr::delete_textures(GLuintVecRef textures) const {
    AzGlContextPtr_deleteTextures(&inner_, textures.release());
}

inline void GlContextPtr::framebuffer_renderbuffer(AzGLenum target, AzGLenum attachment, AzGLenum renderbuffertarget, AzGLuint renderbuffer) const {
    AzGlContextPtr_framebufferRenderbuffer(&inner_, target, attachment, renderbuffertarget, renderbuffer);
}

inline void GlContextPtr::renderbuffer_storage(AzGLenum target, AzGLenum internalformat, AzGLsizei width, AzGLsizei height) const {
    AzGlContextPtr_renderbufferStorage(&inner_, target, internalformat, width, height);
}

inline void GlContextPtr::depth_func(AzGLenum func) const {
    AzGlContextPtr_depthFunc(&inner_, func);
}

inline void GlContextPtr::active_texture(AzGLenum texture) const {
    AzGlContextPtr_activeTexture(&inner_, texture);
}

inline void GlContextPtr::attach_shader(AzGLuint program, AzGLuint shader) const {
    AzGlContextPtr_attachShader(&inner_, program, shader);
}

inline void GlContextPtr::get_uniform_iv(AzGLuint program, AzGLint location, GLintVecRefMut result) const {
    AzGlContextPtr_getUniformIv(&inner_, program, location, result.release());
}

inline void GlContextPtr::get_uniform_fv(AzGLuint program, AzGLint location, GLfloatVecRefMut result) const {
    AzGlContextPtr_getUniformFv(&inner_, program, location, result.release());
}

inline void GlContextPtr::bind_buffer_base(AzGLenum target, AzGLuint index, AzGLuint buffer) const {
    AzGlContextPtr_bindBufferBase(&inner_, target, index, buffer);
}

inline void GlContextPtr::bind_buffer_range(AzGLenum target, AzGLuint index, AzGLuint buffer, AzGLintptr offset, AzGLsizeiptr size) const {
    AzGlContextPtr_bindBufferRange(&inner_, target, index, buffer, offset, size);
}

inline void GlContextPtr::uniform_block_binding(AzGLuint program, AzGLuint uniform_block_index, AzGLuint uniform_block_binding) const {
    AzGlContextPtr_uniformBlockBinding(&inner_, program, uniform_block_index, uniform_block_binding);
}

inline void GlContextPtr::bind_buffer(AzGLenum target, AzGLuint buffer) const {
    AzGlContextPtr_bindBuffer(&inner_, target, buffer);
}

inline void GlContextPtr::bind_vertex_array(AzGLuint vao) const {
    AzGlContextPtr_bindVertexArray(&inner_, vao);
}

inline void GlContextPtr::bind_renderbuffer(AzGLenum target, AzGLuint renderbuffer) const {
    AzGlContextPtr_bindRenderbuffer(&inner_, target, renderbuffer);
}

inline void GlContextPtr::bind_framebuffer(AzGLenum target, AzGLuint framebuffer) const {
    AzGlContextPtr_bindFramebuffer(&inner_, target, framebuffer);
}

inline void GlContextPtr::bind_texture(AzGLenum target, AzGLuint texture) const {
    AzGlContextPtr_bindTexture(&inner_, target, texture);
}

inline void GlContextPtr::draw_buffers(GLenumVecRef bufs) const {
    AzGlContextPtr_drawBuffers(&inner_, bufs.release());
}

inline void GlContextPtr::tex_image_2d(AzGLenum target, AzGLint level, AzGLint internal_format, AzGLsizei width, AzGLsizei height, AzGLint border, AzGLenum format, AzGLenum ty, OptionU8VecRef opt_data) const {
    AzGlContextPtr_texImage2d(&inner_, target, level, internal_format, width, height, border, format, ty, opt_data.release());
}

inline void GlContextPtr::compressed_tex_image_2d(AzGLenum target, AzGLint level, AzGLenum internal_format, AzGLsizei width, AzGLsizei height, AzGLint border, U8VecRef data) const {
    AzGlContextPtr_compressedTexImage2d(&inner_, target, level, internal_format, width, height, border, data.release());
}

inline void GlContextPtr::compressed_tex_sub_image_2d(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLsizei width, AzGLsizei height, AzGLenum format, U8VecRef data) const {
    AzGlContextPtr_compressedTexSubImage2d(&inner_, target, level, xoffset, yoffset, width, height, format, data.release());
}

inline void GlContextPtr::tex_image_3d(AzGLenum target, AzGLint level, AzGLint internal_format, AzGLsizei width, AzGLsizei height, AzGLsizei depth, AzGLint border, AzGLenum format, AzGLenum ty, OptionU8VecRef opt_data) const {
    AzGlContextPtr_texImage3d(&inner_, target, level, internal_format, width, height, depth, border, format, ty, opt_data.release());
}

inline void GlContextPtr::copy_tex_image_2d(AzGLenum target, AzGLint level, AzGLenum internal_format, AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height, AzGLint border) const {
    AzGlContextPtr_copyTexImage2d(&inner_, target, level, internal_format, x, y, width, height, border);
}

inline void GlContextPtr::copy_tex_sub_image_2d(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height) const {
    AzGlContextPtr_copyTexSubImage2d(&inner_, target, level, xoffset, yoffset, x, y, width, height);
}

inline void GlContextPtr::copy_tex_sub_image_3d(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLint zoffset, AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height) const {
    AzGlContextPtr_copyTexSubImage3d(&inner_, target, level, xoffset, yoffset, zoffset, x, y, width, height);
}

inline void GlContextPtr::tex_sub_image_2d(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLsizei width, AzGLsizei height, AzGLenum format, AzGLenum ty, U8VecRef data) const {
    AzGlContextPtr_texSubImage2d(&inner_, target, level, xoffset, yoffset, width, height, format, ty, data.release());
}

inline void GlContextPtr::tex_sub_image_2d_pbo(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLsizei width, AzGLsizei height, AzGLenum format, AzGLenum ty, size_t offset) const {
    AzGlContextPtr_texSubImage2dPbo(&inner_, target, level, xoffset, yoffset, width, height, format, ty, offset);
}

inline void GlContextPtr::tex_sub_image_3d(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLint zoffset, AzGLsizei width, AzGLsizei height, AzGLsizei depth, AzGLenum format, AzGLenum ty, U8VecRef data) const {
    AzGlContextPtr_texSubImage3d(&inner_, target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, data.release());
}

inline void GlContextPtr::tex_sub_image_3d_pbo(AzGLenum target, AzGLint level, AzGLint xoffset, AzGLint yoffset, AzGLint zoffset, AzGLsizei width, AzGLsizei height, AzGLsizei depth, AzGLenum format, AzGLenum ty, size_t offset) const {
    AzGlContextPtr_texSubImage3dPbo(&inner_, target, level, xoffset, yoffset, zoffset, width, height, depth, format, ty, offset);
}

inline void GlContextPtr::tex_storage_2d(AzGLenum target, AzGLint levels, AzGLenum internal_format, AzGLsizei width, AzGLsizei height) const {
    AzGlContextPtr_texStorage2d(&inner_, target, levels, internal_format, width, height);
}

inline void GlContextPtr::tex_storage_3d(AzGLenum target, AzGLint levels, AzGLenum internal_format, AzGLsizei width, AzGLsizei height, AzGLsizei depth) const {
    AzGlContextPtr_texStorage3d(&inner_, target, levels, internal_format, width, height, depth);
}

inline void GlContextPtr::get_tex_image_into_buffer(AzGLenum target, AzGLint level, AzGLenum format, AzGLenum ty, U8VecRefMut output) const {
    AzGlContextPtr_getTexImageIntoBuffer(&inner_, target, level, format, ty, output.release());
}

inline void GlContextPtr::copy_image_sub_data(AzGLuint src_name, AzGLenum src_target, AzGLint src_level, AzGLint src_x, AzGLint src_y, AzGLint src_z, AzGLuint dst_name, AzGLenum dst_target, AzGLint dst_level, AzGLint dst_x, AzGLint dst_y, AzGLint dst_z, AzGLsizei src_width, AzGLsizei src_height, AzGLsizei src_depth) const {
    AzGlContextPtr_copyImageSubData(&inner_, src_name, src_target, src_level, src_x, src_y, src_z, dst_name, dst_target, dst_level, dst_x, dst_y, dst_z, src_width, src_height, src_depth);
}

inline void GlContextPtr::invalidate_framebuffer(AzGLenum target, GLenumVecRef attachments) const {
    AzGlContextPtr_invalidateFramebuffer(&inner_, target, attachments.release());
}

inline void GlContextPtr::invalidate_sub_framebuffer(AzGLenum target, GLenumVecRef attachments, AzGLint xoffset, AzGLint yoffset, AzGLsizei width, AzGLsizei height) const {
    AzGlContextPtr_invalidateSubFramebuffer(&inner_, target, attachments.release(), xoffset, yoffset, width, height);
}

inline void GlContextPtr::get_integer_v(AzGLenum name, GLintVecRefMut result) const {
    AzGlContextPtr_getIntegerV(&inner_, name, result.release());
}

inline void GlContextPtr::get_integer_64v(AzGLenum name, GLint64VecRefMut result) const {
    AzGlContextPtr_getInteger64v(&inner_, name, result.release());
}

inline void GlContextPtr::get_integer_iv(AzGLenum name, AzGLuint index, GLintVecRefMut result) const {
    AzGlContextPtr_getIntegerIv(&inner_, name, index, result.release());
}

inline void GlContextPtr::get_integer_64iv(AzGLenum name, AzGLuint index, GLint64VecRefMut result) const {
    AzGlContextPtr_getInteger64iv(&inner_, name, index, result.release());
}

inline void GlContextPtr::get_boolean_v(AzGLenum name, GLbooleanVecRefMut result) const {
    AzGlContextPtr_getBooleanV(&inner_, name, result.release());
}

inline void GlContextPtr::get_float_v(AzGLenum name, GLfloatVecRefMut result) const {
    AzGlContextPtr_getFloatV(&inner_, name, result.release());
}

inline AzGLint GlContextPtr::get_framebuffer_attachment_parameter_iv(AzGLenum target, AzGLenum attachment, AzGLenum pname) const {
    return AzGlContextPtr_getFramebufferAttachmentParameterIv(&inner_, target, attachment, pname);
}

inline AzGLint GlContextPtr::get_renderbuffer_parameter_iv(AzGLenum target, AzGLenum pname) const {
    return AzGlContextPtr_getRenderbufferParameterIv(&inner_, target, pname);
}

inline AzGLint GlContextPtr::get_tex_parameter_iv(AzGLenum target, AzGLenum name) const {
    return AzGlContextPtr_getTexParameterIv(&inner_, target, name);
}

inline AzGLfloat GlContextPtr::get_tex_parameter_fv(AzGLenum target, AzGLenum name) const {
    return AzGlContextPtr_getTexParameterFv(&inner_, target, name);
}

inline void GlContextPtr::tex_parameter_i(AzGLenum target, AzGLenum pname, AzGLint param) const {
    AzGlContextPtr_texParameterI(&inner_, target, pname, param);
}

inline void GlContextPtr::tex_parameter_f(AzGLenum target, AzGLenum pname, AzGLfloat param) const {
    AzGlContextPtr_texParameterF(&inner_, target, pname, param);
}

inline void GlContextPtr::framebuffer_texture_2d(AzGLenum target, AzGLenum attachment, AzGLenum textarget, AzGLuint texture, AzGLint level) const {
    AzGlContextPtr_framebufferTexture2d(&inner_, target, attachment, textarget, texture, level);
}

inline void GlContextPtr::framebuffer_texture_layer(AzGLenum target, AzGLenum attachment, AzGLuint texture, AzGLint level, AzGLint layer) const {
    AzGlContextPtr_framebufferTextureLayer(&inner_, target, attachment, texture, level, layer);
}

inline void GlContextPtr::blit_framebuffer(AzGLint src_x0, AzGLint src_y0, AzGLint src_x1, AzGLint src_y1, AzGLint dst_x0, AzGLint dst_y0, AzGLint dst_x1, AzGLint dst_y1, AzGLbitfield mask, AzGLenum filter) const {
    AzGlContextPtr_blitFramebuffer(&inner_, src_x0, src_y0, src_x1, src_y1, dst_x0, dst_y0, dst_x1, dst_y1, mask, filter);
}

inline void GlContextPtr::vertex_attrib_4f(AzGLuint index, AzGLfloat x, AzGLfloat y, AzGLfloat z, AzGLfloat w) const {
    AzGlContextPtr_vertexAttrib4f(&inner_, index, x, y, z, w);
}

inline void GlContextPtr::vertex_attrib_divisor(AzGLuint index, AzGLuint divisor) const {
    AzGlContextPtr_vertexAttribDivisor(&inner_, index, divisor);
}

inline void GlContextPtr::viewport(AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height) const {
    AzGlContextPtr_viewport(&inner_, x, y, width, height);
}

inline void GlContextPtr::scissor(AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height) const {
    AzGlContextPtr_scissor(&inner_, x, y, width, height);
}

inline void GlContextPtr::line_width(AzGLfloat width) const {
    AzGlContextPtr_lineWidth(&inner_, width);
}

inline void GlContextPtr::use_program(AzGLuint program) const {
    AzGlContextPtr_useProgram(&inner_, program);
}

inline void GlContextPtr::validate_program(AzGLuint program) const {
    AzGlContextPtr_validateProgram(&inner_, program);
}

inline void GlContextPtr::draw_arrays(AzGLenum mode, AzGLint first, AzGLsizei count) const {
    AzGlContextPtr_drawArrays(&inner_, mode, first, count);
}

inline void GlContextPtr::draw_arrays_instanced(AzGLenum mode, AzGLint first, AzGLsizei count, AzGLsizei primcount) const {
    AzGlContextPtr_drawArraysInstanced(&inner_, mode, first, count, primcount);
}

inline void GlContextPtr::draw_elements(AzGLenum mode, AzGLsizei count, AzGLenum element_type, AzGLuint indices_offset) const {
    AzGlContextPtr_drawElements(&inner_, mode, count, element_type, indices_offset);
}

inline void GlContextPtr::draw_elements_instanced(AzGLenum mode, AzGLsizei count, AzGLenum element_type, AzGLuint indices_offset, AzGLsizei primcount) const {
    AzGlContextPtr_drawElementsInstanced(&inner_, mode, count, element_type, indices_offset, primcount);
}

inline void GlContextPtr::blend_color(float r, float g, float b, float a) const {
    AzGlContextPtr_blendColor(&inner_, r, g, b, a);
}

inline void GlContextPtr::blend_func(AzGLenum sfactor, AzGLenum dfactor) const {
    AzGlContextPtr_blendFunc(&inner_, sfactor, dfactor);
}

inline void GlContextPtr::blend_func_separate(AzGLenum src_rgb, AzGLenum dest_rgb, AzGLenum src_alpha, AzGLenum dest_alpha) const {
    AzGlContextPtr_blendFuncSeparate(&inner_, src_rgb, dest_rgb, src_alpha, dest_alpha);
}

inline void GlContextPtr::blend_equation(AzGLenum mode) const {
    AzGlContextPtr_blendEquation(&inner_, mode);
}

inline void GlContextPtr::blend_equation_separate(AzGLenum mode_rgb, AzGLenum mode_alpha) const {
    AzGlContextPtr_blendEquationSeparate(&inner_, mode_rgb, mode_alpha);
}

inline void GlContextPtr::color_mask(bool r, bool g, bool b, bool a) const {
    AzGlContextPtr_colorMask(&inner_, r, g, b, a);
}

inline void GlContextPtr::cull_face(AzGLenum mode) const {
    AzGlContextPtr_cullFace(&inner_, mode);
}

inline void GlContextPtr::front_face(AzGLenum mode) const {
    AzGlContextPtr_frontFace(&inner_, mode);
}

inline void GlContextPtr::enable(AzGLenum cap) const {
    AzGlContextPtr_enable(&inner_, cap);
}

inline void GlContextPtr::disable(AzGLenum cap) const {
    AzGlContextPtr_disable(&inner_, cap);
}

inline void GlContextPtr::hint(AzGLenum param_name, AzGLenum param_val) const {
    AzGlContextPtr_hint(&inner_, param_name, param_val);
}

inline AzGLboolean GlContextPtr::is_enabled(AzGLenum cap) const {
    return AzGlContextPtr_isEnabled(&inner_, cap);
}

inline AzGLboolean GlContextPtr::is_shader(AzGLuint shader) const {
    return AzGlContextPtr_isShader(&inner_, shader);
}

inline AzGLboolean GlContextPtr::is_texture(AzGLenum texture) const {
    return AzGlContextPtr_isTexture(&inner_, texture);
}

inline AzGLboolean GlContextPtr::is_framebuffer(AzGLenum framebuffer) const {
    return AzGlContextPtr_isFramebuffer(&inner_, framebuffer);
}

inline AzGLboolean GlContextPtr::is_renderbuffer(AzGLenum renderbuffer) const {
    return AzGlContextPtr_isRenderbuffer(&inner_, renderbuffer);
}

inline AzGLenum GlContextPtr::check_frame_buffer_status(AzGLenum target) const {
    return AzGlContextPtr_checkFrameBufferStatus(&inner_, target);
}

inline void GlContextPtr::enable_vertex_attrib_array(AzGLuint index) const {
    AzGlContextPtr_enableVertexAttribArray(&inner_, index);
}

inline void GlContextPtr::disable_vertex_attrib_array(AzGLuint index) const {
    AzGlContextPtr_disableVertexAttribArray(&inner_, index);
}

inline void GlContextPtr::uniform_1f(AzGLint location, AzGLfloat v0) const {
    AzGlContextPtr_uniform1f(&inner_, location, v0);
}

inline void GlContextPtr::uniform_1fv(AzGLint location, F32VecRef values) const {
    AzGlContextPtr_uniform1fv(&inner_, location, values.release());
}

inline void GlContextPtr::uniform_1i(AzGLint location, AzGLint v0) const {
    AzGlContextPtr_uniform1i(&inner_, location, v0);
}

inline void GlContextPtr::uniform_1iv(AzGLint location, I32VecRef values) const {
    AzGlContextPtr_uniform1iv(&inner_, location, values.release());
}

inline void GlContextPtr::uniform_1ui(AzGLint location, AzGLuint v0) const {
    AzGlContextPtr_uniform1ui(&inner_, location, v0);
}

inline void GlContextPtr::uniform_2f(AzGLint location, AzGLfloat v0, AzGLfloat v1) const {
    AzGlContextPtr_uniform2f(&inner_, location, v0, v1);
}

inline void GlContextPtr::uniform_2fv(AzGLint location, F32VecRef values) const {
    AzGlContextPtr_uniform2fv(&inner_, location, values.release());
}

inline void GlContextPtr::uniform_2i(AzGLint location, AzGLint v0, AzGLint v1) const {
    AzGlContextPtr_uniform2i(&inner_, location, v0, v1);
}

inline void GlContextPtr::uniform_2iv(AzGLint location, I32VecRef values) const {
    AzGlContextPtr_uniform2iv(&inner_, location, values.release());
}

inline void GlContextPtr::uniform_2ui(AzGLint location, AzGLuint v0, AzGLuint v1) const {
    AzGlContextPtr_uniform2ui(&inner_, location, v0, v1);
}

inline void GlContextPtr::uniform_3f(AzGLint location, AzGLfloat v0, AzGLfloat v1, AzGLfloat v2) const {
    AzGlContextPtr_uniform3f(&inner_, location, v0, v1, v2);
}

inline void GlContextPtr::uniform_3fv(AzGLint location, F32VecRef values) const {
    AzGlContextPtr_uniform3fv(&inner_, location, values.release());
}

inline void GlContextPtr::uniform_3i(AzGLint location, AzGLint v0, AzGLint v1, AzGLint v2) const {
    AzGlContextPtr_uniform3i(&inner_, location, v0, v1, v2);
}

inline void GlContextPtr::uniform_3iv(AzGLint location, I32VecRef values) const {
    AzGlContextPtr_uniform3iv(&inner_, location, values.release());
}

inline void GlContextPtr::uniform_3ui(AzGLint location, AzGLuint v0, AzGLuint v1, AzGLuint v2) const {
    AzGlContextPtr_uniform3ui(&inner_, location, v0, v1, v2);
}

inline void GlContextPtr::uniform_4f(AzGLint location, AzGLfloat x, AzGLfloat y, AzGLfloat z, AzGLfloat w) const {
    AzGlContextPtr_uniform4f(&inner_, location, x, y, z, w);
}

inline void GlContextPtr::uniform_4i(AzGLint location, AzGLint x, AzGLint y, AzGLint z, AzGLint w) const {
    AzGlContextPtr_uniform4i(&inner_, location, x, y, z, w);
}

inline void GlContextPtr::uniform_4iv(AzGLint location, I32VecRef values) const {
    AzGlContextPtr_uniform4iv(&inner_, location, values.release());
}

inline void GlContextPtr::uniform_4ui(AzGLint location, AzGLuint x, AzGLuint y, AzGLuint z, AzGLuint w) const {
    AzGlContextPtr_uniform4ui(&inner_, location, x, y, z, w);
}

inline void GlContextPtr::uniform_4fv(AzGLint location, F32VecRef values) const {
    AzGlContextPtr_uniform4fv(&inner_, location, values.release());
}

inline void GlContextPtr::uniform_matrix_2fv(AzGLint location, bool transpose, F32VecRef value) const {
    AzGlContextPtr_uniformMatrix2fv(&inner_, location, transpose, value.release());
}

inline void GlContextPtr::uniform_matrix_3fv(AzGLint location, bool transpose, F32VecRef value) const {
    AzGlContextPtr_uniformMatrix3fv(&inner_, location, transpose, value.release());
}

inline void GlContextPtr::uniform_matrix_4fv(AzGLint location, bool transpose, F32VecRef value) const {
    AzGlContextPtr_uniformMatrix4fv(&inner_, location, transpose, value.release());
}

inline void GlContextPtr::depth_mask(bool flag) const {
    AzGlContextPtr_depthMask(&inner_, flag);
}

inline void GlContextPtr::depth_range(double near, double far) const {
    AzGlContextPtr_depthRange(&inner_, near, far);
}

inline GetActiveAttribReturn GlContextPtr::get_active_attrib(AzGLuint program, AzGLuint index) const {
    return GetActiveAttribReturn(AzGlContextPtr_getActiveAttrib(&inner_, program, index));
}

inline GetActiveUniformReturn GlContextPtr::get_active_uniform(AzGLuint program, AzGLuint index) const {
    return GetActiveUniformReturn(AzGlContextPtr_getActiveUniform(&inner_, program, index));
}

inline GLintVec GlContextPtr::get_active_uniforms_iv(AzGLuint program, GLuintVec indices, AzGLenum pname) const {
    return GLintVec(AzGlContextPtr_getActiveUniformsIv(&inner_, program, indices.release(), pname));
}

inline AzGLint GlContextPtr::get_active_uniform_block_i(AzGLuint program, AzGLuint index, AzGLenum pname) const {
    return AzGlContextPtr_getActiveUniformBlockI(&inner_, program, index, pname);
}

inline GLintVec GlContextPtr::get_active_uniform_block_iv(AzGLuint program, AzGLuint index, AzGLenum pname) const {
    return GLintVec(AzGlContextPtr_getActiveUniformBlockIv(&inner_, program, index, pname));
}

inline String GlContextPtr::get_active_uniform_block_name(AzGLuint program, AzGLuint index) const {
    return String(AzGlContextPtr_getActiveUniformBlockName(&inner_, program, index));
}

inline String GlContextPtr::get_program_info_log(AzGLuint program) const {
    return String(AzGlContextPtr_getProgramInfoLog(&inner_, program));
}

inline void GlContextPtr::get_program_iv(AzGLuint program, AzGLenum pname, GLintVecRefMut result) const {
    AzGlContextPtr_getProgramIv(&inner_, program, pname, result.release());
}

inline GetProgramBinaryReturn GlContextPtr::get_program_binary(AzGLuint program) const {
    return GetProgramBinaryReturn(AzGlContextPtr_getProgramBinary(&inner_, program));
}

inline void GlContextPtr::program_binary(AzGLuint program, AzGLenum format, U8VecRef binary) const {
    AzGlContextPtr_programBinary(&inner_, program, format, binary.release());
}

inline void GlContextPtr::program_parameter_i(AzGLuint program, AzGLenum pname, AzGLint value) const {
    AzGlContextPtr_programParameterI(&inner_, program, pname, value);
}

inline void GlContextPtr::get_vertex_attrib_iv(AzGLuint index, AzGLenum pname, GLintVecRefMut result) const {
    AzGlContextPtr_getVertexAttribIv(&inner_, index, pname, result.release());
}

inline void GlContextPtr::get_vertex_attrib_fv(AzGLuint index, AzGLenum pname, GLfloatVecRefMut result) const {
    AzGlContextPtr_getVertexAttribFv(&inner_, index, pname, result.release());
}

inline AzGLsizeiptr GlContextPtr::get_vertex_attrib_pointer_v(AzGLuint index, AzGLenum pname) const {
    return AzGlContextPtr_getVertexAttribPointerV(&inner_, index, pname);
}

inline AzGLint GlContextPtr::get_buffer_parameter_iv(AzGLuint target, AzGLenum pname) const {
    return AzGlContextPtr_getBufferParameterIv(&inner_, target, pname);
}

inline String GlContextPtr::get_shader_info_log(AzGLuint shader) const {
    return String(AzGlContextPtr_getShaderInfoLog(&inner_, shader));
}

inline void GlContextPtr::get_shader_iv(AzGLuint shader, AzGLenum pname, GLintVecRefMut result) const {
    AzGlContextPtr_getShaderIv(&inner_, shader, pname, result.release());
}

inline GlShaderPrecisionFormatReturn GlContextPtr::get_shader_precision_format(AzGLuint shader_type, AzGLuint precision_type) const {
    return GlShaderPrecisionFormatReturn(AzGlContextPtr_getShaderPrecisionFormat(&inner_, shader_type, precision_type));
}

inline void GlContextPtr::compile_shader(AzGLuint shader) const {
    AzGlContextPtr_compileShader(&inner_, shader);
}

inline AzGLuint GlContextPtr::create_program() const {
    return AzGlContextPtr_createProgram(&inner_);
}

inline void GlContextPtr::delete_program(AzGLuint program) const {
    AzGlContextPtr_deleteProgram(&inner_, program);
}

inline AzGLuint GlContextPtr::create_shader(AzGLenum shader_type) const {
    return AzGlContextPtr_createShader(&inner_, shader_type);
}

inline void GlContextPtr::delete_shader(AzGLuint shader) const {
    AzGlContextPtr_deleteShader(&inner_, shader);
}

inline void GlContextPtr::detach_shader(AzGLuint program, AzGLuint shader) const {
    AzGlContextPtr_detachShader(&inner_, program, shader);
}

inline void GlContextPtr::link_program(AzGLuint program) const {
    AzGlContextPtr_linkProgram(&inner_, program);
}

inline void GlContextPtr::clear_color(float r, float g, float b, float a) const {
    AzGlContextPtr_clearColor(&inner_, r, g, b, a);
}

inline void GlContextPtr::clear(AzGLbitfield buffer_mask) const {
    AzGlContextPtr_clear(&inner_, buffer_mask);
}

inline void GlContextPtr::clear_depth(double depth) const {
    AzGlContextPtr_clearDepth(&inner_, depth);
}

inline void GlContextPtr::clear_stencil(AzGLint s) const {
    AzGlContextPtr_clearStencil(&inner_, s);
}

inline void GlContextPtr::flush() const {
    AzGlContextPtr_flush(&inner_);
}

inline void GlContextPtr::finish() const {
    AzGlContextPtr_finish(&inner_);
}

inline AzGLenum GlContextPtr::get_error() const {
    return AzGlContextPtr_getError(&inner_);
}

inline void GlContextPtr::stencil_mask(AzGLuint mask) const {
    AzGlContextPtr_stencilMask(&inner_, mask);
}

inline void GlContextPtr::stencil_mask_separate(AzGLenum face, AzGLuint mask) const {
    AzGlContextPtr_stencilMaskSeparate(&inner_, face, mask);
}

inline void GlContextPtr::stencil_func(AzGLenum func, AzGLint ref_, AzGLuint mask) const {
    AzGlContextPtr_stencilFunc(&inner_, func, ref_, mask);
}

inline void GlContextPtr::stencil_func_separate(AzGLenum face, AzGLenum func, AzGLint ref_, AzGLuint mask) const {
    AzGlContextPtr_stencilFuncSeparate(&inner_, face, func, ref_, mask);
}

inline void GlContextPtr::stencil_op(AzGLenum sfail, AzGLenum dpfail, AzGLenum dppass) const {
    AzGlContextPtr_stencilOp(&inner_, sfail, dpfail, dppass);
}

inline void GlContextPtr::stencil_op_separate(AzGLenum face, AzGLenum sfail, AzGLenum dpfail, AzGLenum dppass) const {
    AzGlContextPtr_stencilOpSeparate(&inner_, face, sfail, dpfail, dppass);
}

inline void GlContextPtr::egl_image_target_texture2d_oes(AzGLenum target, GlVoidPtrConst image) const {
    AzGlContextPtr_eglImageTargetTexture2dOes(&inner_, target, image.release());
}

inline void GlContextPtr::generate_mipmap(AzGLenum target) const {
    AzGlContextPtr_generateMipmap(&inner_, target);
}

inline void GlContextPtr::pop_group_marker_ext() const {
    AzGlContextPtr_popGroupMarkerExt(&inner_);
}

inline void GlContextPtr::pop_debug_group_khr() const {
    AzGlContextPtr_popDebugGroupKhr(&inner_);
}

inline GLsyncPtr GlContextPtr::fence_sync(AzGLenum condition, AzGLbitfield flags) const {
    return GLsyncPtr(AzGlContextPtr_fenceSync(&inner_, condition, flags));
}

inline uint32_t GlContextPtr::client_wait_sync(GLsyncPtr sync, AzGLbitfield flags, AzGLuint64 timeout) const {
    return AzGlContextPtr_clientWaitSync(&inner_, sync.release(), flags, timeout);
}

inline void GlContextPtr::wait_sync(GLsyncPtr sync, AzGLbitfield flags, AzGLuint64 timeout) const {
    AzGlContextPtr_waitSync(&inner_, sync.release(), flags, timeout);
}

inline void GlContextPtr::delete_sync(GLsyncPtr sync) const {
    AzGlContextPtr_deleteSync(&inner_, sync.release());
}

inline void GlContextPtr::texture_range_apple(AzGLenum target, U8VecRef data) const {
    AzGlContextPtr_textureRangeApple(&inner_, target, data.release());
}

inline GLuintVec GlContextPtr::gen_fences_apple(AzGLsizei n) const {
    return GLuintVec(AzGlContextPtr_genFencesApple(&inner_, n));
}

inline void GlContextPtr::delete_fences_apple(GLuintVecRef fences) const {
    AzGlContextPtr_deleteFencesApple(&inner_, fences.release());
}

inline void GlContextPtr::set_fence_apple(AzGLuint fence) const {
    AzGlContextPtr_setFenceApple(&inner_, fence);
}

inline void GlContextPtr::finish_fence_apple(AzGLuint fence) const {
    AzGlContextPtr_finishFenceApple(&inner_, fence);
}

inline void GlContextPtr::test_fence_apple(AzGLuint fence) const {
    AzGlContextPtr_testFenceApple(&inner_, fence);
}

inline AzGLboolean GlContextPtr::test_object_apple(AzGLenum object, AzGLuint name) const {
    return AzGlContextPtr_testObjectApple(&inner_, object, name);
}

inline void GlContextPtr::finish_object_apple(AzGLenum object, AzGLuint name) const {
    AzGlContextPtr_finishObjectApple(&inner_, object, name);
}

inline void GlContextPtr::blend_barrier_khr() const {
    AzGlContextPtr_blendBarrierKhr(&inner_);
}

inline DebugMessageVec GlContextPtr::get_debug_messages() const {
    return DebugMessageVec(AzGlContextPtr_getDebugMessages(&inner_));
}

inline void GlContextPtr::provoking_vertex_angle(AzGLenum mode) const {
    AzGlContextPtr_provokingVertexAngle(&inner_, mode);
}

inline GLuintVec GlContextPtr::gen_vertex_arrays_apple(AzGLsizei n) const {
    return GLuintVec(AzGlContextPtr_genVertexArraysApple(&inner_, n));
}

inline void GlContextPtr::bind_vertex_array_apple(AzGLuint vao) const {
    AzGlContextPtr_bindVertexArrayApple(&inner_, vao);
}

inline void GlContextPtr::delete_vertex_arrays_apple(GLuintVecRef vertex_arrays) const {
    AzGlContextPtr_deleteVertexArraysApple(&inner_, vertex_arrays.release());
}

inline void GlContextPtr::copy_texture_chromium(AzGLuint source_id, AzGLint source_level, AzGLenum dest_target, AzGLuint dest_id, AzGLint dest_level, AzGLint internal_format, AzGLenum dest_type, AzGLboolean unpack_flip_y, AzGLboolean unpack_premultiply_alpha, AzGLboolean unpack_unmultiply_alpha) const {
    AzGlContextPtr_copyTextureChromium(&inner_, source_id, source_level, dest_target, dest_id, dest_level, internal_format, dest_type, unpack_flip_y, unpack_premultiply_alpha, unpack_unmultiply_alpha);
}

inline void GlContextPtr::copy_sub_texture_chromium(AzGLuint source_id, AzGLint source_level, AzGLenum dest_target, AzGLuint dest_id, AzGLint dest_level, AzGLint x_offset, AzGLint y_offset, AzGLint x, AzGLint y, AzGLsizei width, AzGLsizei height, AzGLboolean unpack_flip_y, AzGLboolean unpack_premultiply_alpha, AzGLboolean unpack_unmultiply_alpha) const {
    AzGlContextPtr_copySubTextureChromium(&inner_, source_id, source_level, dest_target, dest_id, dest_level, x_offset, y_offset, x, y, width, height, unpack_flip_y, unpack_premultiply_alpha, unpack_unmultiply_alpha);
}

inline void GlContextPtr::egl_image_target_renderbuffer_storage_oes(uint32_t target, GlVoidPtrConst image) const {
    AzGlContextPtr_eglImageTargetRenderbufferStorageOes(&inner_, target, image.release());
}

inline void GlContextPtr::copy_texture_3d_angle(AzGLuint source_id, AzGLint source_level, AzGLenum dest_target, AzGLuint dest_id, AzGLint dest_level, AzGLint internal_format, AzGLenum dest_type, AzGLboolean unpack_flip_y, AzGLboolean unpack_premultiply_alpha, AzGLboolean unpack_unmultiply_alpha) const {
    AzGlContextPtr_copyTexture3dAngle(&inner_, source_id, source_level, dest_target, dest_id, dest_level, internal_format, dest_type, unpack_flip_y, unpack_premultiply_alpha, unpack_unmultiply_alpha);
}

inline void GlContextPtr::copy_sub_texture_3d_angle(AzGLuint source_id, AzGLint source_level, AzGLenum dest_target, AzGLuint dest_id, AzGLint dest_level, AzGLint x_offset, AzGLint y_offset, AzGLint z_offset, AzGLint x, AzGLint y, AzGLint z, AzGLsizei width, AzGLsizei height, AzGLsizei depth, AzGLboolean unpack_flip_y, AzGLboolean unpack_premultiply_alpha, AzGLboolean unpack_unmultiply_alpha) const {
    AzGlContextPtr_copySubTexture3dAngle(&inner_, source_id, source_level, dest_target, dest_id, dest_level, x_offset, y_offset, z_offset, x, y, z, width, height, depth, unpack_flip_y, unpack_premultiply_alpha, unpack_unmultiply_alpha);
}

inline void GlContextPtr::buffer_storage(AzGLenum target, AzGLsizeiptr size, GlVoidPtrConst data, AzGLbitfield flags) const {
    AzGlContextPtr_bufferStorage(&inner_, target, size, data.release(), flags);
}

inline void GlContextPtr::flush_mapped_buffer_range(AzGLenum target, AzGLintptr offset, AzGLsizeiptr length) const {
    AzGlContextPtr_flushMappedBufferRange(&inner_, target, offset, length);
}

inline AzGLuint GlContextPtr::get_svg_shader() const {
    return AzGlContextPtr_getSvgShader(&inner_);
}

inline AzGLuint GlContextPtr::get_fxaa_shader() const {
    return AzGlContextPtr_getFxaaShader(&inner_);
}

inline void GlContextPtr::shader_source(AzGLuint shader, StringVec strings) const {
    AzGlContextPtr_shaderSource(&inner_, shader, strings.release());
}

inline void GlContextPtr::bind_attrib_location(AzGLuint program, AzGLuint index, String name) const {
    AzGlContextPtr_bindAttribLocation(&inner_, program, index, name.release());
}

inline AzGLuint GlContextPtr::get_uniform_block_index(AzGLuint program, String name) const {
    return AzGlContextPtr_getUniformBlockIndex(&inner_, program, name.release());
}

inline GLuintVec GlContextPtr::get_uniform_indices(AzGLuint program, RefstrVecRef names) const {
    return GLuintVec(AzGlContextPtr_getUniformIndices(&inner_, program, names.release()));
}

inline void GlContextPtr::vertex_attrib_pointer_f32(AzGLuint index, AzGLint size, bool normalized, AzGLsizei stride, AzGLuint offset) const {
    AzGlContextPtr_vertexAttribPointerF32(&inner_, index, size, normalized, stride, offset);
}

inline void GlContextPtr::vertex_attrib_pointer(AzGLuint index, AzGLint size, AzGLenum type_, bool normalized, AzGLsizei stride, AzGLuint offset) const {
    AzGlContextPtr_vertexAttribPointer(&inner_, index, size, type_, normalized, stride, offset);
}

inline void GlContextPtr::vertex_attrib_i_pointer(AzGLuint index, AzGLint size, AzGLenum type_, AzGLsizei stride, AzGLuint offset) const {
    AzGlContextPtr_vertexAttribIPointer(&inner_, index, size, type_, stride, offset);
}

inline int GlContextPtr::get_attrib_location(AzGLuint program, String name) const {
    return AzGlContextPtr_getAttribLocation(&inner_, program, name.release());
}

inline int GlContextPtr::get_frag_data_location(AzGLuint program, String name) const {
    return AzGlContextPtr_getFragDataLocation(&inner_, program, name.release());
}

inline int GlContextPtr::get_uniform_location(AzGLuint program, String name) const {
    return AzGlContextPtr_getUniformLocation(&inner_, program, name.release());
}

inline String GlContextPtr::get_string(AzGLenum which) const {
    return String(AzGlContextPtr_getString(&inner_, which));
}

inline String GlContextPtr::get_string_i(AzGLenum which, AzGLuint index) const {
    return String(AzGlContextPtr_getStringI(&inner_, which, index));
}

inline void GlContextPtr::insert_event_marker_ext(String message) const {
    AzGlContextPtr_insertEventMarkerExt(&inner_, message.release());
}

inline void GlContextPtr::push_group_marker_ext(String message) const {
    AzGlContextPtr_pushGroupMarkerExt(&inner_, message.release());
}

inline void GlContextPtr::debug_message_insert_khr(AzGLenum source, AzGLenum type_, AzGLuint id, AzGLenum severity, String message) const {
    AzGlContextPtr_debugMessageInsertKhr(&inner_, source, type_, id, severity, message.release());
}

inline void GlContextPtr::push_debug_group_khr(AzGLenum source, AzGLuint id, String message) const {
    AzGlContextPtr_pushDebugGroupKhr(&inner_, source, id, message.release());
}

inline AzGLint GlContextPtr::get_frag_data_index(AzGLuint program, String name) const {
    return AzGlContextPtr_getFragDataIndex(&inner_, program, name.release());
}

inline void GlContextPtr::bind_frag_data_location_indexed(AzGLuint program, AzGLuint color_number, AzGLuint index, String name) const {
    AzGlContextPtr_bindFragDataLocationIndexed(&inner_, program, color_number, index, name.release());
}

inline void GlContextPtr::delete_() {
    AzGlContextPtr_delete(&inner_);
}

inline GlContextPtr GlContextPtr::clone() const {
    return GlContextPtr(AzGlContextPtr_clone(&inner_));
}

inline bool GlContextPtr::partialEq(const GlContextPtr& b) const {
    return AzGlContextPtr_partialEq(&inner_, b.ptr());
}

inline uint8_t GlContextPtr::partialCmp(const GlContextPtr& b) const {
    return AzGlContextPtr_partialCmp(&inner_, b.ptr());
}

inline uint8_t GlContextPtr::cmp(const GlContextPtr& b) const {
    return AzGlContextPtr_cmp(&inner_, b.ptr());
}

inline String GlContextPtr::toDbgString() const {
    return String(AzGlContextPtr_toDbgString(&inner_));
}

inline String GLuintVecSlice::toDbgString() const {
    return String(AzGLuintVecSlice_toDbgString(&inner_));
}

inline String GLintVecSlice::toDbgString() const {
    return String(AzGLintVecSlice_toDbgString(&inner_));
}

inline bool ImageDescriptor::partialEq(const ImageDescriptor& b) const {
    return AzImageDescriptor_partialEq(&inner_, b.ptr());
}

inline uint64_t ImageDescriptor::hash() const {
    return AzImageDescriptor_hash(&inner_);
}

inline uint8_t ImageDescriptor::partialCmp(const ImageDescriptor& b) const {
    return AzImageDescriptor_partialCmp(&inner_, b.ptr());
}

inline uint8_t ImageDescriptor::cmp(const ImageDescriptor& b) const {
    return AzImageDescriptor_cmp(&inner_, b.ptr());
}

inline String ImageDescriptor::toDbgString() const {
    return String(AzImageDescriptor_toDbgString(&inner_));
}

inline FontMetrics FontMetrics::zero() {
    return FontMetrics(AzFontMetrics_zero());
}

inline FontMetrics FontMetrics::default_() {
    return FontMetrics(AzFontMetrics_default());
}

inline bool FontMetrics::use_typo_metrics() const {
    return AzFontMetrics_useTypoMetrics(&inner_);
}

inline int16_t FontMetrics::get_ascender() const {
    return AzFontMetrics_getAscender(&inner_);
}

inline int16_t FontMetrics::get_descender() const {
    return AzFontMetrics_getDescender(&inner_);
}

inline int16_t FontMetrics::get_line_gap() const {
    return AzFontMetrics_getLineGap(&inner_);
}

inline int16_t FontMetrics::get_x_min() const {
    return AzFontMetrics_getXMin(&inner_);
}

inline int16_t FontMetrics::get_y_min() const {
    return AzFontMetrics_getYMin(&inner_);
}

inline int16_t FontMetrics::get_x_max() const {
    return AzFontMetrics_getXMax(&inner_);
}

inline int16_t FontMetrics::get_y_max() const {
    return AzFontMetrics_getYMax(&inner_);
}

inline uint16_t FontMetrics::get_advance_width_max() const {
    return AzFontMetrics_getAdvanceWidthMax(&inner_);
}

inline int16_t FontMetrics::get_min_left_side_bearing() const {
    return AzFontMetrics_getMinLeftSideBearing(&inner_);
}

inline int16_t FontMetrics::get_min_right_side_bearing() const {
    return AzFontMetrics_getMinRightSideBearing(&inner_);
}

inline int16_t FontMetrics::get_x_max_extent() const {
    return AzFontMetrics_getXMaxExtent(&inner_);
}

inline int16_t FontMetrics::get_x_avg_char_width() const {
    return AzFontMetrics_getXAvgCharWidth(&inner_);
}

inline int16_t FontMetrics::get_y_subscript_x_size() const {
    return AzFontMetrics_getYSubscriptXSize(&inner_);
}

inline int16_t FontMetrics::get_y_subscript_y_size() const {
    return AzFontMetrics_getYSubscriptYSize(&inner_);
}

inline int16_t FontMetrics::get_y_subscript_x_offset() const {
    return AzFontMetrics_getYSubscriptXOffset(&inner_);
}

inline int16_t FontMetrics::get_y_subscript_y_offset() const {
    return AzFontMetrics_getYSubscriptYOffset(&inner_);
}

inline int16_t FontMetrics::get_y_superscript_x_size() const {
    return AzFontMetrics_getYSuperscriptXSize(&inner_);
}

inline int16_t FontMetrics::get_y_superscript_y_size() const {
    return AzFontMetrics_getYSuperscriptYSize(&inner_);
}

inline int16_t FontMetrics::get_y_superscript_x_offset() const {
    return AzFontMetrics_getYSuperscriptXOffset(&inner_);
}

inline int16_t FontMetrics::get_y_superscript_y_offset() const {
    return AzFontMetrics_getYSuperscriptYOffset(&inner_);
}

inline void FontMetrics::delete_() {
    AzFontMetrics_delete(&inner_);
}

inline FontMetrics FontMetrics::clone() const {
    return FontMetrics(AzFontMetrics_clone(&inner_));
}

inline bool FontMetrics::partialEq(const FontMetrics& b) const {
    return AzFontMetrics_partialEq(&inner_, b.ptr());
}

inline uint64_t FontMetrics::hash() const {
    return AzFontMetrics_hash(&inner_);
}

inline uint8_t FontMetrics::partialCmp(const FontMetrics& b) const {
    return AzFontMetrics_partialCmp(&inner_, b.ptr());
}

inline uint8_t FontMetrics::cmp(const FontMetrics& b) const {
    return AzFontMetrics_cmp(&inner_, b.ptr());
}

inline String FontMetrics::toDbgString() const {
    return String(AzFontMetrics_toDbgString(&inner_));
}

inline FontRef FontRef::create(const void* parsed, AzFontRefDestructorCallbackType destructor) {
    return FontRef(AzFontRef_create(parsed, destructor));
}

inline OptionFontRef FontRef::parse(LoadedFontSource source) {
    return OptionFontRef(AzFontRef_parse(source.release()));
}

inline U8Vec FontRef::get_bytes() const {
    return U8Vec(AzFontRef_getBytes(&inner_));
}

inline FontMetrics FontRef::get_font_metrics() const {
    return FontMetrics(AzFontRef_getFontMetrics(&inner_));
}

inline uint64_t FontRef::get_hash() const {
    return AzFontRef_getHash(&inner_);
}

inline void FontRef::delete_() {
    AzFontRef_delete(&inner_);
}

inline FontRef FontRef::clone() const {
    return FontRef(AzFontRef_clone(&inner_));
}

inline bool FontRef::partialEq(const FontRef& b) const {
    return AzFontRef_partialEq(&inner_, b.ptr());
}

inline uint64_t FontRef::hash() const {
    return AzFontRef_hash(&inner_);
}

inline uint8_t FontRef::partialCmp(const FontRef& b) const {
    return AzFontRef_partialCmp(&inner_, b.ptr());
}

inline uint8_t FontRef::cmp(const FontRef& b) const {
    return AzFontRef_cmp(&inner_, b.ptr());
}

inline String FontRef::toDbgString() const {
    return String(AzFontRef_toDbgString(&inner_));
}

inline LogicalRect LogicalRect::create(LogicalPosition origin, LogicalSize size) {
    return LogicalRect(AzLogicalRect_create(origin.release(), size.release()));
}

inline LogicalRect LogicalRect::zero() {
    return LogicalRect(AzLogicalRect_zero());
}

inline LogicalRect LogicalRect::default_() {
    return LogicalRect(AzLogicalRect_default());
}

inline float LogicalRect::max_x() const {
    return AzLogicalRect_maxX(&inner_);
}

inline float LogicalRect::min_x() const {
    return AzLogicalRect_minX(&inner_);
}

inline float LogicalRect::max_y() const {
    return AzLogicalRect_maxY(&inner_);
}

inline float LogicalRect::min_y() const {
    return AzLogicalRect_minY(&inner_);
}

inline bool LogicalRect::contains(LogicalPosition point) const {
    return AzLogicalRect_contains(&inner_, point.release());
}

inline bool LogicalRect::intersects(LogicalRect other) const {
    return AzLogicalRect_intersects(&inner_, other.release());
}

inline bool LogicalRect::partialEq(const LogicalRect& b) const {
    return AzLogicalRect_partialEq(&inner_, b.ptr());
}

inline uint64_t LogicalRect::hash() const {
    return AzLogicalRect_hash(&inner_);
}

inline uint8_t LogicalRect::partialCmp(const LogicalRect& b) const {
    return AzLogicalRect_partialCmp(&inner_, b.ptr());
}

inline uint8_t LogicalRect::cmp(const LogicalRect& b) const {
    return AzLogicalRect_cmp(&inner_, b.ptr());
}

inline String LogicalRect::toDbgString() const {
    return String(AzLogicalRect_toDbgString(&inner_));
}

inline void ShapeCircle::delete_() {
    AzShapeCircle_delete(&inner_);
}

inline ShapeCircle ShapeCircle::clone() const {
    return ShapeCircle(AzShapeCircle_clone(&inner_));
}

inline bool ShapeCircle::partialEq(const ShapeCircle& b) const {
    return AzShapeCircle_partialEq(&inner_, b.ptr());
}

inline uint64_t ShapeCircle::hash() const {
    return AzShapeCircle_hash(&inner_);
}

inline uint8_t ShapeCircle::partialCmp(const ShapeCircle& b) const {
    return AzShapeCircle_partialCmp(&inner_, b.ptr());
}

inline uint8_t ShapeCircle::cmp(const ShapeCircle& b) const {
    return AzShapeCircle_cmp(&inner_, b.ptr());
}

inline String ShapeCircle::toDbgString() const {
    return String(AzShapeCircle_toDbgString(&inner_));
}

inline bool SvgLine::partialEq(const SvgLine& b) const {
    return AzSvgLine_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgLine::partialCmp(const SvgLine& b) const {
    return AzSvgLine_partialCmp(&inner_, b.ptr());
}

inline String SvgLine::toDbgString() const {
    return String(AzSvgLine_toDbgString(&inner_));
}

inline bool SvgCubicCurve::partialEq(const SvgCubicCurve& b) const {
    return AzSvgCubicCurve_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgCubicCurve::partialCmp(const SvgCubicCurve& b) const {
    return AzSvgCubicCurve_partialCmp(&inner_, b.ptr());
}

inline String SvgCubicCurve::toDbgString() const {
    return String(AzSvgCubicCurve_toDbgString(&inner_));
}

inline bool SvgQuadraticCurve::partialEq(const SvgQuadraticCurve& b) const {
    return AzSvgQuadraticCurve_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgQuadraticCurve::partialCmp(const SvgQuadraticCurve& b) const {
    return AzSvgQuadraticCurve_partialCmp(&inner_, b.ptr());
}

inline String SvgQuadraticCurve::toDbgString() const {
    return String(AzSvgQuadraticCurve_toDbgString(&inner_));
}

inline void GetSystemTimeCallback::delete_() {
    AzGetSystemTimeCallback_delete(&inner_);
}

inline GetSystemTimeCallback GetSystemTimeCallback::clone() const {
    return GetSystemTimeCallback(AzGetSystemTimeCallback_clone(&inner_));
}

inline bool GetSystemTimeCallback::partialEq(const GetSystemTimeCallback& b) const {
    return AzGetSystemTimeCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t GetSystemTimeCallback::hash() const {
    return AzGetSystemTimeCallback_hash(&inner_);
}

inline uint8_t GetSystemTimeCallback::partialCmp(const GetSystemTimeCallback& b) const {
    return AzGetSystemTimeCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t GetSystemTimeCallback::cmp(const GetSystemTimeCallback& b) const {
    return AzGetSystemTimeCallback_cmp(&inner_, b.ptr());
}

inline String GetSystemTimeCallback::toDbgString() const {
    return String(AzGetSystemTimeCallback_toDbgString(&inner_));
}

inline ScrollIntoViewOptions ScrollIntoViewOptions::nearest() {
    return ScrollIntoViewOptions(AzScrollIntoViewOptions_nearest());
}

inline ScrollIntoViewOptions ScrollIntoViewOptions::center() {
    return ScrollIntoViewOptions(AzScrollIntoViewOptions_center());
}

inline ScrollIntoViewOptions ScrollIntoViewOptions::start() {
    return ScrollIntoViewOptions(AzScrollIntoViewOptions_start());
}

inline ScrollIntoViewOptions ScrollIntoViewOptions::end() {
    return ScrollIntoViewOptions(AzScrollIntoViewOptions_end());
}

inline ScrollIntoViewOptions ScrollIntoViewOptions::default_() {
    return ScrollIntoViewOptions(AzScrollIntoViewOptions_default());
}

inline ScrollIntoViewOptions ScrollIntoViewOptions::with_instant() const {
    return ScrollIntoViewOptions(AzScrollIntoViewOptions_withInstant(inner_));
}

inline ScrollIntoViewOptions ScrollIntoViewOptions::with_smooth() const {
    return ScrollIntoViewOptions(AzScrollIntoViewOptions_withSmooth(inner_));
}

inline bool ScrollIntoViewOptions::partialEq(const ScrollIntoViewOptions& b) const {
    return AzScrollIntoViewOptions_partialEq(&inner_, b.ptr());
}

inline uint64_t ScrollIntoViewOptions::hash() const {
    return AzScrollIntoViewOptions_hash(&inner_);
}

inline String ScrollIntoViewOptions::toDbgString() const {
    return String(AzScrollIntoViewOptions_toDbgString(&inner_));
}

inline void NonXmlCharError::delete_() {
    AzNonXmlCharError_delete(&inner_);
}

inline NonXmlCharError NonXmlCharError::clone() const {
    return NonXmlCharError(AzNonXmlCharError_clone(&inner_));
}

inline bool NonXmlCharError::partialEq(const NonXmlCharError& b) const {
    return AzNonXmlCharError_partialEq(&inner_, b.ptr());
}

inline uint8_t NonXmlCharError::partialCmp(const NonXmlCharError& b) const {
    return AzNonXmlCharError_partialCmp(&inner_, b.ptr());
}

inline String NonXmlCharError::toDbgString() const {
    return String(AzNonXmlCharError_toDbgString(&inner_));
}

inline void InvalidCharError::delete_() {
    AzInvalidCharError_delete(&inner_);
}

inline InvalidCharError InvalidCharError::clone() const {
    return InvalidCharError(AzInvalidCharError_clone(&inner_));
}

inline bool InvalidCharError::partialEq(const InvalidCharError& b) const {
    return AzInvalidCharError_partialEq(&inner_, b.ptr());
}

inline uint8_t InvalidCharError::partialCmp(const InvalidCharError& b) const {
    return AzInvalidCharError_partialCmp(&inner_, b.ptr());
}

inline String InvalidCharError::toDbgString() const {
    return String(AzInvalidCharError_toDbgString(&inner_));
}

inline void InvalidQuoteError::delete_() {
    AzInvalidQuoteError_delete(&inner_);
}

inline InvalidQuoteError InvalidQuoteError::clone() const {
    return InvalidQuoteError(AzInvalidQuoteError_clone(&inner_));
}

inline bool InvalidQuoteError::partialEq(const InvalidQuoteError& b) const {
    return AzInvalidQuoteError_partialEq(&inner_, b.ptr());
}

inline uint8_t InvalidQuoteError::partialCmp(const InvalidQuoteError& b) const {
    return AzInvalidQuoteError_partialCmp(&inner_, b.ptr());
}

inline String InvalidQuoteError::toDbgString() const {
    return String(AzInvalidQuoteError_toDbgString(&inner_));
}

inline void InvalidSpaceError::delete_() {
    AzInvalidSpaceError_delete(&inner_);
}

inline InvalidSpaceError InvalidSpaceError::clone() const {
    return InvalidSpaceError(AzInvalidSpaceError_clone(&inner_));
}

inline bool InvalidSpaceError::partialEq(const InvalidSpaceError& b) const {
    return AzInvalidSpaceError_partialEq(&inner_, b.ptr());
}

inline uint8_t InvalidSpaceError::partialCmp(const InvalidSpaceError& b) const {
    return AzInvalidSpaceError_partialCmp(&inner_, b.ptr());
}

inline String InvalidSpaceError::toDbgString() const {
    return String(AzInvalidSpaceError_toDbgString(&inner_));
}

inline ErrorLocationRange ErrorLocationRange::default_() {
    return ErrorLocationRange(AzErrorLocationRange_default());
}

inline bool ErrorLocationRange::partialEq(const ErrorLocationRange& b) const {
    return AzErrorLocationRange_partialEq(&inner_, b.ptr());
}

inline uint64_t ErrorLocationRange::hash() const {
    return AzErrorLocationRange_hash(&inner_);
}

inline uint8_t ErrorLocationRange::partialCmp(const ErrorLocationRange& b) const {
    return AzErrorLocationRange_partialCmp(&inner_, b.ptr());
}

inline uint8_t ErrorLocationRange::cmp(const ErrorLocationRange& b) const {
    return AzErrorLocationRange_cmp(&inner_, b.ptr());
}

inline String ErrorLocationRange::toDbgString() const {
    return String(AzErrorLocationRange_toDbgString(&inner_));
}

inline RendererOptions RendererOptions::default_() {
    return RendererOptions(AzRendererOptions_default());
}

inline bool RendererOptions::partialEq(const RendererOptions& b) const {
    return AzRendererOptions_partialEq(&inner_, b.ptr());
}

inline uint64_t RendererOptions::hash() const {
    return AzRendererOptions_hash(&inner_);
}

inline uint8_t RendererOptions::partialCmp(const RendererOptions& b) const {
    return AzRendererOptions_partialCmp(&inner_, b.ptr());
}

inline uint8_t RendererOptions::cmp(const RendererOptions& b) const {
    return AzRendererOptions_cmp(&inner_, b.ptr());
}

inline String RendererOptions::toDbgString() const {
    return String(AzRendererOptions_toDbgString(&inner_));
}

inline void FileMetadata::delete_() {
    AzFileMetadata_delete(&inner_);
}

inline FileMetadata FileMetadata::clone() const {
    return FileMetadata(AzFileMetadata_clone(&inner_));
}

inline bool FileMetadata::partialEq(const FileMetadata& b) const {
    return AzFileMetadata_partialEq(&inner_, b.ptr());
}

inline String FileMetadata::toDbgString() const {
    return String(AzFileMetadata_toDbgString(&inner_));
}

inline bool SensorReading::partialEq(const SensorReading& b) const {
    return AzSensorReading_partialEq(&inner_, b.ptr());
}

inline String SensorReading::toDbgString() const {
    return String(AzSensorReading_toDbgString(&inner_));
}

inline bool GamepadState::is_pressed(AzGamepadButton button) const {
    return AzGamepadState_isPressed(&inner_, button);
}

inline float GamepadState::axis(AzGamepadAxis axis) const {
    return AzGamepadState_axis(&inner_, axis);
}

inline bool GamepadState::partialEq(const GamepadState& b) const {
    return AzGamepadState_partialEq(&inner_, b.ptr());
}

inline String GamepadState::toDbgString() const {
    return String(AzGamepadState_toDbgString(&inner_));
}

inline CameraConfig CameraConfig::default_() {
    return CameraConfig(AzCameraConfig_default());
}

inline bool CameraConfig::partialEq(const CameraConfig& b) const {
    return AzCameraConfig_partialEq(&inner_, b.ptr());
}

inline String CameraConfig::toDbgString() const {
    return String(AzCameraConfig_toDbgString(&inner_));
}

inline ScreenCaptureConfig ScreenCaptureConfig::default_() {
    return ScreenCaptureConfig(AzScreenCaptureConfig_default());
}

inline bool ScreenCaptureConfig::partialEq(const ScreenCaptureConfig& b) const {
    return AzScreenCaptureConfig_partialEq(&inner_, b.ptr());
}

inline String ScreenCaptureConfig::toDbgString() const {
    return String(AzScreenCaptureConfig_toDbgString(&inner_));
}

inline bool DetectedRotation::partialEq(const DetectedRotation& b) const {
    return AzDetectedRotation_partialEq(&inner_, b.ptr());
}

inline String DetectedRotation::toDbgString() const {
    return String(AzDetectedRotation_toDbgString(&inner_));
}

inline bool DetectedLongPress::partialEq(const DetectedLongPress& b) const {
    return AzDetectedLongPress_partialEq(&inner_, b.ptr());
}

inline String DetectedLongPress::toDbgString() const {
    return String(AzDetectedLongPress_toDbgString(&inner_));
}

inline bool IcuDateTime::partialEq(const IcuDateTime& b) const {
    return AzIcuDateTime_partialEq(&inner_, b.ptr());
}

inline String IcuDateTime::toDbgString() const {
    return String(AzIcuDateTime_toDbgString(&inner_));
}

inline HidpiAdjustedBounds HidpiAdjustedBounds::from_bounds(LayoutSize bounds, DpiScaleFactor hidpi_factor) {
    return HidpiAdjustedBounds(AzHidpiAdjustedBounds_fromBounds(bounds.release(), hidpi_factor.release()));
}

inline AzPhysicalSizeU32 HidpiAdjustedBounds::get_physical_size() const {
    return AzHidpiAdjustedBounds_getPhysicalSize(&inner_);
}

inline LogicalSize HidpiAdjustedBounds::get_logical_size() const {
    return LogicalSize(AzHidpiAdjustedBounds_getLogicalSize(&inner_));
}

inline DpiScaleFactor HidpiAdjustedBounds::get_hidpi_factor() const {
    return DpiScaleFactor(AzHidpiAdjustedBounds_getHidpiFactor(&inner_));
}

inline String HidpiAdjustedBounds::toDbgString() const {
    return String(AzHidpiAdjustedBounds_toDbgString(&inner_));
}

inline WindowSize WindowSize::default_() {
    return WindowSize(AzWindowSize_default());
}

inline bool WindowSize::partialEq(const WindowSize& b) const {
    return AzWindowSize_partialEq(&inner_, b.ptr());
}

inline uint8_t WindowSize::partialCmp(const WindowSize& b) const {
    return AzWindowSize_partialCmp(&inner_, b.ptr());
}

inline String WindowSize::toDbgString() const {
    return String(AzWindowSize_toDbgString(&inner_));
}

inline void TextOpMoveCursor::delete_() {
    AzTextOpMoveCursor_delete(&inner_);
}

inline TextOpMoveCursor TextOpMoveCursor::clone() const {
    return TextOpMoveCursor(AzTextOpMoveCursor_clone(&inner_));
}

inline String TextOpMoveCursor::toDbgString() const {
    return String(AzTextOpMoveCursor_toDbgString(&inner_));
}

inline OptionRefAny CallbackInfo::get_ctx() const {
    return OptionRefAny(AzCallbackInfo_getCtx(&inner_));
}

inline OptionGlContextPtr CallbackInfo::get_gl_context() const {
    return OptionGlContextPtr(AzCallbackInfo_getGlContext(&inner_));
}

inline void CallbackInfo::add_timer(TimerId timer_id, Timer timer) {
    AzCallbackInfo_addTimer(&inner_, timer_id.release(), timer.release());
}

inline void CallbackInfo::remove_timer(TimerId timer_id) {
    AzCallbackInfo_removeTimer(&inner_, timer_id.release());
}

inline void CallbackInfo::add_thread(ThreadId thread_id, Thread thread) {
    AzCallbackInfo_addThread(&inner_, thread_id.release(), thread.release());
}

inline void CallbackInfo::remove_thread(ThreadId thread_id) {
    AzCallbackInfo_removeThread(&inner_, thread_id.release());
}

inline void CallbackInfo::stop_propagation() {
    AzCallbackInfo_stopPropagation(&inner_);
}

inline void CallbackInfo::stop_immediate_propagation() {
    AzCallbackInfo_stopImmediatePropagation(&inner_);
}

inline void CallbackInfo::create_window(WindowCreateOptions options) {
    AzCallbackInfo_createWindow(&inner_, options.release());
}

inline void CallbackInfo::close_window() {
    AzCallbackInfo_closeWindow(&inner_);
}

inline void CallbackInfo::modify_window_state(FullWindowState state) {
    AzCallbackInfo_modifyWindowState(&inner_, state.release());
}

inline void CallbackInfo::add_image_to_cache(String id, ImageRef image) {
    AzCallbackInfo_addImageToCache(&inner_, id.release(), image.release());
}

inline void CallbackInfo::remove_image_from_cache(String id) {
    AzCallbackInfo_removeImageFromCache(&inner_, id.release());
}

inline void CallbackInfo::reload_system_fonts() {
    AzCallbackInfo_reloadSystemFonts(&inner_);
}

inline void CallbackInfo::prevent_default() {
    AzCallbackInfo_preventDefault(&inner_);
}

inline void CallbackInfo::open_menu(Menu menu) {
    AzCallbackInfo_openMenu(&inner_, menu.release());
}

inline void CallbackInfo::open_menu_at(Menu menu, LogicalPosition position) {
    AzCallbackInfo_openMenuAt(&inner_, menu.release(), position.release());
}

inline void CallbackInfo::show_tooltip(String text) {
    AzCallbackInfo_showTooltip(&inner_, text.release());
}

inline void CallbackInfo::show_tooltip_at(String text, LogicalPosition position) {
    AzCallbackInfo_showTooltipAt(&inner_, text.release(), position.release());
}

inline void CallbackInfo::hide_tooltip() {
    AzCallbackInfo_hideTooltip(&inner_);
}

inline bool CallbackInfo::open_menu_for_hit_node(Menu menu) {
    return AzCallbackInfo_openMenuForHitNode(&inner_, menu.release());
}

inline WindowFlags CallbackInfo::get_current_window_flags() const {
    return WindowFlags(AzCallbackInfo_getCurrentWindowFlags(&inner_));
}

inline OptionLogicalPosition CallbackInfo::get_scroll_offset() const {
    return OptionLogicalPosition(AzCallbackInfo_getScrollOffset(&inner_));
}

inline KeyboardState CallbackInfo::get_current_keyboard_state() const {
    return KeyboardState(AzCallbackInfo_getCurrentKeyboardState(&inner_));
}

inline MouseState CallbackInfo::get_current_mouse_state() const {
    return MouseState(AzCallbackInfo_getCurrentMouseState(&inner_));
}

inline OptionCursorNodePosition CallbackInfo::get_cursor_relative_to_node() const {
    return OptionCursorNodePosition(AzCallbackInfo_getCursorRelativeToNode(&inner_));
}

inline OptionLogicalPosition CallbackInfo::get_cursor_relative_to_viewport() const {
    return OptionLogicalPosition(AzCallbackInfo_getCursorRelativeToViewport(&inner_));
}

inline OptionLogicalPosition CallbackInfo::get_cursor_position() const {
    return OptionLogicalPosition(AzCallbackInfo_getCursorPosition(&inner_));
}

inline OptionScreenPosition CallbackInfo::get_cursor_position_screen() const {
    return OptionScreenPosition(AzCallbackInfo_getCursorPositionScreen(&inner_));
}

inline OptionDragDelta CallbackInfo::get_drag_delta() const {
    return OptionDragDelta(AzCallbackInfo_getDragDelta(&inner_));
}

inline OptionDragDelta CallbackInfo::get_drag_delta_screen() const {
    return OptionDragDelta(AzCallbackInfo_getDragDeltaScreen(&inner_));
}

inline OptionDragDelta CallbackInfo::get_drag_delta_screen_incremental() const {
    return OptionDragDelta(AzCallbackInfo_getDragDeltaScreenIncremental(&inner_));
}

inline void CallbackInfo::begin_interactive_move() {
    AzCallbackInfo_beginInteractiveMove(&inner_);
}

inline MonitorVec CallbackInfo::get_monitors() const {
    return MonitorVec(AzCallbackInfo_getMonitors(&inner_));
}

inline OptionMonitor CallbackInfo::get_current_monitor() const {
    return OptionMonitor(AzCallbackInfo_getCurrentMonitor(&inner_));
}

inline AzInstant CallbackInfo::get_current_time() const {
    return AzCallbackInfo_getCurrentTime(&inner_);
}

inline bool CallbackInfo::is_dom_focused(DomId dom_id) const {
    return AzCallbackInfo_isDomFocused(&inner_, dom_id.release());
}

inline bool CallbackInfo::is_pen_in_contact() const {
    return AzCallbackInfo_isPenInContact(&inner_);
}

inline bool CallbackInfo::is_pen_eraser() const {
    return AzCallbackInfo_isPenEraser(&inner_);
}

inline bool CallbackInfo::is_pen_barrel_button_pressed() const {
    return AzCallbackInfo_isPenBarrelButtonPressed(&inner_);
}

inline void CallbackInfo::set_focus_to_path(DomId dom_id, CssPath css_path) {
    AzCallbackInfo_setFocusToPath(&inner_, dom_id.release(), css_path.release());
}

inline void CallbackInfo::focus_next() {
    AzCallbackInfo_focusNext(&inner_);
}

inline void CallbackInfo::focus_previous() {
    AzCallbackInfo_focusPrevious(&inner_);
}

inline void CallbackInfo::focus_first() {
    AzCallbackInfo_focusFirst(&inner_);
}

inline void CallbackInfo::focus_last() {
    AzCallbackInfo_focusLast(&inner_);
}

inline void CallbackInfo::clear_focus() {
    AzCallbackInfo_clearFocus(&inner_);
}

inline bool CallbackInfo::is_dragging() const {
    return AzCallbackInfo_isDragging(&inner_);
}

inline bool CallbackInfo::is_drag_active() const {
    return AzCallbackInfo_isDragActive(&inner_);
}

inline bool CallbackInfo::is_node_drag_active() const {
    return AzCallbackInfo_isNodeDragActive(&inner_);
}

inline bool CallbackInfo::is_file_drag_active() const {
    return AzCallbackInfo_isFileDragActive(&inner_);
}

inline bool CallbackInfo::has_sufficient_history_for_gestures() const {
    return AzCallbackInfo_hasSufficientHistoryForGestures(&inner_);
}

inline void CallbackInfo::change_node_text(DomNodeId node_id, String text) {
    AzCallbackInfo_changeNodeText(&inner_, node_id.release(), text.release());
}

inline void CallbackInfo::update_image_callback(DomId dom_id, NodeId node_id) {
    AzCallbackInfo_updateImageCallback(&inner_, dom_id.release(), node_id.release());
}

inline void CallbackInfo::update_all_image_callbacks() {
    AzCallbackInfo_updateAllImageCallbacks(&inner_);
}

inline void CallbackInfo::trigger_virtual_view_rerender(DomId dom_id, NodeId node_id) {
    AzCallbackInfo_triggerVirtualViewRerender(&inner_, dom_id.release(), node_id.release());
}

inline NodeHierarchyItemId CallbackInfo::get_node_id_by_id_attribute(DomId dom_id, String id) const {
    return NodeHierarchyItemId(AzCallbackInfo_getNodeIdByIdAttribute(&inner_, dom_id.release(), id.release()));
}

inline NodeHierarchyItemId CallbackInfo::get_parent_node(DomId dom_id, NodeId node_id) const {
    return NodeHierarchyItemId(AzCallbackInfo_getParentNode(&inner_, dom_id.release(), node_id.release()));
}

inline NodeHierarchyItemId CallbackInfo::get_next_sibling_node(DomId dom_id, NodeId node_id) const {
    return NodeHierarchyItemId(AzCallbackInfo_getNextSiblingNode(&inner_, dom_id.release(), node_id.release()));
}

inline NodeHierarchyItemId CallbackInfo::get_previous_sibling_node(DomId dom_id, NodeId node_id) const {
    return NodeHierarchyItemId(AzCallbackInfo_getPreviousSiblingNode(&inner_, dom_id.release(), node_id.release()));
}

inline NodeHierarchyItemId CallbackInfo::get_first_child_node(DomId dom_id, NodeId node_id) const {
    return NodeHierarchyItemId(AzCallbackInfo_getFirstChildNode(&inner_, dom_id.release(), node_id.release()));
}

inline NodeHierarchyItemId CallbackInfo::get_last_child_node(DomId dom_id, NodeId node_id) const {
    return NodeHierarchyItemId(AzCallbackInfo_getLastChildNode(&inner_, dom_id.release(), node_id.release()));
}

inline void CallbackInfo::change_node_image_mask(DomId dom_id, NodeId node_id, ImageMask mask) {
    AzCallbackInfo_changeNodeImageMask(&inner_, dom_id.release(), node_id.release(), mask.release());
}

inline void CallbackInfo::set_css_property(DomNodeId node_id, AzCssProperty property) {
    AzCallbackInfo_setCssProperty(&inner_, node_id.release(), property);
}

inline void CallbackInfo::scroll_to(DomId dom_id, NodeHierarchyItemId node_id, LogicalPosition position) {
    AzCallbackInfo_scrollTo(&inner_, dom_id.release(), node_id.release(), position.release());
}

inline void CallbackInfo::insert_text(DomId dom_id, NodeId node_id, String text) {
    AzCallbackInfo_insertText(&inner_, dom_id.release(), node_id.release(), text.release());
}

inline SelectionId CallbackInfo::add_cursor(DomId dom_id, NodeId node_id, TextCursor cursor) {
    return SelectionId(AzCallbackInfo_addCursor(&inner_, dom_id.release(), node_id.release(), cursor.release()));
}

inline SelectionId CallbackInfo::add_selection_range(DomId dom_id, NodeId node_id, SelectionRange range) {
    return SelectionId(AzCallbackInfo_addSelectionRange(&inner_, dom_id.release(), node_id.release(), range.release()));
}

inline bool CallbackInfo::remove_selection_by_id(SelectionId selection_id) {
    return AzCallbackInfo_removeSelectionById(&inner_, selection_id.release());
}

inline size_t CallbackInfo::get_selection_count(DomId dom_id) const {
    return AzCallbackInfo_getSelectionCount(&inner_, dom_id.release());
}

inline bool CallbackInfo::open_menu_for_node(Menu menu, DomNodeId node_id) {
    return AzCallbackInfo_openMenuForNode(&inner_, menu.release(), node_id.release());
}

inline OptionLogicalSize CallbackInfo::get_node_size(DomNodeId node_id) const {
    return OptionLogicalSize(AzCallbackInfo_getNodeSize(&inner_, node_id.release()));
}

inline OptionLogicalPosition CallbackInfo::get_node_position(DomNodeId node_id) const {
    return OptionLogicalPosition(AzCallbackInfo_getNodePosition(&inner_, node_id.release()));
}

inline OptionLogicalRect CallbackInfo::get_node_rect(DomNodeId node_id) const {
    return OptionLogicalRect(AzCallbackInfo_getNodeRect(&inner_, node_id.release()));
}

inline OptionLogicalRect CallbackInfo::get_hit_node_rect() const {
    return OptionLogicalRect(AzCallbackInfo_getHitNodeRect(&inner_));
}

inline OptionTimer CallbackInfo::get_timer(TimerId timer_id) const {
    return OptionTimer(AzCallbackInfo_getTimer(&inner_, timer_id.release()));
}

inline TimerIdVec CallbackInfo::get_timer_ids() const {
    return TimerIdVec(AzCallbackInfo_getTimerIds(&inner_));
}

inline OptionThread CallbackInfo::get_thread(ThreadId thread_id) const {
    return OptionThread(AzCallbackInfo_getThread(&inner_, thread_id.release()));
}

inline ThreadIdVec CallbackInfo::get_thread_ids() const {
    return ThreadIdVec(AzCallbackInfo_getThreadIds(&inner_));
}

inline DomIdVec CallbackInfo::get_dom_ids() const {
    return DomIdVec(AzCallbackInfo_getDomIds(&inner_));
}

inline DomNodeId CallbackInfo::get_hit_node() const {
    return DomNodeId(AzCallbackInfo_getHitNode(&inner_));
}

inline OptionDomNodeId CallbackInfo::get_parent(DomNodeId node_id) const {
    return OptionDomNodeId(AzCallbackInfo_getParent(&inner_, node_id.release()));
}

inline OptionDomNodeId CallbackInfo::get_previous_sibling(DomNodeId node_id) const {
    return OptionDomNodeId(AzCallbackInfo_getPreviousSibling(&inner_, node_id.release()));
}

inline OptionDomNodeId CallbackInfo::get_next_sibling(DomNodeId node_id) const {
    return OptionDomNodeId(AzCallbackInfo_getNextSibling(&inner_, node_id.release()));
}

inline OptionDomNodeId CallbackInfo::get_first_child(DomNodeId node_id) const {
    return OptionDomNodeId(AzCallbackInfo_getFirstChild(&inner_, node_id.release()));
}

inline OptionDomNodeId CallbackInfo::get_last_child(DomNodeId node_id) const {
    return OptionDomNodeId(AzCallbackInfo_getLastChild(&inner_, node_id.release()));
}

inline OptionRefAny CallbackInfo::get_dataset(DomNodeId node_id) {
    return OptionRefAny(AzCallbackInfo_getDataset(&inner_, node_id.release()));
}

inline OptionDomNodeId CallbackInfo::get_node_id_of_root_dataset(RefAny search_key) {
    return OptionDomNodeId(AzCallbackInfo_getNodeIdOfRootDataset(&inner_, search_key.release()));
}

inline OptionString CallbackInfo::get_string_contents(DomNodeId node_id) const {
    return OptionString(AzCallbackInfo_getStringContents(&inner_, node_id.release()));
}

inline OptionSelectionState CallbackInfo::get_selection(DomId dom_id) const {
    return OptionSelectionState(AzCallbackInfo_getSelection(&inner_, dom_id.release()));
}

inline bool CallbackInfo::has_selection(DomId dom_id) const {
    return AzCallbackInfo_hasSelection(&inner_, dom_id.release());
}

inline OptionTextCursor CallbackInfo::get_primary_cursor(DomId dom_id) const {
    return OptionTextCursor(AzCallbackInfo_getPrimaryCursor(&inner_, dom_id.release()));
}

inline SelectionRangeVec CallbackInfo::get_selection_ranges(DomId dom_id) const {
    return SelectionRangeVec(AzCallbackInfo_getSelectionRanges(&inner_, dom_id.release()));
}

inline FullWindowState CallbackInfo::get_current_window_state() const {
    return FullWindowState(AzCallbackInfo_getCurrentWindowState(&inner_));
}

inline OptionWindowFlags CallbackInfo::get_previous_window_flags() const {
    return OptionWindowFlags(AzCallbackInfo_getPreviousWindowFlags(&inner_));
}

inline OptionKeyboardState CallbackInfo::get_previous_keyboard_state() const {
    return OptionKeyboardState(AzCallbackInfo_getPreviousKeyboardState(&inner_));
}

inline OptionMouseState CallbackInfo::get_previous_mouse_state() const {
    return OptionMouseState(AzCallbackInfo_getPreviousMouseState(&inner_));
}

inline AzRawWindowHandle CallbackInfo::get_current_window_handle() const {
    return AzCallbackInfo_getCurrentWindowHandle(&inner_);
}

inline OptionLogicalRect CallbackInfo::get_hit_node_layout_rect() const {
    return OptionLogicalRect(AzCallbackInfo_getHitNodeLayoutRect(&inner_));
}

inline OptionCssProperty CallbackInfo::get_computed_css_property(DomNodeId node_id, AzCssPropertyType property_type) const {
    return OptionCssProperty(AzCallbackInfo_getComputedCssProperty(&inner_, node_id.release(), property_type));
}

inline OptionCssProperty CallbackInfo::get_computed_width(DomNodeId node_id) const {
    return OptionCssProperty(AzCallbackInfo_getComputedWidth(&inner_, node_id.release()));
}

inline OptionCssProperty CallbackInfo::get_computed_height(DomNodeId node_id) const {
    return OptionCssProperty(AzCallbackInfo_getComputedHeight(&inner_, node_id.release()));
}

inline GetSystemTimeCallback CallbackInfo::get_system_time_fn() const {
    return GetSystemTimeCallback(AzCallbackInfo_getSystemTimeFn(&inner_));
}

inline bool CallbackInfo::is_node_focused(DomNodeId node_id) const {
    return AzCallbackInfo_isNodeFocused(&inner_, node_id.release());
}

inline OptionPenState CallbackInfo::get_pen_state() const {
    return OptionPenState(AzCallbackInfo_getPenState(&inner_));
}

inline OptionF32 CallbackInfo::get_pen_pressure() const {
    return OptionF32(AzCallbackInfo_getPenPressure(&inner_));
}

inline OptionPenTilt CallbackInfo::get_pen_tilt() const {
    return OptionPenTilt(AzCallbackInfo_getPenTilt(&inner_));
}

inline OptionU64 CallbackInfo::get_current_event_id() const {
    return OptionU64(AzCallbackInfo_getCurrentEventId(&inner_));
}

inline void CallbackInfo::set_focus_to_node(DomId dom_id, NodeId node_id) {
    AzCallbackInfo_setFocusToNode(&inner_, dom_id.release(), node_id.release());
}

inline OptionDomNodeId CallbackInfo::get_focused_node() const {
    return OptionDomNodeId(AzCallbackInfo_getFocusedNode(&inner_));
}

inline bool CallbackInfo::has_focus(DomNodeId node_id) const {
    return AzCallbackInfo_hasFocus(&inner_, node_id.release());
}

inline OptionString CallbackInfo::get_hovered_file() const {
    return OptionString(AzCallbackInfo_getHoveredFile(&inner_));
}

inline OptionString CallbackInfo::get_dropped_file() const {
    return OptionString(AzCallbackInfo_getDroppedFile(&inner_));
}

inline OptionDomNodeId CallbackInfo::get_dragged_node() const {
    return OptionDomNodeId(AzCallbackInfo_getDraggedNode(&inner_));
}

inline OptionString CallbackInfo::get_dragged_file() const {
    return OptionString(AzCallbackInfo_getDraggedFile(&inner_));
}

inline OptionDragState CallbackInfo::get_drag_state() const {
    return OptionDragState(AzCallbackInfo_getDragState(&inner_));
}

inline OptionLogicalPosition CallbackInfo::get_scroll_offset_for_node(DomId dom_id, NodeId node_id) const {
    return OptionLogicalPosition(AzCallbackInfo_getScrollOffsetForNode(&inner_, dom_id.release(), node_id.release()));
}

inline OptionLogicalPosition CallbackInfo::get_scroll_delta(DomId dom_id, NodeId node_id) const {
    return OptionLogicalPosition(AzCallbackInfo_getScrollDelta(&inner_, dom_id.release(), node_id.release()));
}

inline bool CallbackInfo::had_scroll_activity(DomId dom_id, NodeId node_id) const {
    return AzCallbackInfo_hadScrollActivity(&inner_, dom_id.release(), node_id.release());
}

inline OptionScrollState CallbackInfo::get_scroll_state(DomId dom_id, NodeId node_id) const {
    return OptionScrollState(AzCallbackInfo_getScrollState(&inner_, dom_id.release(), node_id.release()));
}

inline OptionSelectionRange CallbackInfo::inspect_paste_target_range(DomNodeId target) const {
    return OptionSelectionRange(AzCallbackInfo_inspectPasteTargetRange(&inner_, target.release()));
}

inline OptionSelectAllResult CallbackInfo::inspect_select_all_changeset(DomNodeId target) const {
    return OptionSelectAllResult(AzCallbackInfo_inspectSelectAllChangeset(&inner_, target.release()));
}

inline OptionDeleteResult CallbackInfo::inspect_delete_changeset(DomNodeId target, bool forward) const {
    return OptionDeleteResult(AzCallbackInfo_inspectDeleteChangeset(&inner_, target.release(), forward));
}

inline OptionClipboardContent CallbackInfo::get_clipboard_content() const {
    return OptionClipboardContent(AzCallbackInfo_getClipboardContent(&inner_));
}

inline OptionClipboardContent CallbackInfo::inspect_copy_changeset(DomNodeId target) const {
    return OptionClipboardContent(AzCallbackInfo_inspectCopyChangeset(&inner_, target.release()));
}

inline OptionClipboardContent CallbackInfo::inspect_cut_changeset(DomNodeId target) const {
    return OptionClipboardContent(AzCallbackInfo_inspectCutChangeset(&inner_, target.release()));
}

inline void CallbackInfo::set_clipboard_content(ClipboardContent content) {
    AzCallbackInfo_setClipboardContent(&inner_, content.release());
}

inline void CallbackInfo::set_copy_content(DomNodeId target, ClipboardContent content) {
    AzCallbackInfo_setCopyContent(&inner_, target.release(), content.release());
}

inline void CallbackInfo::set_cut_content(DomNodeId target, ClipboardContent content) {
    AzCallbackInfo_setCutContent(&inner_, target.release(), content.release());
}

inline void CallbackInfo::set_select_all_range(DomNodeId target, SelectionRange range) {
    AzCallbackInfo_setSelectAllRange(&inner_, target.release(), range.release());
}

inline OptionString CallbackInfo::get_node_text_content(DomNodeId target) const {
    return OptionString(AzCallbackInfo_getNodeTextContent(&inner_, target.release()));
}

inline OptionTextCursor CallbackInfo::get_node_cursor_position(DomNodeId target) const {
    return OptionTextCursor(AzCallbackInfo_getNodeCursorPosition(&inner_, target.release()));
}

inline SelectionRangeVec CallbackInfo::get_node_selection_ranges(DomNodeId target) const {
    return SelectionRangeVec(AzCallbackInfo_getNodeSelectionRanges(&inner_, target.release()));
}

inline bool CallbackInfo::node_has_selection(DomNodeId target) const {
    return AzCallbackInfo_nodeHasSelection(&inner_, target.release());
}

inline OptionUsize CallbackInfo::get_node_text_length(DomNodeId target) const {
    return OptionUsize(AzCallbackInfo_getNodeTextLength(&inner_, target.release()));
}

inline bool CallbackInfo::can_undo(NodeId node_id) const {
    return AzCallbackInfo_canUndo(&inner_, node_id.release());
}

inline bool CallbackInfo::can_redo(NodeId node_id) const {
    return AzCallbackInfo_canRedo(&inner_, node_id.release());
}

inline OptionString CallbackInfo::get_undo_text(NodeId node_id) const {
    return OptionString(AzCallbackInfo_getUndoText(&inner_, node_id.release()));
}

inline OptionString CallbackInfo::get_redo_text(NodeId node_id) const {
    return OptionString(AzCallbackInfo_getRedoText(&inner_, node_id.release()));
}

inline OptionUndoableOperation CallbackInfo::inspect_undo_operation(NodeId node_id) const {
    return OptionUndoableOperation(AzCallbackInfo_inspectUndoOperation(&inner_, node_id.release()));
}

inline OptionUndoableOperation CallbackInfo::inspect_redo_operation(NodeId node_id) const {
    return OptionUndoableOperation(AzCallbackInfo_inspectRedoOperation(&inner_, node_id.release()));
}

inline OptionTextCursor CallbackInfo::inspect_move_cursor_left(DomNodeId target) const {
    return OptionTextCursor(AzCallbackInfo_inspectMoveCursorLeft(&inner_, target.release()));
}

inline OptionTextCursor CallbackInfo::inspect_move_cursor_right(DomNodeId target) const {
    return OptionTextCursor(AzCallbackInfo_inspectMoveCursorRight(&inner_, target.release()));
}

inline OptionTextCursor CallbackInfo::inspect_move_cursor_up(DomNodeId target) const {
    return OptionTextCursor(AzCallbackInfo_inspectMoveCursorUp(&inner_, target.release()));
}

inline OptionTextCursor CallbackInfo::inspect_move_cursor_down(DomNodeId target) const {
    return OptionTextCursor(AzCallbackInfo_inspectMoveCursorDown(&inner_, target.release()));
}

inline OptionTextCursor CallbackInfo::inspect_move_cursor_to_line_start(DomNodeId target) const {
    return OptionTextCursor(AzCallbackInfo_inspectMoveCursorToLineStart(&inner_, target.release()));
}

inline OptionTextCursor CallbackInfo::inspect_move_cursor_to_line_end(DomNodeId target) const {
    return OptionTextCursor(AzCallbackInfo_inspectMoveCursorToLineEnd(&inner_, target.release()));
}

inline OptionTextCursor CallbackInfo::inspect_move_cursor_to_document_start(DomNodeId target) const {
    return OptionTextCursor(AzCallbackInfo_inspectMoveCursorToDocumentStart(&inner_, target.release()));
}

inline OptionTextCursor CallbackInfo::inspect_move_cursor_to_document_end(DomNodeId target) const {
    return OptionTextCursor(AzCallbackInfo_inspectMoveCursorToDocumentEnd(&inner_, target.release()));
}

inline OptionDeleteResult CallbackInfo::inspect_backspace(DomNodeId target) const {
    return OptionDeleteResult(AzCallbackInfo_inspectBackspace(&inner_, target.release()));
}

inline OptionDeleteResult CallbackInfo::inspect_delete(DomNodeId target) const {
    return OptionDeleteResult(AzCallbackInfo_inspectDelete(&inner_, target.release()));
}

inline void CallbackInfo::move_cursor_left(DomNodeId target, bool extend_selection) {
    AzCallbackInfo_moveCursorLeft(&inner_, target.release(), extend_selection);
}

inline void CallbackInfo::move_cursor_right(DomNodeId target, bool extend_selection) {
    AzCallbackInfo_moveCursorRight(&inner_, target.release(), extend_selection);
}

inline void CallbackInfo::move_cursor_up(DomNodeId target, bool extend_selection) {
    AzCallbackInfo_moveCursorUp(&inner_, target.release(), extend_selection);
}

inline void CallbackInfo::move_cursor_down(DomNodeId target, bool extend_selection) {
    AzCallbackInfo_moveCursorDown(&inner_, target.release(), extend_selection);
}

inline void CallbackInfo::move_cursor_to_line_start(DomNodeId target, bool extend_selection) {
    AzCallbackInfo_moveCursorToLineStart(&inner_, target.release(), extend_selection);
}

inline void CallbackInfo::move_cursor_to_line_end(DomNodeId target, bool extend_selection) {
    AzCallbackInfo_moveCursorToLineEnd(&inner_, target.release(), extend_selection);
}

inline void CallbackInfo::move_cursor_to_document_start(DomNodeId target, bool extend_selection) {
    AzCallbackInfo_moveCursorToDocumentStart(&inner_, target.release(), extend_selection);
}

inline void CallbackInfo::move_cursor_to_document_end(DomNodeId target, bool extend_selection) {
    AzCallbackInfo_moveCursorToDocumentEnd(&inner_, target.release(), extend_selection);
}

inline void CallbackInfo::delete_backward(DomNodeId target) {
    AzCallbackInfo_deleteBackward(&inner_, target.release());
}

inline void CallbackInfo::delete_forward(DomNodeId target) {
    AzCallbackInfo_deleteForward(&inner_, target.release());
}

inline NodeHierarchyItemIdVec CallbackInfo::get_all_children_nodes(DomId dom_id, NodeId node_id) const {
    return NodeHierarchyItemIdVec(AzCallbackInfo_getAllChildrenNodes(&inner_, dom_id.release(), node_id.release()));
}

inline size_t CallbackInfo::get_children_count(DomId dom_id, NodeId node_id) const {
    return AzCallbackInfo_getChildrenCount(&inner_, dom_id.release(), node_id.release());
}

inline OptionString CallbackInfo::get_node_tag_name(DomNodeId node_id) const {
    return OptionString(AzCallbackInfo_getNodeTagName(&inner_, node_id.release()));
}

inline OptionString CallbackInfo::get_node_attribute(DomNodeId node_id, String attr_name) const {
    return OptionString(AzCallbackInfo_getNodeAttribute(&inner_, node_id.release(), attr_name.release()));
}

inline StringVec CallbackInfo::get_node_classes(DomNodeId node_id) const {
    return StringVec(AzCallbackInfo_getNodeClasses(&inner_, node_id.release()));
}

inline OptionString CallbackInfo::get_node_id(DomNodeId node_id) const {
    return OptionString(AzCallbackInfo_getNodeId(&inner_, node_id.release()));
}

inline ResultU8VecString CallbackInfo::take_screenshot(DomId dom_id) const {
    return ResultU8VecString(AzCallbackInfo_takeScreenshot(&inner_, dom_id.release()));
}

inline ResultVoidString CallbackInfo::take_screenshot_to_file(DomId dom_id, String path) const {
    return ResultVoidString(AzCallbackInfo_takeScreenshotToFile(&inner_, dom_id.release(), path.release()));
}

inline ResultVoidString CallbackInfo::take_native_screenshot(String path) const {
    return ResultVoidString(AzCallbackInfo_takeNativeScreenshot(&inner_, path.release()));
}

inline ResultU8VecString CallbackInfo::take_native_screenshot_bytes() const {
    return ResultU8VecString(AzCallbackInfo_takeNativeScreenshotBytes(&inner_));
}

inline ResultStringString CallbackInfo::take_native_screenshot_base64() const {
    return ResultStringString(AzCallbackInfo_takeNativeScreenshotBase64(&inner_));
}

inline ResultStringString CallbackInfo::take_screenshot_base64(DomId dom_id) const {
    return ResultStringString(AzCallbackInfo_takeScreenshotBase64(&inner_, dom_id.release()));
}

inline OptionPendingTextEdit CallbackInfo::get_text_changeset() const {
    return OptionPendingTextEdit(AzCallbackInfo_getTextChangeset(&inner_));
}

inline void CallbackInfo::accept_drop() {
    AzCallbackInfo_acceptDrop(&inner_);
}

inline StringVec CallbackInfo::get_drag_types() const {
    return StringVec(AzCallbackInfo_getDragTypes(&inner_));
}

inline void CallbackInfo::set_drag_data(String mime_type, U8Vec data) {
    AzCallbackInfo_setDragData(&inner_, mime_type.release(), data.release());
}

inline void CallbackInfo::set_drop_effect(AzDropEffect effect) {
    AzCallbackInfo_setDropEffect(&inner_, effect);
}

inline bool CallbackInfo::was_double_clicked() const {
    return AzCallbackInfo_wasDoubleClicked(&inner_);
}

inline OptionGestureDirection CallbackInfo::get_swipe_direction() const {
    return OptionGestureDirection(AzCallbackInfo_getSwipeDirection(&inner_));
}

inline OptionDetectedPinch CallbackInfo::get_pinch() const {
    return OptionDetectedPinch(AzCallbackInfo_getPinch(&inner_));
}

inline OptionDetectedRotation CallbackInfo::get_rotation() const {
    return OptionDetectedRotation(AzCallbackInfo_getRotation(&inner_));
}

inline OptionDetectedLongPress CallbackInfo::get_long_press() const {
    return OptionDetectedLongPress(AzCallbackInfo_getLongPress(&inner_));
}

inline OptionLocationFix CallbackInfo::get_location_fix() const {
    return OptionLocationFix(AzCallbackInfo_getLocationFix(&inner_));
}

inline OptionBiometricResult CallbackInfo::get_biometric_result() const {
    return OptionBiometricResult(AzCallbackInfo_getBiometricResult(&inner_));
}

inline AzBiometricKind CallbackInfo::get_biometric_kind() const {
    return AzCallbackInfo_getBiometricKind(&inner_);
}

inline void CallbackInfo::request_biometric_auth(BiometricPrompt prompt) {
    AzCallbackInfo_requestBiometricAuth(&inner_, prompt.release());
}

inline void CallbackInfo::keyring_store(String key, String secret, bool require_biometry) {
    AzCallbackInfo_keyringStore(&inner_, key.release(), secret.release(), require_biometry);
}

inline void CallbackInfo::keyring_get(String key) {
    AzCallbackInfo_keyringGet(&inner_, key.release());
}

inline void CallbackInfo::keyring_delete(String key) {
    AzCallbackInfo_keyringDelete(&inner_, key.release());
}

inline OptionKeyringResult CallbackInfo::get_keyring_result() const {
    return OptionKeyringResult(AzCallbackInfo_getKeyringResult(&inner_));
}

inline OptionSensorReading CallbackInfo::get_sensor_reading(AzSensorKind kind) const {
    return OptionSensorReading(AzCallbackInfo_getSensorReading(&inner_, kind));
}

inline OptionGamepadState CallbackInfo::get_gamepad_state(GamepadId id) const {
    return OptionGamepadState(AzCallbackInfo_getGamepadState(&inner_, id.release()));
}

inline OptionGamepadState CallbackInfo::get_primary_gamepad() const {
    return OptionGamepadState(AzCallbackInfo_getPrimaryGamepad(&inner_));
}

inline OptionWacomPadState CallbackInfo::get_wacom_pad() const {
    return OptionWacomPadState(AzCallbackInfo_getWacomPad(&inner_));
}

inline SafeAreaInsets CallbackInfo::get_safe_area_insets() const {
    return SafeAreaInsets(AzCallbackInfo_getSafeAreaInsets(&inner_));
}

inline LoadedFontVec CallbackInfo::get_loaded_fonts() const {
    return LoadedFontVec(AzCallbackInfo_getLoadedFonts(&inner_));
}

inline OptionU8Vec CallbackInfo::get_loaded_font_bytes(uint64_t font_hash) const {
    return OptionU8Vec(AzCallbackInfo_getLoadedFontBytes(&inner_, font_hash));
}

inline String CallbackInfo::toDbgString() const {
    return String(AzCallbackInfo_toDbgString(&inner_));
}

inline void TagIdToNodeIdMapping::delete_() {
    AzTagIdToNodeIdMapping_delete(&inner_);
}

inline TagIdToNodeIdMapping TagIdToNodeIdMapping::clone() const {
    return TagIdToNodeIdMapping(AzTagIdToNodeIdMapping_clone(&inner_));
}

inline bool TagIdToNodeIdMapping::partialEq(const TagIdToNodeIdMapping& b) const {
    return AzTagIdToNodeIdMapping_partialEq(&inner_, b.ptr());
}

inline uint8_t TagIdToNodeIdMapping::partialCmp(const TagIdToNodeIdMapping& b) const {
    return AzTagIdToNodeIdMapping_partialCmp(&inner_, b.ptr());
}

inline uint8_t TagIdToNodeIdMapping::cmp(const TagIdToNodeIdMapping& b) const {
    return AzTagIdToNodeIdMapping_cmp(&inner_, b.ptr());
}

inline String TagIdToNodeIdMapping::toDbgString() const {
    return String(AzTagIdToNodeIdMapping_toDbgString(&inner_));
}

inline MouseState MouseState::default_() {
    return MouseState(AzMouseState_default());
}

inline bool MouseState::partialEq(const MouseState& b) const {
    return AzMouseState_partialEq(&inner_, b.ptr());
}

inline uint8_t MouseState::partialCmp(const MouseState& b) const {
    return AzMouseState_partialCmp(&inner_, b.ptr());
}

inline String MouseState::toDbgString() const {
    return String(AzMouseState_toDbgString(&inner_));
}

inline bool SelectionRange::partialEq(const SelectionRange& b) const {
    return AzSelectionRange_partialEq(&inner_, b.ptr());
}

inline uint64_t SelectionRange::hash() const {
    return AzSelectionRange_hash(&inner_);
}

inline uint8_t SelectionRange::partialCmp(const SelectionRange& b) const {
    return AzSelectionRange_partialCmp(&inner_, b.ptr());
}

inline uint8_t SelectionRange::cmp(const SelectionRange& b) const {
    return AzSelectionRange_cmp(&inner_, b.ptr());
}

inline String SelectionRange::toDbgString() const {
    return String(AzSelectionRange_toDbgString(&inner_));
}

inline SelectionRadius SelectionRadius::default_() {
    return SelectionRadius(AzSelectionRadius_default());
}

inline bool SelectionRadius::partialEq(const SelectionRadius& b) const {
    return AzSelectionRadius_partialEq(&inner_, b.ptr());
}

inline uint64_t SelectionRadius::hash() const {
    return AzSelectionRadius_hash(&inner_);
}

inline uint8_t SelectionRadius::partialCmp(const SelectionRadius& b) const {
    return AzSelectionRadius_partialCmp(&inner_, b.ptr());
}

inline uint8_t SelectionRadius::cmp(const SelectionRadius& b) const {
    return AzSelectionRadius_cmp(&inner_, b.ptr());
}

inline String SelectionRadius::toDbgString() const {
    return String(AzSelectionRadius_toDbgString(&inner_));
}

inline bool PixelValueSize::partialEq(const PixelValueSize& b) const {
    return AzPixelValueSize_partialEq(&inner_, b.ptr());
}

inline uint64_t PixelValueSize::hash() const {
    return AzPixelValueSize_hash(&inner_);
}

inline uint8_t PixelValueSize::partialCmp(const PixelValueSize& b) const {
    return AzPixelValueSize_partialCmp(&inner_, b.ptr());
}

inline uint8_t PixelValueSize::cmp(const PixelValueSize& b) const {
    return AzPixelValueSize_cmp(&inner_, b.ptr());
}

inline String PixelValueSize::toDbgString() const {
    return String(AzPixelValueSize_toDbgString(&inner_));
}

inline PixelValueNoPercent PixelValueNoPercent::default_() {
    return PixelValueNoPercent(AzPixelValueNoPercent_default());
}

inline bool PixelValueNoPercent::partialEq(const PixelValueNoPercent& b) const {
    return AzPixelValueNoPercent_partialEq(&inner_, b.ptr());
}

inline uint64_t PixelValueNoPercent::hash() const {
    return AzPixelValueNoPercent_hash(&inner_);
}

inline uint8_t PixelValueNoPercent::partialCmp(const PixelValueNoPercent& b) const {
    return AzPixelValueNoPercent_partialCmp(&inner_, b.ptr());
}

inline uint8_t PixelValueNoPercent::cmp(const PixelValueNoPercent& b) const {
    return AzPixelValueNoPercent_cmp(&inner_, b.ptr());
}

inline String PixelValueNoPercent::toDbgString() const {
    return String(AzPixelValueNoPercent_toDbgString(&inner_));
}

inline StyleBlur StyleBlur::default_() {
    return StyleBlur(AzStyleBlur_default());
}

inline void StyleBlur::delete_() {
    AzStyleBlur_delete(&inner_);
}

inline StyleBlur StyleBlur::clone() const {
    return StyleBlur(AzStyleBlur_clone(&inner_));
}

inline bool StyleBlur::partialEq(const StyleBlur& b) const {
    return AzStyleBlur_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBlur::hash() const {
    return AzStyleBlur_hash(&inner_);
}

inline uint8_t StyleBlur::partialCmp(const StyleBlur& b) const {
    return AzStyleBlur_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBlur::cmp(const StyleBlur& b) const {
    return AzStyleBlur_cmp(&inner_, b.ptr());
}

inline String StyleBlur::toDbgString() const {
    return String(AzStyleBlur_toDbgString(&inner_));
}

inline StyleFilterOffset StyleFilterOffset::default_() {
    return StyleFilterOffset(AzStyleFilterOffset_default());
}

inline void StyleFilterOffset::delete_() {
    AzStyleFilterOffset_delete(&inner_);
}

inline StyleFilterOffset StyleFilterOffset::clone() const {
    return StyleFilterOffset(AzStyleFilterOffset_clone(&inner_));
}

inline bool StyleFilterOffset::partialEq(const StyleFilterOffset& b) const {
    return AzStyleFilterOffset_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleFilterOffset::hash() const {
    return AzStyleFilterOffset_hash(&inner_);
}

inline uint8_t StyleFilterOffset::partialCmp(const StyleFilterOffset& b) const {
    return AzStyleFilterOffset_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleFilterOffset::cmp(const StyleFilterOffset& b) const {
    return AzStyleFilterOffset_cmp(&inner_, b.ptr());
}

inline String StyleFilterOffset::toDbgString() const {
    return String(AzStyleFilterOffset_toDbgString(&inner_));
}

inline LayoutLeft LayoutLeft::default_() {
    return LayoutLeft(AzLayoutLeft_default());
}

inline bool LayoutLeft::partialEq(const LayoutLeft& b) const {
    return AzLayoutLeft_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutLeft::hash() const {
    return AzLayoutLeft_hash(&inner_);
}

inline uint8_t LayoutLeft::partialCmp(const LayoutLeft& b) const {
    return AzLayoutLeft_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutLeft::cmp(const LayoutLeft& b) const {
    return AzLayoutLeft_cmp(&inner_, b.ptr());
}

inline LayoutMarginBottom LayoutMarginBottom::default_() {
    return LayoutMarginBottom(AzLayoutMarginBottom_default());
}

inline bool LayoutMarginBottom::partialEq(const LayoutMarginBottom& b) const {
    return AzLayoutMarginBottom_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutMarginBottom::hash() const {
    return AzLayoutMarginBottom_hash(&inner_);
}

inline uint8_t LayoutMarginBottom::partialCmp(const LayoutMarginBottom& b) const {
    return AzLayoutMarginBottom_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutMarginBottom::cmp(const LayoutMarginBottom& b) const {
    return AzLayoutMarginBottom_cmp(&inner_, b.ptr());
}

inline String LayoutMarginBottom::toDbgString() const {
    return String(AzLayoutMarginBottom_toDbgString(&inner_));
}

inline LayoutMarginLeft LayoutMarginLeft::default_() {
    return LayoutMarginLeft(AzLayoutMarginLeft_default());
}

inline bool LayoutMarginLeft::partialEq(const LayoutMarginLeft& b) const {
    return AzLayoutMarginLeft_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutMarginLeft::hash() const {
    return AzLayoutMarginLeft_hash(&inner_);
}

inline uint8_t LayoutMarginLeft::partialCmp(const LayoutMarginLeft& b) const {
    return AzLayoutMarginLeft_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutMarginLeft::cmp(const LayoutMarginLeft& b) const {
    return AzLayoutMarginLeft_cmp(&inner_, b.ptr());
}

inline String LayoutMarginLeft::toDbgString() const {
    return String(AzLayoutMarginLeft_toDbgString(&inner_));
}

inline LayoutMarginRight LayoutMarginRight::default_() {
    return LayoutMarginRight(AzLayoutMarginRight_default());
}

inline bool LayoutMarginRight::partialEq(const LayoutMarginRight& b) const {
    return AzLayoutMarginRight_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutMarginRight::hash() const {
    return AzLayoutMarginRight_hash(&inner_);
}

inline uint8_t LayoutMarginRight::partialCmp(const LayoutMarginRight& b) const {
    return AzLayoutMarginRight_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutMarginRight::cmp(const LayoutMarginRight& b) const {
    return AzLayoutMarginRight_cmp(&inner_, b.ptr());
}

inline String LayoutMarginRight::toDbgString() const {
    return String(AzLayoutMarginRight_toDbgString(&inner_));
}

inline LayoutMarginTop LayoutMarginTop::default_() {
    return LayoutMarginTop(AzLayoutMarginTop_default());
}

inline bool LayoutMarginTop::partialEq(const LayoutMarginTop& b) const {
    return AzLayoutMarginTop_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutMarginTop::hash() const {
    return AzLayoutMarginTop_hash(&inner_);
}

inline uint8_t LayoutMarginTop::partialCmp(const LayoutMarginTop& b) const {
    return AzLayoutMarginTop_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutMarginTop::cmp(const LayoutMarginTop& b) const {
    return AzLayoutMarginTop_cmp(&inner_, b.ptr());
}

inline String LayoutMarginTop::toDbgString() const {
    return String(AzLayoutMarginTop_toDbgString(&inner_));
}

inline bool LayoutMaxHeight::partialEq(const LayoutMaxHeight& b) const {
    return AzLayoutMaxHeight_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutMaxHeight::hash() const {
    return AzLayoutMaxHeight_hash(&inner_);
}

inline uint8_t LayoutMaxHeight::partialCmp(const LayoutMaxHeight& b) const {
    return AzLayoutMaxHeight_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutMaxHeight::cmp(const LayoutMaxHeight& b) const {
    return AzLayoutMaxHeight_cmp(&inner_, b.ptr());
}

inline String LayoutMaxHeight::toDbgString() const {
    return String(AzLayoutMaxHeight_toDbgString(&inner_));
}

inline bool LayoutMaxWidth::partialEq(const LayoutMaxWidth& b) const {
    return AzLayoutMaxWidth_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutMaxWidth::hash() const {
    return AzLayoutMaxWidth_hash(&inner_);
}

inline uint8_t LayoutMaxWidth::partialCmp(const LayoutMaxWidth& b) const {
    return AzLayoutMaxWidth_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutMaxWidth::cmp(const LayoutMaxWidth& b) const {
    return AzLayoutMaxWidth_cmp(&inner_, b.ptr());
}

inline String LayoutMaxWidth::toDbgString() const {
    return String(AzLayoutMaxWidth_toDbgString(&inner_));
}

inline bool LayoutMinHeight::partialEq(const LayoutMinHeight& b) const {
    return AzLayoutMinHeight_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutMinHeight::hash() const {
    return AzLayoutMinHeight_hash(&inner_);
}

inline uint8_t LayoutMinHeight::partialCmp(const LayoutMinHeight& b) const {
    return AzLayoutMinHeight_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutMinHeight::cmp(const LayoutMinHeight& b) const {
    return AzLayoutMinHeight_cmp(&inner_, b.ptr());
}

inline String LayoutMinHeight::toDbgString() const {
    return String(AzLayoutMinHeight_toDbgString(&inner_));
}

inline bool LayoutMinWidth::partialEq(const LayoutMinWidth& b) const {
    return AzLayoutMinWidth_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutMinWidth::hash() const {
    return AzLayoutMinWidth_hash(&inner_);
}

inline uint8_t LayoutMinWidth::partialCmp(const LayoutMinWidth& b) const {
    return AzLayoutMinWidth_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutMinWidth::cmp(const LayoutMinWidth& b) const {
    return AzLayoutMinWidth_cmp(&inner_, b.ptr());
}

inline String LayoutMinWidth::toDbgString() const {
    return String(AzLayoutMinWidth_toDbgString(&inner_));
}

inline LayoutPaddingBottom LayoutPaddingBottom::default_() {
    return LayoutPaddingBottom(AzLayoutPaddingBottom_default());
}

inline bool LayoutPaddingBottom::partialEq(const LayoutPaddingBottom& b) const {
    return AzLayoutPaddingBottom_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutPaddingBottom::hash() const {
    return AzLayoutPaddingBottom_hash(&inner_);
}

inline uint8_t LayoutPaddingBottom::partialCmp(const LayoutPaddingBottom& b) const {
    return AzLayoutPaddingBottom_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutPaddingBottom::cmp(const LayoutPaddingBottom& b) const {
    return AzLayoutPaddingBottom_cmp(&inner_, b.ptr());
}

inline String LayoutPaddingBottom::toDbgString() const {
    return String(AzLayoutPaddingBottom_toDbgString(&inner_));
}

inline LayoutPaddingLeft LayoutPaddingLeft::default_() {
    return LayoutPaddingLeft(AzLayoutPaddingLeft_default());
}

inline bool LayoutPaddingLeft::partialEq(const LayoutPaddingLeft& b) const {
    return AzLayoutPaddingLeft_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutPaddingLeft::hash() const {
    return AzLayoutPaddingLeft_hash(&inner_);
}

inline uint8_t LayoutPaddingLeft::partialCmp(const LayoutPaddingLeft& b) const {
    return AzLayoutPaddingLeft_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutPaddingLeft::cmp(const LayoutPaddingLeft& b) const {
    return AzLayoutPaddingLeft_cmp(&inner_, b.ptr());
}

inline String LayoutPaddingLeft::toDbgString() const {
    return String(AzLayoutPaddingLeft_toDbgString(&inner_));
}

inline LayoutPaddingRight LayoutPaddingRight::default_() {
    return LayoutPaddingRight(AzLayoutPaddingRight_default());
}

inline bool LayoutPaddingRight::partialEq(const LayoutPaddingRight& b) const {
    return AzLayoutPaddingRight_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutPaddingRight::hash() const {
    return AzLayoutPaddingRight_hash(&inner_);
}

inline uint8_t LayoutPaddingRight::partialCmp(const LayoutPaddingRight& b) const {
    return AzLayoutPaddingRight_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutPaddingRight::cmp(const LayoutPaddingRight& b) const {
    return AzLayoutPaddingRight_cmp(&inner_, b.ptr());
}

inline String LayoutPaddingRight::toDbgString() const {
    return String(AzLayoutPaddingRight_toDbgString(&inner_));
}

inline LayoutPaddingTop LayoutPaddingTop::default_() {
    return LayoutPaddingTop(AzLayoutPaddingTop_default());
}

inline bool LayoutPaddingTop::partialEq(const LayoutPaddingTop& b) const {
    return AzLayoutPaddingTop_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutPaddingTop::hash() const {
    return AzLayoutPaddingTop_hash(&inner_);
}

inline uint8_t LayoutPaddingTop::partialCmp(const LayoutPaddingTop& b) const {
    return AzLayoutPaddingTop_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutPaddingTop::cmp(const LayoutPaddingTop& b) const {
    return AzLayoutPaddingTop_cmp(&inner_, b.ptr());
}

inline String LayoutPaddingTop::toDbgString() const {
    return String(AzLayoutPaddingTop_toDbgString(&inner_));
}

inline LayoutRight LayoutRight::default_() {
    return LayoutRight(AzLayoutRight_default());
}

inline bool LayoutRight::partialEq(const LayoutRight& b) const {
    return AzLayoutRight_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutRight::hash() const {
    return AzLayoutRight_hash(&inner_);
}

inline uint8_t LayoutRight::partialCmp(const LayoutRight& b) const {
    return AzLayoutRight_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutRight::cmp(const LayoutRight& b) const {
    return AzLayoutRight_cmp(&inner_, b.ptr());
}

inline LayoutTop LayoutTop::default_() {
    return LayoutTop(AzLayoutTop_default());
}

inline bool LayoutTop::partialEq(const LayoutTop& b) const {
    return AzLayoutTop_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutTop::hash() const {
    return AzLayoutTop_hash(&inner_);
}

inline uint8_t LayoutTop::partialCmp(const LayoutTop& b) const {
    return AzLayoutTop_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutTop::cmp(const LayoutTop& b) const {
    return AzLayoutTop_cmp(&inner_, b.ptr());
}

inline void NormalizedLinearColorStop::delete_() {
    AzNormalizedLinearColorStop_delete(&inner_);
}

inline NormalizedLinearColorStop NormalizedLinearColorStop::clone() const {
    return NormalizedLinearColorStop(AzNormalizedLinearColorStop_clone(&inner_));
}

inline bool NormalizedLinearColorStop::partialEq(const NormalizedLinearColorStop& b) const {
    return AzNormalizedLinearColorStop_partialEq(&inner_, b.ptr());
}

inline uint64_t NormalizedLinearColorStop::hash() const {
    return AzNormalizedLinearColorStop_hash(&inner_);
}

inline uint8_t NormalizedLinearColorStop::partialCmp(const NormalizedLinearColorStop& b) const {
    return AzNormalizedLinearColorStop_partialCmp(&inner_, b.ptr());
}

inline uint8_t NormalizedLinearColorStop::cmp(const NormalizedLinearColorStop& b) const {
    return AzNormalizedLinearColorStop_cmp(&inner_, b.ptr());
}

inline String NormalizedLinearColorStop::toDbgString() const {
    return String(AzNormalizedLinearColorStop_toDbgString(&inner_));
}

inline void NormalizedRadialColorStop::delete_() {
    AzNormalizedRadialColorStop_delete(&inner_);
}

inline NormalizedRadialColorStop NormalizedRadialColorStop::clone() const {
    return NormalizedRadialColorStop(AzNormalizedRadialColorStop_clone(&inner_));
}

inline bool NormalizedRadialColorStop::partialEq(const NormalizedRadialColorStop& b) const {
    return AzNormalizedRadialColorStop_partialEq(&inner_, b.ptr());
}

inline uint64_t NormalizedRadialColorStop::hash() const {
    return AzNormalizedRadialColorStop_hash(&inner_);
}

inline uint8_t NormalizedRadialColorStop::partialCmp(const NormalizedRadialColorStop& b) const {
    return AzNormalizedRadialColorStop_partialCmp(&inner_, b.ptr());
}

inline uint8_t NormalizedRadialColorStop::cmp(const NormalizedRadialColorStop& b) const {
    return AzNormalizedRadialColorStop_cmp(&inner_, b.ptr());
}

inline String NormalizedRadialColorStop::toDbgString() const {
    return String(AzNormalizedRadialColorStop_toDbgString(&inner_));
}

inline StyleBorderBottomLeftRadius StyleBorderBottomLeftRadius::default_() {
    return StyleBorderBottomLeftRadius(AzStyleBorderBottomLeftRadius_default());
}

inline bool StyleBorderBottomLeftRadius::partialEq(const StyleBorderBottomLeftRadius& b) const {
    return AzStyleBorderBottomLeftRadius_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBorderBottomLeftRadius::hash() const {
    return AzStyleBorderBottomLeftRadius_hash(&inner_);
}

inline uint8_t StyleBorderBottomLeftRadius::partialCmp(const StyleBorderBottomLeftRadius& b) const {
    return AzStyleBorderBottomLeftRadius_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBorderBottomLeftRadius::cmp(const StyleBorderBottomLeftRadius& b) const {
    return AzStyleBorderBottomLeftRadius_cmp(&inner_, b.ptr());
}

inline StyleBorderBottomRightRadius StyleBorderBottomRightRadius::default_() {
    return StyleBorderBottomRightRadius(AzStyleBorderBottomRightRadius_default());
}

inline bool StyleBorderBottomRightRadius::partialEq(const StyleBorderBottomRightRadius& b) const {
    return AzStyleBorderBottomRightRadius_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBorderBottomRightRadius::hash() const {
    return AzStyleBorderBottomRightRadius_hash(&inner_);
}

inline uint8_t StyleBorderBottomRightRadius::partialCmp(const StyleBorderBottomRightRadius& b) const {
    return AzStyleBorderBottomRightRadius_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBorderBottomRightRadius::cmp(const StyleBorderBottomRightRadius& b) const {
    return AzStyleBorderBottomRightRadius_cmp(&inner_, b.ptr());
}

inline bool LayoutBorderBottomWidth::partialEq(const LayoutBorderBottomWidth& b) const {
    return AzLayoutBorderBottomWidth_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutBorderBottomWidth::hash() const {
    return AzLayoutBorderBottomWidth_hash(&inner_);
}

inline uint8_t LayoutBorderBottomWidth::partialCmp(const LayoutBorderBottomWidth& b) const {
    return AzLayoutBorderBottomWidth_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutBorderBottomWidth::cmp(const LayoutBorderBottomWidth& b) const {
    return AzLayoutBorderBottomWidth_cmp(&inner_, b.ptr());
}

inline bool LayoutBorderLeftWidth::partialEq(const LayoutBorderLeftWidth& b) const {
    return AzLayoutBorderLeftWidth_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutBorderLeftWidth::hash() const {
    return AzLayoutBorderLeftWidth_hash(&inner_);
}

inline uint8_t LayoutBorderLeftWidth::partialCmp(const LayoutBorderLeftWidth& b) const {
    return AzLayoutBorderLeftWidth_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutBorderLeftWidth::cmp(const LayoutBorderLeftWidth& b) const {
    return AzLayoutBorderLeftWidth_cmp(&inner_, b.ptr());
}

inline bool LayoutBorderRightWidth::partialEq(const LayoutBorderRightWidth& b) const {
    return AzLayoutBorderRightWidth_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutBorderRightWidth::hash() const {
    return AzLayoutBorderRightWidth_hash(&inner_);
}

inline uint8_t LayoutBorderRightWidth::partialCmp(const LayoutBorderRightWidth& b) const {
    return AzLayoutBorderRightWidth_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutBorderRightWidth::cmp(const LayoutBorderRightWidth& b) const {
    return AzLayoutBorderRightWidth_cmp(&inner_, b.ptr());
}

inline StyleBorderTopLeftRadius StyleBorderTopLeftRadius::default_() {
    return StyleBorderTopLeftRadius(AzStyleBorderTopLeftRadius_default());
}

inline bool StyleBorderTopLeftRadius::partialEq(const StyleBorderTopLeftRadius& b) const {
    return AzStyleBorderTopLeftRadius_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBorderTopLeftRadius::hash() const {
    return AzStyleBorderTopLeftRadius_hash(&inner_);
}

inline uint8_t StyleBorderTopLeftRadius::partialCmp(const StyleBorderTopLeftRadius& b) const {
    return AzStyleBorderTopLeftRadius_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBorderTopLeftRadius::cmp(const StyleBorderTopLeftRadius& b) const {
    return AzStyleBorderTopLeftRadius_cmp(&inner_, b.ptr());
}

inline StyleBorderTopRightRadius StyleBorderTopRightRadius::default_() {
    return StyleBorderTopRightRadius(AzStyleBorderTopRightRadius_default());
}

inline bool StyleBorderTopRightRadius::partialEq(const StyleBorderTopRightRadius& b) const {
    return AzStyleBorderTopRightRadius_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBorderTopRightRadius::hash() const {
    return AzStyleBorderTopRightRadius_hash(&inner_);
}

inline uint8_t StyleBorderTopRightRadius::partialCmp(const StyleBorderTopRightRadius& b) const {
    return AzStyleBorderTopRightRadius_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBorderTopRightRadius::cmp(const StyleBorderTopRightRadius& b) const {
    return AzStyleBorderTopRightRadius_cmp(&inner_, b.ptr());
}

inline bool LayoutBorderTopWidth::partialEq(const LayoutBorderTopWidth& b) const {
    return AzLayoutBorderTopWidth_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutBorderTopWidth::hash() const {
    return AzLayoutBorderTopWidth_hash(&inner_);
}

inline uint8_t LayoutBorderTopWidth::partialCmp(const LayoutBorderTopWidth& b) const {
    return AzLayoutBorderTopWidth_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutBorderTopWidth::cmp(const LayoutBorderTopWidth& b) const {
    return AzLayoutBorderTopWidth_cmp(&inner_, b.ptr());
}

inline StyleFontSize StyleFontSize::px(float value) {
    return StyleFontSize(AzStyleFontSize_px(value));
}

inline StyleFontSize StyleFontSize::default_() {
    return StyleFontSize(AzStyleFontSize_default());
}

inline bool StyleFontSize::partialEq(const StyleFontSize& b) const {
    return AzStyleFontSize_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleFontSize::hash() const {
    return AzStyleFontSize_hash(&inner_);
}

inline uint8_t StyleFontSize::partialCmp(const StyleFontSize& b) const {
    return AzStyleFontSize_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleFontSize::cmp(const StyleFontSize& b) const {
    return AzStyleFontSize_cmp(&inner_, b.ptr());
}

inline String StyleFontSize::toDbgString() const {
    return String(AzStyleFontSize_toDbgString(&inner_));
}

inline StyleLetterSpacing StyleLetterSpacing::default_() {
    return StyleLetterSpacing(AzStyleLetterSpacing_default());
}

inline bool StyleLetterSpacing::partialEq(const StyleLetterSpacing& b) const {
    return AzStyleLetterSpacing_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleLetterSpacing::hash() const {
    return AzStyleLetterSpacing_hash(&inner_);
}

inline uint8_t StyleLetterSpacing::partialCmp(const StyleLetterSpacing& b) const {
    return AzStyleLetterSpacing_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleLetterSpacing::cmp(const StyleLetterSpacing& b) const {
    return AzStyleLetterSpacing_cmp(&inner_, b.ptr());
}

inline String StyleLetterSpacing::toDbgString() const {
    return String(AzStyleLetterSpacing_toDbgString(&inner_));
}

inline StyleLineHeight StyleLineHeight::default_() {
    return StyleLineHeight(AzStyleLineHeight_default());
}

inline bool StyleLineHeight::partialEq(const StyleLineHeight& b) const {
    return AzStyleLineHeight_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleLineHeight::hash() const {
    return AzStyleLineHeight_hash(&inner_);
}

inline uint8_t StyleLineHeight::partialCmp(const StyleLineHeight& b) const {
    return AzStyleLineHeight_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleLineHeight::cmp(const StyleLineHeight& b) const {
    return AzStyleLineHeight_cmp(&inner_, b.ptr());
}

inline StyleOpacity StyleOpacity::default_() {
    return StyleOpacity(AzStyleOpacity_default());
}

inline bool StyleOpacity::partialEq(const StyleOpacity& b) const {
    return AzStyleOpacity_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleOpacity::hash() const {
    return AzStyleOpacity_hash(&inner_);
}

inline uint8_t StyleOpacity::partialCmp(const StyleOpacity& b) const {
    return AzStyleOpacity_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleOpacity::cmp(const StyleOpacity& b) const {
    return AzStyleOpacity_cmp(&inner_, b.ptr());
}

inline StyleTransformOrigin StyleTransformOrigin::default_() {
    return StyleTransformOrigin(AzStyleTransformOrigin_default());
}

inline bool StyleTransformOrigin::partialEq(const StyleTransformOrigin& b) const {
    return AzStyleTransformOrigin_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleTransformOrigin::hash() const {
    return AzStyleTransformOrigin_hash(&inner_);
}

inline uint8_t StyleTransformOrigin::partialCmp(const StyleTransformOrigin& b) const {
    return AzStyleTransformOrigin_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleTransformOrigin::cmp(const StyleTransformOrigin& b) const {
    return AzStyleTransformOrigin_cmp(&inner_, b.ptr());
}

inline String StyleTransformOrigin::toDbgString() const {
    return String(AzStyleTransformOrigin_toDbgString(&inner_));
}

inline bool StyleTransformTranslate2D::partialEq(const StyleTransformTranslate2D& b) const {
    return AzStyleTransformTranslate2D_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleTransformTranslate2D::hash() const {
    return AzStyleTransformTranslate2D_hash(&inner_);
}

inline uint8_t StyleTransformTranslate2D::partialCmp(const StyleTransformTranslate2D& b) const {
    return AzStyleTransformTranslate2D_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleTransformTranslate2D::cmp(const StyleTransformTranslate2D& b) const {
    return AzStyleTransformTranslate2D_cmp(&inner_, b.ptr());
}

inline String StyleTransformTranslate2D::toDbgString() const {
    return String(AzStyleTransformTranslate2D_toDbgString(&inner_));
}

inline bool StyleTransformTranslate3D::partialEq(const StyleTransformTranslate3D& b) const {
    return AzStyleTransformTranslate3D_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleTransformTranslate3D::hash() const {
    return AzStyleTransformTranslate3D_hash(&inner_);
}

inline uint8_t StyleTransformTranslate3D::partialCmp(const StyleTransformTranslate3D& b) const {
    return AzStyleTransformTranslate3D_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleTransformTranslate3D::cmp(const StyleTransformTranslate3D& b) const {
    return AzStyleTransformTranslate3D_cmp(&inner_, b.ptr());
}

inline String StyleTransformTranslate3D::toDbgString() const {
    return String(AzStyleTransformTranslate3D_toDbgString(&inner_));
}

inline bool StyleTransformRotate3D::partialEq(const StyleTransformRotate3D& b) const {
    return AzStyleTransformRotate3D_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleTransformRotate3D::hash() const {
    return AzStyleTransformRotate3D_hash(&inner_);
}

inline uint8_t StyleTransformRotate3D::partialCmp(const StyleTransformRotate3D& b) const {
    return AzStyleTransformRotate3D_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleTransformRotate3D::cmp(const StyleTransformRotate3D& b) const {
    return AzStyleTransformRotate3D_cmp(&inner_, b.ptr());
}

inline String StyleTransformRotate3D::toDbgString() const {
    return String(AzStyleTransformRotate3D_toDbgString(&inner_));
}

inline bool StyleTransformSkew2D::partialEq(const StyleTransformSkew2D& b) const {
    return AzStyleTransformSkew2D_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleTransformSkew2D::hash() const {
    return AzStyleTransformSkew2D_hash(&inner_);
}

inline uint8_t StyleTransformSkew2D::partialCmp(const StyleTransformSkew2D& b) const {
    return AzStyleTransformSkew2D_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleTransformSkew2D::cmp(const StyleTransformSkew2D& b) const {
    return AzStyleTransformSkew2D_cmp(&inner_, b.ptr());
}

inline String StyleTransformSkew2D::toDbgString() const {
    return String(AzStyleTransformSkew2D_toDbgString(&inner_));
}

inline StyleWordSpacing StyleWordSpacing::default_() {
    return StyleWordSpacing(AzStyleWordSpacing_default());
}

inline bool StyleWordSpacing::partialEq(const StyleWordSpacing& b) const {
    return AzStyleWordSpacing_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleWordSpacing::hash() const {
    return AzStyleWordSpacing_hash(&inner_);
}

inline uint8_t StyleWordSpacing::partialCmp(const StyleWordSpacing& b) const {
    return AzStyleWordSpacing_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleWordSpacing::cmp(const StyleWordSpacing& b) const {
    return AzStyleWordSpacing_cmp(&inner_, b.ptr());
}

inline String StyleWordSpacing::toDbgString() const {
    return String(AzStyleWordSpacing_toDbgString(&inner_));
}

inline StylePerspectiveOrigin StylePerspectiveOrigin::default_() {
    return StylePerspectiveOrigin(AzStylePerspectiveOrigin_default());
}

inline bool StylePerspectiveOrigin::partialEq(const StylePerspectiveOrigin& b) const {
    return AzStylePerspectiveOrigin_partialEq(&inner_, b.ptr());
}

inline uint64_t StylePerspectiveOrigin::hash() const {
    return AzStylePerspectiveOrigin_hash(&inner_);
}

inline uint8_t StylePerspectiveOrigin::partialCmp(const StylePerspectiveOrigin& b) const {
    return AzStylePerspectiveOrigin_partialCmp(&inner_, b.ptr());
}

inline uint8_t StylePerspectiveOrigin::cmp(const StylePerspectiveOrigin& b) const {
    return AzStylePerspectiveOrigin_cmp(&inner_, b.ptr());
}

inline String StylePerspectiveOrigin::toDbgString() const {
    return String(AzStylePerspectiveOrigin_toDbgString(&inner_));
}

inline LayoutGap LayoutGap::default_() {
    return LayoutGap(AzLayoutGap_default());
}

inline bool LayoutGap::partialEq(const LayoutGap& b) const {
    return AzLayoutGap_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutGap::hash() const {
    return AzLayoutGap_hash(&inner_);
}

inline uint8_t LayoutGap::partialCmp(const LayoutGap& b) const {
    return AzLayoutGap_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutGap::cmp(const LayoutGap& b) const {
    return AzLayoutGap_cmp(&inner_, b.ptr());
}

inline String LayoutGap::toDbgString() const {
    return String(AzLayoutGap_toDbgString(&inner_));
}

inline ShapeMargin ShapeMargin::default_() {
    return ShapeMargin(AzShapeMargin_default());
}

inline bool ShapeMargin::partialEq(const ShapeMargin& b) const {
    return AzShapeMargin_partialEq(&inner_, b.ptr());
}

inline uint64_t ShapeMargin::hash() const {
    return AzShapeMargin_hash(&inner_);
}

inline uint8_t ShapeMargin::partialCmp(const ShapeMargin& b) const {
    return AzShapeMargin_partialCmp(&inner_, b.ptr());
}

inline uint8_t ShapeMargin::cmp(const ShapeMargin& b) const {
    return AzShapeMargin_cmp(&inner_, b.ptr());
}

inline String ShapeMargin::toDbgString() const {
    return String(AzShapeMargin_toDbgString(&inner_));
}

inline ColumnRuleWidth ColumnRuleWidth::default_() {
    return ColumnRuleWidth(AzColumnRuleWidth_default());
}

inline bool ColumnRuleWidth::partialEq(const ColumnRuleWidth& b) const {
    return AzColumnRuleWidth_partialEq(&inner_, b.ptr());
}

inline uint64_t ColumnRuleWidth::hash() const {
    return AzColumnRuleWidth_hash(&inner_);
}

inline uint8_t ColumnRuleWidth::partialCmp(const ColumnRuleWidth& b) const {
    return AzColumnRuleWidth_partialCmp(&inner_, b.ptr());
}

inline uint8_t ColumnRuleWidth::cmp(const ColumnRuleWidth& b) const {
    return AzColumnRuleWidth_cmp(&inner_, b.ptr());
}

inline String ColumnRuleWidth::toDbgString() const {
    return String(AzColumnRuleWidth_toDbgString(&inner_));
}

inline StyleTextIndent StyleTextIndent::default_() {
    return StyleTextIndent(AzStyleTextIndent_default());
}

inline bool StyleTextIndent::partialEq(const StyleTextIndent& b) const {
    return AzStyleTextIndent_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleTextIndent::hash() const {
    return AzStyleTextIndent_hash(&inner_);
}

inline uint8_t StyleTextIndent::partialCmp(const StyleTextIndent& b) const {
    return AzStyleTextIndent_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleTextIndent::cmp(const StyleTextIndent& b) const {
    return AzStyleTextIndent_cmp(&inner_, b.ptr());
}

inline String StyleTextIndent::toDbgString() const {
    return String(AzStyleTextIndent_toDbgString(&inner_));
}

inline LayoutBorderSpacing LayoutBorderSpacing::default_() {
    return LayoutBorderSpacing(AzLayoutBorderSpacing_default());
}

inline bool LayoutBorderSpacing::partialEq(const LayoutBorderSpacing& b) const {
    return AzLayoutBorderSpacing_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutBorderSpacing::hash() const {
    return AzLayoutBorderSpacing_hash(&inner_);
}

inline uint8_t LayoutBorderSpacing::partialCmp(const LayoutBorderSpacing& b) const {
    return AzLayoutBorderSpacing_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutBorderSpacing::cmp(const LayoutBorderSpacing& b) const {
    return AzLayoutBorderSpacing_cmp(&inner_, b.ptr());
}

inline String LayoutBorderSpacing::toDbgString() const {
    return String(AzLayoutBorderSpacing_toDbgString(&inner_));
}

inline LayoutPaddingInlineStart LayoutPaddingInlineStart::default_() {
    return LayoutPaddingInlineStart(AzLayoutPaddingInlineStart_default());
}

inline bool LayoutPaddingInlineStart::partialEq(const LayoutPaddingInlineStart& b) const {
    return AzLayoutPaddingInlineStart_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutPaddingInlineStart::hash() const {
    return AzLayoutPaddingInlineStart_hash(&inner_);
}

inline uint8_t LayoutPaddingInlineStart::partialCmp(const LayoutPaddingInlineStart& b) const {
    return AzLayoutPaddingInlineStart_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutPaddingInlineStart::cmp(const LayoutPaddingInlineStart& b) const {
    return AzLayoutPaddingInlineStart_cmp(&inner_, b.ptr());
}

inline String LayoutPaddingInlineStart::toDbgString() const {
    return String(AzLayoutPaddingInlineStart_toDbgString(&inner_));
}

inline LayoutColumnGap LayoutColumnGap::default_() {
    return LayoutColumnGap(AzLayoutColumnGap_default());
}

inline bool LayoutColumnGap::partialEq(const LayoutColumnGap& b) const {
    return AzLayoutColumnGap_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutColumnGap::hash() const {
    return AzLayoutColumnGap_hash(&inner_);
}

inline uint8_t LayoutColumnGap::partialCmp(const LayoutColumnGap& b) const {
    return AzLayoutColumnGap_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutColumnGap::cmp(const LayoutColumnGap& b) const {
    return AzLayoutColumnGap_cmp(&inner_, b.ptr());
}

inline String LayoutColumnGap::toDbgString() const {
    return String(AzLayoutColumnGap_toDbgString(&inner_));
}

inline LayoutPaddingInlineEnd LayoutPaddingInlineEnd::default_() {
    return LayoutPaddingInlineEnd(AzLayoutPaddingInlineEnd_default());
}

inline bool LayoutPaddingInlineEnd::partialEq(const LayoutPaddingInlineEnd& b) const {
    return AzLayoutPaddingInlineEnd_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutPaddingInlineEnd::hash() const {
    return AzLayoutPaddingInlineEnd_hash(&inner_);
}

inline uint8_t LayoutPaddingInlineEnd::partialCmp(const LayoutPaddingInlineEnd& b) const {
    return AzLayoutPaddingInlineEnd_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutPaddingInlineEnd::cmp(const LayoutPaddingInlineEnd& b) const {
    return AzLayoutPaddingInlineEnd_cmp(&inner_, b.ptr());
}

inline String LayoutPaddingInlineEnd::toDbgString() const {
    return String(AzLayoutPaddingInlineEnd_toDbgString(&inner_));
}

inline LayoutRowGap LayoutRowGap::default_() {
    return LayoutRowGap(AzLayoutRowGap_default());
}

inline bool LayoutRowGap::partialEq(const LayoutRowGap& b) const {
    return AzLayoutRowGap_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutRowGap::hash() const {
    return AzLayoutRowGap_hash(&inner_);
}

inline uint8_t LayoutRowGap::partialCmp(const LayoutRowGap& b) const {
    return AzLayoutRowGap_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutRowGap::cmp(const LayoutRowGap& b) const {
    return AzLayoutRowGap_cmp(&inner_, b.ptr());
}

inline String LayoutRowGap::toDbgString() const {
    return String(AzLayoutRowGap_toDbgString(&inner_));
}

inline LayoutInsetBottom LayoutInsetBottom::default_() {
    return LayoutInsetBottom(AzLayoutInsetBottom_default());
}

inline bool LayoutInsetBottom::partialEq(const LayoutInsetBottom& b) const {
    return AzLayoutInsetBottom_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutInsetBottom::hash() const {
    return AzLayoutInsetBottom_hash(&inner_);
}

inline uint8_t LayoutInsetBottom::partialCmp(const LayoutInsetBottom& b) const {
    return AzLayoutInsetBottom_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutInsetBottom::cmp(const LayoutInsetBottom& b) const {
    return AzLayoutInsetBottom_cmp(&inner_, b.ptr());
}

inline SystemColors SystemColors::default_() {
    return SystemColors(AzSystemColors_default());
}

inline void SystemColors::delete_() {
    AzSystemColors_delete(&inner_);
}

inline SystemColors SystemColors::clone() const {
    return SystemColors(AzSystemColors_clone(&inner_));
}

inline bool SystemColors::partialEq(const SystemColors& b) const {
    return AzSystemColors_partialEq(&inner_, b.ptr());
}

inline String SystemColors::toDbgString() const {
    return String(AzSystemColors_toDbgString(&inner_));
}

inline CaretWidth CaretWidth::default_() {
    return CaretWidth(AzCaretWidth_default());
}

inline bool CaretWidth::partialEq(const CaretWidth& b) const {
    return AzCaretWidth_partialEq(&inner_, b.ptr());
}

inline uint64_t CaretWidth::hash() const {
    return AzCaretWidth_hash(&inner_);
}

inline uint8_t CaretWidth::partialCmp(const CaretWidth& b) const {
    return AzCaretWidth_partialCmp(&inner_, b.ptr());
}

inline uint8_t CaretWidth::cmp(const CaretWidth& b) const {
    return AzCaretWidth_cmp(&inner_, b.ptr());
}

inline String CaretWidth::toDbgString() const {
    return String(AzCaretWidth_toDbgString(&inner_));
}

inline StyleTabSize StyleTabSize::default_() {
    return StyleTabSize(AzStyleTabSize_default());
}

inline bool StyleTabSize::partialEq(const StyleTabSize& b) const {
    return AzStyleTabSize_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleTabSize::hash() const {
    return AzStyleTabSize_hash(&inner_);
}

inline uint8_t StyleTabSize::partialCmp(const StyleTabSize& b) const {
    return AzStyleTabSize_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleTabSize::cmp(const StyleTabSize& b) const {
    return AzStyleTabSize_cmp(&inner_, b.ptr());
}

inline String StyleTabSize::toDbgString() const {
    return String(AzStyleTabSize_toDbgString(&inner_));
}

inline StyleOverflowClipMargin StyleOverflowClipMargin::default_() {
    return StyleOverflowClipMargin(AzStyleOverflowClipMargin_default());
}

inline bool StyleOverflowClipMargin::partialEq(const StyleOverflowClipMargin& b) const {
    return AzStyleOverflowClipMargin_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleOverflowClipMargin::hash() const {
    return AzStyleOverflowClipMargin_hash(&inner_);
}

inline uint8_t StyleOverflowClipMargin::partialCmp(const StyleOverflowClipMargin& b) const {
    return AzStyleOverflowClipMargin_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleOverflowClipMargin::cmp(const StyleOverflowClipMargin& b) const {
    return AzStyleOverflowClipMargin_cmp(&inner_, b.ptr());
}

inline String StyleOverflowClipMargin::toDbgString() const {
    return String(AzStyleOverflowClipMargin_toDbgString(&inner_));
}

inline Texture Texture::create(AzGLuint texture_id, TextureFlags flags, AzPhysicalSizeU32 size, ColorU background_color, GlContextPtr gl_context, AzRawImageFormat format) {
    return Texture(AzTexture_create(texture_id, flags.release(), size, background_color.release(), gl_context.release(), format));
}

inline Texture Texture::allocate_rgba8(GlContextPtr gl_context, AzPhysicalSizeU32 size, ColorU background) {
    return Texture(AzTexture_allocateRgba8(gl_context.release(), size, background.release()));
}

inline Texture Texture::allocate_clip_mask(GlContextPtr gl, AzPhysicalSizeU32 size, ColorU background) {
    return Texture(AzTexture_allocateClipMask(gl.release(), size, background.release()));
}

inline void Texture::clear() {
    AzTexture_clear(&inner_);
}

inline bool Texture::apply_fxaa() {
    return AzTexture_applyFxaa(&inner_);
}

inline bool Texture::draw_tesselated_svg_gpu_node(TessellatedGPUSvgNode node, AzPhysicalSizeU32 size, ColorU color, StyleTransformVec transforms) {
    return AzTexture_drawTesselatedSvgGpuNode(&inner_, node.release(), size, color.release(), transforms.release());
}

inline ImageDescriptor Texture::get_descriptor() const {
    return ImageDescriptor(AzTexture_getDescriptor(&inner_));
}

inline bool Texture::draw_tesselated_colored_svg_gpu_node(TessellatedColoredGPUSvgNode node, AzPhysicalSizeU32 size, StyleTransformVec transforms) {
    return AzTexture_drawTesselatedColoredSvgGpuNode(&inner_, node.release(), size, transforms.release());
}

inline void Texture::delete_() {
    AzTexture_delete(&inner_);
}

inline Texture Texture::clone() const {
    return Texture(AzTexture_clone(&inner_));
}

inline void ImageMask::delete_() {
    AzImageMask_delete(&inner_);
}

inline ImageMask ImageMask::clone() const {
    return ImageMask(AzImageMask_clone(&inner_));
}

inline bool ImageMask::partialEq(const ImageMask& b) const {
    return AzImageMask_partialEq(&inner_, b.ptr());
}

inline uint64_t ImageMask::hash() const {
    return AzImageMask_hash(&inner_);
}

inline uint8_t ImageMask::partialCmp(const ImageMask& b) const {
    return AzImageMask_partialCmp(&inner_, b.ptr());
}

inline uint8_t ImageMask::cmp(const ImageMask& b) const {
    return AzImageMask_cmp(&inner_, b.ptr());
}

inline String ImageMask::toDbgString() const {
    return String(AzImageMask_toDbgString(&inner_));
}

inline SvgStrokeStyle SvgStrokeStyle::default_() {
    return SvgStrokeStyle(AzSvgStrokeStyle_default());
}

inline bool SvgStrokeStyle::partialEq(const SvgStrokeStyle& b) const {
    return AzSvgStrokeStyle_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgStrokeStyle::partialCmp(const SvgStrokeStyle& b) const {
    return AzSvgStrokeStyle_partialCmp(&inner_, b.ptr());
}

inline String SvgStrokeStyle::toDbgString() const {
    return String(AzSvgStrokeStyle_toDbgString(&inner_));
}

inline void InstantPtr::delete_() {
    AzInstantPtr_delete(&inner_);
}

inline InstantPtr InstantPtr::clone() const {
    return InstantPtr(AzInstantPtr_clone(&inner_));
}

inline bool InstantPtr::partialEq(const InstantPtr& b) const {
    return AzInstantPtr_partialEq(&inner_, b.ptr());
}

inline uint64_t InstantPtr::hash() const {
    return AzInstantPtr_hash(&inner_);
}

inline uint8_t InstantPtr::partialCmp(const InstantPtr& b) const {
    return AzInstantPtr_partialCmp(&inner_, b.ptr());
}

inline uint8_t InstantPtr::cmp(const InstantPtr& b) const {
    return AzInstantPtr_cmp(&inner_, b.ptr());
}

inline String InstantPtr::toDbgString() const {
    return String(AzInstantPtr_toDbgString(&inner_));
}

inline ListViewRowVec ListViewRowVec::create() {
    return ListViewRowVec(AzListViewRowVec_create());
}

inline ListViewRowVec ListViewRowVec::with_capacity(size_t cap) {
    return ListViewRowVec(AzListViewRowVec_withCapacity(cap));
}

inline size_t ListViewRowVec::len() const {
    return AzListViewRowVec_len(&inner_);
}

inline size_t ListViewRowVec::capacity() const {
    return AzListViewRowVec_capacity(&inner_);
}

inline bool ListViewRowVec::is_empty() const {
    return AzListViewRowVec_isEmpty(&inner_);
}

inline OptionListViewRow ListViewRowVec::get(size_t index) const {
    return OptionListViewRow(AzListViewRowVec_get(&inner_, index));
}

inline ListViewRowVec ListViewRowVec::from_item(ListViewRow item) {
    return ListViewRowVec(AzListViewRowVec_fromItem(item.release()));
}

inline ListViewRowVec ListViewRowVec::copy_from_ptr(const ListViewRow& ptr, size_t len) {
    return ListViewRowVec(AzListViewRowVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionListViewRow ListViewRowVec::c_get(size_t index) const {
    return OptionListViewRow(AzListViewRowVec_cGet(&inner_, index));
}

inline ListViewRowVecSlice ListViewRowVec::as_c_slice() const {
    return ListViewRowVecSlice(AzListViewRowVec_asCSlice(&inner_));
}

inline ListViewRowVecSlice ListViewRowVec::as_c_slice_range(size_t start, size_t end) const {
    return ListViewRowVecSlice(AzListViewRowVec_asCSliceRange(&inner_, start, end));
}

inline void ListViewRowVec::delete_() {
    AzListViewRowVec_delete(&inner_);
}

inline ListViewRowVec ListViewRowVec::clone() const {
    return ListViewRowVec(AzListViewRowVec_clone(&inner_));
}

inline String ListViewRowVec::toDbgString() const {
    return String(AzListViewRowVec_toDbgString(&inner_));
}

inline StyleFilterVec StyleFilterVec::create() {
    return StyleFilterVec(AzStyleFilterVec_create());
}

inline StyleFilterVec StyleFilterVec::with_capacity(size_t cap) {
    return StyleFilterVec(AzStyleFilterVec_withCapacity(cap));
}

inline size_t StyleFilterVec::len() const {
    return AzStyleFilterVec_len(&inner_);
}

inline size_t StyleFilterVec::capacity() const {
    return AzStyleFilterVec_capacity(&inner_);
}

inline bool StyleFilterVec::is_empty() const {
    return AzStyleFilterVec_isEmpty(&inner_);
}

inline OptionStyleFilter StyleFilterVec::get(size_t index) const {
    return OptionStyleFilter(AzStyleFilterVec_get(&inner_, index));
}

inline StyleFilterVec StyleFilterVec::from_item(AzStyleFilter item) {
    return StyleFilterVec(AzStyleFilterVec_fromItem(item));
}

inline StyleFilterVec StyleFilterVec::copy_from_ptr(const AzStyleFilter* ptr, size_t len) {
    return StyleFilterVec(AzStyleFilterVec_copyFromPtr(ptr, len));
}

inline OptionStyleFilter StyleFilterVec::c_get(size_t index) const {
    return OptionStyleFilter(AzStyleFilterVec_cGet(&inner_, index));
}

inline StyleFilterVecSlice StyleFilterVec::as_c_slice() const {
    return StyleFilterVecSlice(AzStyleFilterVec_asCSlice(&inner_));
}

inline StyleFilterVecSlice StyleFilterVec::as_c_slice_range(size_t start, size_t end) const {
    return StyleFilterVecSlice(AzStyleFilterVec_asCSliceRange(&inner_, start, end));
}

inline void StyleFilterVec::delete_() {
    AzStyleFilterVec_delete(&inner_);
}

inline StyleFilterVec StyleFilterVec::clone() const {
    return StyleFilterVec(AzStyleFilterVec_clone(&inner_));
}

inline bool StyleFilterVec::partialEq(const StyleFilterVec& b) const {
    return AzStyleFilterVec_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleFilterVec::hash() const {
    return AzStyleFilterVec_hash(&inner_);
}

inline uint8_t StyleFilterVec::partialCmp(const StyleFilterVec& b) const {
    return AzStyleFilterVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleFilterVec::cmp(const StyleFilterVec& b) const {
    return AzStyleFilterVec_cmp(&inner_, b.ptr());
}

inline String StyleFilterVec::toDbgString() const {
    return String(AzStyleFilterVec_toDbgString(&inner_));
}

inline AccessibilityStateVec AccessibilityStateVec::create() {
    return AccessibilityStateVec(AzAccessibilityStateVec_create());
}

inline AccessibilityStateVec AccessibilityStateVec::with_capacity(size_t cap) {
    return AccessibilityStateVec(AzAccessibilityStateVec_withCapacity(cap));
}

inline size_t AccessibilityStateVec::len() const {
    return AzAccessibilityStateVec_len(&inner_);
}

inline size_t AccessibilityStateVec::capacity() const {
    return AzAccessibilityStateVec_capacity(&inner_);
}

inline bool AccessibilityStateVec::is_empty() const {
    return AzAccessibilityStateVec_isEmpty(&inner_);
}

inline OptionAccessibilityState AccessibilityStateVec::get(size_t index) const {
    return OptionAccessibilityState(AzAccessibilityStateVec_get(&inner_, index));
}

inline AccessibilityStateVec AccessibilityStateVec::from_item(AzAccessibilityState item) {
    return AccessibilityStateVec(AzAccessibilityStateVec_fromItem(item));
}

inline AccessibilityStateVec AccessibilityStateVec::copy_from_ptr(const AzAccessibilityState* ptr, size_t len) {
    return AccessibilityStateVec(AzAccessibilityStateVec_copyFromPtr(ptr, len));
}

inline OptionAccessibilityState AccessibilityStateVec::c_get(size_t index) const {
    return OptionAccessibilityState(AzAccessibilityStateVec_cGet(&inner_, index));
}

inline AccessibilityStateVecSlice AccessibilityStateVec::as_c_slice() const {
    return AccessibilityStateVecSlice(AzAccessibilityStateVec_asCSlice(&inner_));
}

inline AccessibilityStateVecSlice AccessibilityStateVec::as_c_slice_range(size_t start, size_t end) const {
    return AccessibilityStateVecSlice(AzAccessibilityStateVec_asCSliceRange(&inner_, start, end));
}

inline void AccessibilityStateVec::delete_() {
    AzAccessibilityStateVec_delete(&inner_);
}

inline AccessibilityStateVec AccessibilityStateVec::clone() const {
    return AccessibilityStateVec(AzAccessibilityStateVec_clone(&inner_));
}

inline bool AccessibilityStateVec::partialEq(const AccessibilityStateVec& b) const {
    return AzAccessibilityStateVec_partialEq(&inner_, b.ptr());
}

inline uint64_t AccessibilityStateVec::hash() const {
    return AzAccessibilityStateVec_hash(&inner_);
}

inline uint8_t AccessibilityStateVec::partialCmp(const AccessibilityStateVec& b) const {
    return AzAccessibilityStateVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t AccessibilityStateVec::cmp(const AccessibilityStateVec& b) const {
    return AzAccessibilityStateVec_cmp(&inner_, b.ptr());
}

inline String AccessibilityStateVec::toDbgString() const {
    return String(AzAccessibilityStateVec_toDbgString(&inner_));
}

inline MenuItemVec MenuItemVec::create() {
    return MenuItemVec(AzMenuItemVec_create());
}

inline MenuItemVec MenuItemVec::with_capacity(size_t cap) {
    return MenuItemVec(AzMenuItemVec_withCapacity(cap));
}

inline size_t MenuItemVec::len() const {
    return AzMenuItemVec_len(&inner_);
}

inline size_t MenuItemVec::capacity() const {
    return AzMenuItemVec_capacity(&inner_);
}

inline bool MenuItemVec::is_empty() const {
    return AzMenuItemVec_isEmpty(&inner_);
}

inline OptionMenuItem MenuItemVec::get(size_t index) const {
    return OptionMenuItem(AzMenuItemVec_get(&inner_, index));
}

inline MenuItemVec MenuItemVec::from_item(AzMenuItem item) {
    return MenuItemVec(AzMenuItemVec_fromItem(item));
}

inline MenuItemVec MenuItemVec::copy_from_ptr(const AzMenuItem* ptr, size_t len) {
    return MenuItemVec(AzMenuItemVec_copyFromPtr(ptr, len));
}

inline OptionMenuItem MenuItemVec::c_get(size_t index) const {
    return OptionMenuItem(AzMenuItemVec_cGet(&inner_, index));
}

inline MenuItemVecSlice MenuItemVec::as_c_slice() const {
    return MenuItemVecSlice(AzMenuItemVec_asCSlice(&inner_));
}

inline MenuItemVecSlice MenuItemVec::as_c_slice_range(size_t start, size_t end) const {
    return MenuItemVecSlice(AzMenuItemVec_asCSliceRange(&inner_, start, end));
}

inline void MenuItemVec::delete_() {
    AzMenuItemVec_delete(&inner_);
}

inline MenuItemVec MenuItemVec::clone() const {
    return MenuItemVec(AzMenuItemVec_clone(&inner_));
}

inline bool MenuItemVec::partialEq(const MenuItemVec& b) const {
    return AzMenuItemVec_partialEq(&inner_, b.ptr());
}

inline uint64_t MenuItemVec::hash() const {
    return AzMenuItemVec_hash(&inner_);
}

inline uint8_t MenuItemVec::partialCmp(const MenuItemVec& b) const {
    return AzMenuItemVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t MenuItemVec::cmp(const MenuItemVec& b) const {
    return AzMenuItemVec_cmp(&inner_, b.ptr());
}

inline String MenuItemVec::toDbgString() const {
    return String(AzMenuItemVec_toDbgString(&inner_));
}

inline StyleFontFamilyVec StyleFontFamilyVec::create() {
    return StyleFontFamilyVec(AzStyleFontFamilyVec_create());
}

inline StyleFontFamilyVec StyleFontFamilyVec::with_capacity(size_t cap) {
    return StyleFontFamilyVec(AzStyleFontFamilyVec_withCapacity(cap));
}

inline size_t StyleFontFamilyVec::len() const {
    return AzStyleFontFamilyVec_len(&inner_);
}

inline size_t StyleFontFamilyVec::capacity() const {
    return AzStyleFontFamilyVec_capacity(&inner_);
}

inline bool StyleFontFamilyVec::is_empty() const {
    return AzStyleFontFamilyVec_isEmpty(&inner_);
}

inline OptionStyleFontFamily StyleFontFamilyVec::get(size_t index) const {
    return OptionStyleFontFamily(AzStyleFontFamilyVec_get(&inner_, index));
}

inline StyleFontFamilyVec StyleFontFamilyVec::from_item(AzStyleFontFamily item) {
    return StyleFontFamilyVec(AzStyleFontFamilyVec_fromItem(item));
}

inline StyleFontFamilyVec StyleFontFamilyVec::copy_from_ptr(const AzStyleFontFamily* ptr, size_t len) {
    return StyleFontFamilyVec(AzStyleFontFamilyVec_copyFromPtr(ptr, len));
}

inline OptionStyleFontFamily StyleFontFamilyVec::c_get(size_t index) const {
    return OptionStyleFontFamily(AzStyleFontFamilyVec_cGet(&inner_, index));
}

inline StyleFontFamilyVecSlice StyleFontFamilyVec::as_c_slice() const {
    return StyleFontFamilyVecSlice(AzStyleFontFamilyVec_asCSlice(&inner_));
}

inline StyleFontFamilyVecSlice StyleFontFamilyVec::as_c_slice_range(size_t start, size_t end) const {
    return StyleFontFamilyVecSlice(AzStyleFontFamilyVec_asCSliceRange(&inner_, start, end));
}

inline void StyleFontFamilyVec::delete_() {
    AzStyleFontFamilyVec_delete(&inner_);
}

inline StyleFontFamilyVec StyleFontFamilyVec::clone() const {
    return StyleFontFamilyVec(AzStyleFontFamilyVec_clone(&inner_));
}

inline bool StyleFontFamilyVec::partialEq(const StyleFontFamilyVec& b) const {
    return AzStyleFontFamilyVec_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleFontFamilyVec::hash() const {
    return AzStyleFontFamilyVec_hash(&inner_);
}

inline uint8_t StyleFontFamilyVec::partialCmp(const StyleFontFamilyVec& b) const {
    return AzStyleFontFamilyVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleFontFamilyVec::cmp(const StyleFontFamilyVec& b) const {
    return AzStyleFontFamilyVec_cmp(&inner_, b.ptr());
}

inline String StyleFontFamilyVec::toDbgString() const {
    return String(AzStyleFontFamilyVec_toDbgString(&inner_));
}

inline DomVec DomVec::create() {
    return DomVec(AzDomVec_create());
}

inline DomVec DomVec::with_capacity(size_t cap) {
    return DomVec(AzDomVec_withCapacity(cap));
}

inline size_t DomVec::len() const {
    return AzDomVec_len(&inner_);
}

inline size_t DomVec::capacity() const {
    return AzDomVec_capacity(&inner_);
}

inline bool DomVec::is_empty() const {
    return AzDomVec_isEmpty(&inner_);
}

inline OptionDom DomVec::get(size_t index) const {
    return OptionDom(AzDomVec_get(&inner_, index));
}

inline DomVec DomVec::from_item(Dom item) {
    return DomVec(AzDomVec_fromItem(item.release()));
}

inline DomVec DomVec::copy_from_ptr(const Dom& ptr, size_t len) {
    return DomVec(AzDomVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionDom DomVec::c_get(size_t index) const {
    return OptionDom(AzDomVec_cGet(&inner_, index));
}

inline DomVecSlice DomVec::as_c_slice() const {
    return DomVecSlice(AzDomVec_asCSlice(&inner_));
}

inline DomVecSlice DomVec::as_c_slice_range(size_t start, size_t end) const {
    return DomVecSlice(AzDomVec_asCSliceRange(&inner_, start, end));
}

inline void DomVec::delete_() {
    AzDomVec_delete(&inner_);
}

inline DomVec DomVec::clone() const {
    return DomVec(AzDomVec_clone(&inner_));
}

inline bool DomVec::partialEq(const DomVec& b) const {
    return AzDomVec_partialEq(&inner_, b.ptr());
}

inline uint64_t DomVec::hash() const {
    return AzDomVec_hash(&inner_);
}

inline uint8_t DomVec::partialCmp(const DomVec& b) const {
    return AzDomVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t DomVec::cmp(const DomVec& b) const {
    return AzDomVec_cmp(&inner_, b.ptr());
}

inline String DomVec::toDbgString() const {
    return String(AzDomVec_toDbgString(&inner_));
}

inline IdOrClassVec IdOrClassVec::create() {
    return IdOrClassVec(AzIdOrClassVec_create());
}

inline IdOrClassVec IdOrClassVec::with_capacity(size_t cap) {
    return IdOrClassVec(AzIdOrClassVec_withCapacity(cap));
}

inline size_t IdOrClassVec::len() const {
    return AzIdOrClassVec_len(&inner_);
}

inline size_t IdOrClassVec::capacity() const {
    return AzIdOrClassVec_capacity(&inner_);
}

inline bool IdOrClassVec::is_empty() const {
    return AzIdOrClassVec_isEmpty(&inner_);
}

inline OptionIdOrClass IdOrClassVec::get(size_t index) const {
    return OptionIdOrClass(AzIdOrClassVec_get(&inner_, index));
}

inline IdOrClassVec IdOrClassVec::from_item(AzIdOrClass item) {
    return IdOrClassVec(AzIdOrClassVec_fromItem(item));
}

inline IdOrClassVec IdOrClassVec::copy_from_ptr(const AzIdOrClass* ptr, size_t len) {
    return IdOrClassVec(AzIdOrClassVec_copyFromPtr(ptr, len));
}

inline OptionIdOrClass IdOrClassVec::c_get(size_t index) const {
    return OptionIdOrClass(AzIdOrClassVec_cGet(&inner_, index));
}

inline IdOrClassVecSlice IdOrClassVec::as_c_slice() const {
    return IdOrClassVecSlice(AzIdOrClassVec_asCSlice(&inner_));
}

inline IdOrClassVecSlice IdOrClassVec::as_c_slice_range(size_t start, size_t end) const {
    return IdOrClassVecSlice(AzIdOrClassVec_asCSliceRange(&inner_, start, end));
}

inline void IdOrClassVec::delete_() {
    AzIdOrClassVec_delete(&inner_);
}

inline IdOrClassVec IdOrClassVec::clone() const {
    return IdOrClassVec(AzIdOrClassVec_clone(&inner_));
}

inline bool IdOrClassVec::partialEq(const IdOrClassVec& b) const {
    return AzIdOrClassVec_partialEq(&inner_, b.ptr());
}

inline uint64_t IdOrClassVec::hash() const {
    return AzIdOrClassVec_hash(&inner_);
}

inline uint8_t IdOrClassVec::partialCmp(const IdOrClassVec& b) const {
    return AzIdOrClassVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t IdOrClassVec::cmp(const IdOrClassVec& b) const {
    return AzIdOrClassVec_cmp(&inner_, b.ptr());
}

inline String IdOrClassVec::toDbgString() const {
    return String(AzIdOrClassVec_toDbgString(&inner_));
}

inline DynamicSelectorVec DynamicSelectorVec::create() {
    return DynamicSelectorVec(AzDynamicSelectorVec_create());
}

inline DynamicSelectorVec DynamicSelectorVec::with_capacity(size_t cap) {
    return DynamicSelectorVec(AzDynamicSelectorVec_withCapacity(cap));
}

inline size_t DynamicSelectorVec::len() const {
    return AzDynamicSelectorVec_len(&inner_);
}

inline size_t DynamicSelectorVec::capacity() const {
    return AzDynamicSelectorVec_capacity(&inner_);
}

inline bool DynamicSelectorVec::is_empty() const {
    return AzDynamicSelectorVec_isEmpty(&inner_);
}

inline OptionDynamicSelector DynamicSelectorVec::get(size_t index) const {
    return OptionDynamicSelector(AzDynamicSelectorVec_get(&inner_, index));
}

inline DynamicSelectorVec DynamicSelectorVec::from_item(AzDynamicSelector item) {
    return DynamicSelectorVec(AzDynamicSelectorVec_fromItem(item));
}

inline DynamicSelectorVec DynamicSelectorVec::copy_from_ptr(const AzDynamicSelector* ptr, size_t len) {
    return DynamicSelectorVec(AzDynamicSelectorVec_copyFromPtr(ptr, len));
}

inline OptionDynamicSelector DynamicSelectorVec::c_get(size_t index) const {
    return OptionDynamicSelector(AzDynamicSelectorVec_cGet(&inner_, index));
}

inline DynamicSelectorVecSlice DynamicSelectorVec::as_c_slice() const {
    return DynamicSelectorVecSlice(AzDynamicSelectorVec_asCSlice(&inner_));
}

inline DynamicSelectorVecSlice DynamicSelectorVec::as_c_slice_range(size_t start, size_t end) const {
    return DynamicSelectorVecSlice(AzDynamicSelectorVec_asCSliceRange(&inner_, start, end));
}

inline void DynamicSelectorVec::delete_() {
    AzDynamicSelectorVec_delete(&inner_);
}

inline DynamicSelectorVec DynamicSelectorVec::clone() const {
    return DynamicSelectorVec(AzDynamicSelectorVec_clone(&inner_));
}

inline bool DynamicSelectorVec::partialEq(const DynamicSelectorVec& b) const {
    return AzDynamicSelectorVec_partialEq(&inner_, b.ptr());
}

inline String DynamicSelectorVec::toDbgString() const {
    return String(AzDynamicSelectorVec_toDbgString(&inner_));
}

inline CssPropertyWithConditionsVec CssPropertyWithConditionsVec::create() {
    return CssPropertyWithConditionsVec(AzCssPropertyWithConditionsVec_create());
}

inline CssPropertyWithConditionsVec CssPropertyWithConditionsVec::with_capacity(size_t cap) {
    return CssPropertyWithConditionsVec(AzCssPropertyWithConditionsVec_withCapacity(cap));
}

inline size_t CssPropertyWithConditionsVec::len() const {
    return AzCssPropertyWithConditionsVec_len(&inner_);
}

inline size_t CssPropertyWithConditionsVec::capacity() const {
    return AzCssPropertyWithConditionsVec_capacity(&inner_);
}

inline bool CssPropertyWithConditionsVec::is_empty() const {
    return AzCssPropertyWithConditionsVec_isEmpty(&inner_);
}

inline OptionCssPropertyWithConditions CssPropertyWithConditionsVec::get(size_t index) const {
    return OptionCssPropertyWithConditions(AzCssPropertyWithConditionsVec_get(&inner_, index));
}

inline CssPropertyWithConditionsVec CssPropertyWithConditionsVec::from_item(CssPropertyWithConditions item) {
    return CssPropertyWithConditionsVec(AzCssPropertyWithConditionsVec_fromItem(item.release()));
}

inline CssPropertyWithConditionsVec CssPropertyWithConditionsVec::copy_from_ptr(const CssPropertyWithConditions& ptr, size_t len) {
    return CssPropertyWithConditionsVec(AzCssPropertyWithConditionsVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionCssPropertyWithConditions CssPropertyWithConditionsVec::c_get(size_t index) const {
    return OptionCssPropertyWithConditions(AzCssPropertyWithConditionsVec_cGet(&inner_, index));
}

inline CssPropertyWithConditionsVecSlice CssPropertyWithConditionsVec::as_c_slice() const {
    return CssPropertyWithConditionsVecSlice(AzCssPropertyWithConditionsVec_asCSlice(&inner_));
}

inline CssPropertyWithConditionsVecSlice CssPropertyWithConditionsVec::as_c_slice_range(size_t start, size_t end) const {
    return CssPropertyWithConditionsVecSlice(AzCssPropertyWithConditionsVec_asCSliceRange(&inner_, start, end));
}

inline void CssPropertyWithConditionsVec::delete_() {
    AzCssPropertyWithConditionsVec_delete(&inner_);
}

inline CssPropertyWithConditionsVec CssPropertyWithConditionsVec::clone() const {
    return CssPropertyWithConditionsVec(AzCssPropertyWithConditionsVec_clone(&inner_));
}

inline bool CssPropertyWithConditionsVec::partialEq(const CssPropertyWithConditionsVec& b) const {
    return AzCssPropertyWithConditionsVec_partialEq(&inner_, b.ptr());
}

inline uint64_t CssPropertyWithConditionsVec::hash() const {
    return AzCssPropertyWithConditionsVec_hash(&inner_);
}

inline uint8_t CssPropertyWithConditionsVec::partialCmp(const CssPropertyWithConditionsVec& b) const {
    return AzCssPropertyWithConditionsVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t CssPropertyWithConditionsVec::cmp(const CssPropertyWithConditionsVec& b) const {
    return AzCssPropertyWithConditionsVec_cmp(&inner_, b.ptr());
}

inline String CssPropertyWithConditionsVec::toDbgString() const {
    return String(AzCssPropertyWithConditionsVec_toDbgString(&inner_));
}

inline StyleBackgroundContentVec StyleBackgroundContentVec::create() {
    return StyleBackgroundContentVec(AzStyleBackgroundContentVec_create());
}

inline StyleBackgroundContentVec StyleBackgroundContentVec::with_capacity(size_t cap) {
    return StyleBackgroundContentVec(AzStyleBackgroundContentVec_withCapacity(cap));
}

inline size_t StyleBackgroundContentVec::len() const {
    return AzStyleBackgroundContentVec_len(&inner_);
}

inline size_t StyleBackgroundContentVec::capacity() const {
    return AzStyleBackgroundContentVec_capacity(&inner_);
}

inline bool StyleBackgroundContentVec::is_empty() const {
    return AzStyleBackgroundContentVec_isEmpty(&inner_);
}

inline OptionStyleBackgroundContent StyleBackgroundContentVec::get(size_t index) const {
    return OptionStyleBackgroundContent(AzStyleBackgroundContentVec_get(&inner_, index));
}

inline StyleBackgroundContentVec StyleBackgroundContentVec::from_item(AzStyleBackgroundContent item) {
    return StyleBackgroundContentVec(AzStyleBackgroundContentVec_fromItem(item));
}

inline StyleBackgroundContentVec StyleBackgroundContentVec::copy_from_ptr(const AzStyleBackgroundContent* ptr, size_t len) {
    return StyleBackgroundContentVec(AzStyleBackgroundContentVec_copyFromPtr(ptr, len));
}

inline OptionStyleBackgroundContent StyleBackgroundContentVec::c_get(size_t index) const {
    return OptionStyleBackgroundContent(AzStyleBackgroundContentVec_cGet(&inner_, index));
}

inline StyleBackgroundContentVecSlice StyleBackgroundContentVec::as_c_slice() const {
    return StyleBackgroundContentVecSlice(AzStyleBackgroundContentVec_asCSlice(&inner_));
}

inline StyleBackgroundContentVecSlice StyleBackgroundContentVec::as_c_slice_range(size_t start, size_t end) const {
    return StyleBackgroundContentVecSlice(AzStyleBackgroundContentVec_asCSliceRange(&inner_, start, end));
}

inline void StyleBackgroundContentVec::delete_() {
    AzStyleBackgroundContentVec_delete(&inner_);
}

inline StyleBackgroundContentVec StyleBackgroundContentVec::clone() const {
    return StyleBackgroundContentVec(AzStyleBackgroundContentVec_clone(&inner_));
}

inline bool StyleBackgroundContentVec::partialEq(const StyleBackgroundContentVec& b) const {
    return AzStyleBackgroundContentVec_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBackgroundContentVec::hash() const {
    return AzStyleBackgroundContentVec_hash(&inner_);
}

inline uint8_t StyleBackgroundContentVec::partialCmp(const StyleBackgroundContentVec& b) const {
    return AzStyleBackgroundContentVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBackgroundContentVec::cmp(const StyleBackgroundContentVec& b) const {
    return AzStyleBackgroundContentVec_cmp(&inner_, b.ptr());
}

inline String StyleBackgroundContentVec::toDbgString() const {
    return String(AzStyleBackgroundContentVec_toDbgString(&inner_));
}

inline StyleBackgroundPositionVec StyleBackgroundPositionVec::create() {
    return StyleBackgroundPositionVec(AzStyleBackgroundPositionVec_create());
}

inline StyleBackgroundPositionVec StyleBackgroundPositionVec::with_capacity(size_t cap) {
    return StyleBackgroundPositionVec(AzStyleBackgroundPositionVec_withCapacity(cap));
}

inline size_t StyleBackgroundPositionVec::len() const {
    return AzStyleBackgroundPositionVec_len(&inner_);
}

inline size_t StyleBackgroundPositionVec::capacity() const {
    return AzStyleBackgroundPositionVec_capacity(&inner_);
}

inline bool StyleBackgroundPositionVec::is_empty() const {
    return AzStyleBackgroundPositionVec_isEmpty(&inner_);
}

inline OptionStyleBackgroundPosition StyleBackgroundPositionVec::get(size_t index) const {
    return OptionStyleBackgroundPosition(AzStyleBackgroundPositionVec_get(&inner_, index));
}

inline StyleBackgroundPositionVec StyleBackgroundPositionVec::from_item(StyleBackgroundPosition item) {
    return StyleBackgroundPositionVec(AzStyleBackgroundPositionVec_fromItem(item.release()));
}

inline StyleBackgroundPositionVec StyleBackgroundPositionVec::copy_from_ptr(const StyleBackgroundPosition& ptr, size_t len) {
    return StyleBackgroundPositionVec(AzStyleBackgroundPositionVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionStyleBackgroundPosition StyleBackgroundPositionVec::c_get(size_t index) const {
    return OptionStyleBackgroundPosition(AzStyleBackgroundPositionVec_cGet(&inner_, index));
}

inline StyleBackgroundPositionVecSlice StyleBackgroundPositionVec::as_c_slice() const {
    return StyleBackgroundPositionVecSlice(AzStyleBackgroundPositionVec_asCSlice(&inner_));
}

inline StyleBackgroundPositionVecSlice StyleBackgroundPositionVec::as_c_slice_range(size_t start, size_t end) const {
    return StyleBackgroundPositionVecSlice(AzStyleBackgroundPositionVec_asCSliceRange(&inner_, start, end));
}

inline void StyleBackgroundPositionVec::delete_() {
    AzStyleBackgroundPositionVec_delete(&inner_);
}

inline StyleBackgroundPositionVec StyleBackgroundPositionVec::clone() const {
    return StyleBackgroundPositionVec(AzStyleBackgroundPositionVec_clone(&inner_));
}

inline bool StyleBackgroundPositionVec::partialEq(const StyleBackgroundPositionVec& b) const {
    return AzStyleBackgroundPositionVec_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBackgroundPositionVec::hash() const {
    return AzStyleBackgroundPositionVec_hash(&inner_);
}

inline uint8_t StyleBackgroundPositionVec::partialCmp(const StyleBackgroundPositionVec& b) const {
    return AzStyleBackgroundPositionVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBackgroundPositionVec::cmp(const StyleBackgroundPositionVec& b) const {
    return AzStyleBackgroundPositionVec_cmp(&inner_, b.ptr());
}

inline String StyleBackgroundPositionVec::toDbgString() const {
    return String(AzStyleBackgroundPositionVec_toDbgString(&inner_));
}

inline StyleBackgroundRepeatVec StyleBackgroundRepeatVec::create() {
    return StyleBackgroundRepeatVec(AzStyleBackgroundRepeatVec_create());
}

inline StyleBackgroundRepeatVec StyleBackgroundRepeatVec::with_capacity(size_t cap) {
    return StyleBackgroundRepeatVec(AzStyleBackgroundRepeatVec_withCapacity(cap));
}

inline size_t StyleBackgroundRepeatVec::len() const {
    return AzStyleBackgroundRepeatVec_len(&inner_);
}

inline size_t StyleBackgroundRepeatVec::capacity() const {
    return AzStyleBackgroundRepeatVec_capacity(&inner_);
}

inline bool StyleBackgroundRepeatVec::is_empty() const {
    return AzStyleBackgroundRepeatVec_isEmpty(&inner_);
}

inline OptionStyleBackgroundRepeat StyleBackgroundRepeatVec::get(size_t index) const {
    return OptionStyleBackgroundRepeat(AzStyleBackgroundRepeatVec_get(&inner_, index));
}

inline StyleBackgroundRepeatVec StyleBackgroundRepeatVec::from_item(AzStyleBackgroundRepeat item) {
    return StyleBackgroundRepeatVec(AzStyleBackgroundRepeatVec_fromItem(item));
}

inline StyleBackgroundRepeatVec StyleBackgroundRepeatVec::copy_from_ptr(const AzStyleBackgroundRepeat* ptr, size_t len) {
    return StyleBackgroundRepeatVec(AzStyleBackgroundRepeatVec_copyFromPtr(ptr, len));
}

inline OptionStyleBackgroundRepeat StyleBackgroundRepeatVec::c_get(size_t index) const {
    return OptionStyleBackgroundRepeat(AzStyleBackgroundRepeatVec_cGet(&inner_, index));
}

inline StyleBackgroundRepeatVecSlice StyleBackgroundRepeatVec::as_c_slice() const {
    return StyleBackgroundRepeatVecSlice(AzStyleBackgroundRepeatVec_asCSlice(&inner_));
}

inline StyleBackgroundRepeatVecSlice StyleBackgroundRepeatVec::as_c_slice_range(size_t start, size_t end) const {
    return StyleBackgroundRepeatVecSlice(AzStyleBackgroundRepeatVec_asCSliceRange(&inner_, start, end));
}

inline void StyleBackgroundRepeatVec::delete_() {
    AzStyleBackgroundRepeatVec_delete(&inner_);
}

inline StyleBackgroundRepeatVec StyleBackgroundRepeatVec::clone() const {
    return StyleBackgroundRepeatVec(AzStyleBackgroundRepeatVec_clone(&inner_));
}

inline bool StyleBackgroundRepeatVec::partialEq(const StyleBackgroundRepeatVec& b) const {
    return AzStyleBackgroundRepeatVec_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBackgroundRepeatVec::hash() const {
    return AzStyleBackgroundRepeatVec_hash(&inner_);
}

inline uint8_t StyleBackgroundRepeatVec::partialCmp(const StyleBackgroundRepeatVec& b) const {
    return AzStyleBackgroundRepeatVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBackgroundRepeatVec::cmp(const StyleBackgroundRepeatVec& b) const {
    return AzStyleBackgroundRepeatVec_cmp(&inner_, b.ptr());
}

inline String StyleBackgroundRepeatVec::toDbgString() const {
    return String(AzStyleBackgroundRepeatVec_toDbgString(&inner_));
}

inline StyleBackgroundSizeVec StyleBackgroundSizeVec::create() {
    return StyleBackgroundSizeVec(AzStyleBackgroundSizeVec_create());
}

inline StyleBackgroundSizeVec StyleBackgroundSizeVec::with_capacity(size_t cap) {
    return StyleBackgroundSizeVec(AzStyleBackgroundSizeVec_withCapacity(cap));
}

inline size_t StyleBackgroundSizeVec::len() const {
    return AzStyleBackgroundSizeVec_len(&inner_);
}

inline size_t StyleBackgroundSizeVec::capacity() const {
    return AzStyleBackgroundSizeVec_capacity(&inner_);
}

inline bool StyleBackgroundSizeVec::is_empty() const {
    return AzStyleBackgroundSizeVec_isEmpty(&inner_);
}

inline OptionStyleBackgroundSize StyleBackgroundSizeVec::get(size_t index) const {
    return OptionStyleBackgroundSize(AzStyleBackgroundSizeVec_get(&inner_, index));
}

inline StyleBackgroundSizeVec StyleBackgroundSizeVec::from_item(AzStyleBackgroundSize item) {
    return StyleBackgroundSizeVec(AzStyleBackgroundSizeVec_fromItem(item));
}

inline StyleBackgroundSizeVec StyleBackgroundSizeVec::copy_from_ptr(const AzStyleBackgroundSize* ptr, size_t len) {
    return StyleBackgroundSizeVec(AzStyleBackgroundSizeVec_copyFromPtr(ptr, len));
}

inline OptionStyleBackgroundSize StyleBackgroundSizeVec::c_get(size_t index) const {
    return OptionStyleBackgroundSize(AzStyleBackgroundSizeVec_cGet(&inner_, index));
}

inline StyleBackgroundSizeVecSlice StyleBackgroundSizeVec::as_c_slice() const {
    return StyleBackgroundSizeVecSlice(AzStyleBackgroundSizeVec_asCSlice(&inner_));
}

inline StyleBackgroundSizeVecSlice StyleBackgroundSizeVec::as_c_slice_range(size_t start, size_t end) const {
    return StyleBackgroundSizeVecSlice(AzStyleBackgroundSizeVec_asCSliceRange(&inner_, start, end));
}

inline void StyleBackgroundSizeVec::delete_() {
    AzStyleBackgroundSizeVec_delete(&inner_);
}

inline StyleBackgroundSizeVec StyleBackgroundSizeVec::clone() const {
    return StyleBackgroundSizeVec(AzStyleBackgroundSizeVec_clone(&inner_));
}

inline bool StyleBackgroundSizeVec::partialEq(const StyleBackgroundSizeVec& b) const {
    return AzStyleBackgroundSizeVec_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBackgroundSizeVec::hash() const {
    return AzStyleBackgroundSizeVec_hash(&inner_);
}

inline uint8_t StyleBackgroundSizeVec::partialCmp(const StyleBackgroundSizeVec& b) const {
    return AzStyleBackgroundSizeVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBackgroundSizeVec::cmp(const StyleBackgroundSizeVec& b) const {
    return AzStyleBackgroundSizeVec_cmp(&inner_, b.ptr());
}

inline String StyleBackgroundSizeVec::toDbgString() const {
    return String(AzStyleBackgroundSizeVec_toDbgString(&inner_));
}

inline StyleTransformVec StyleTransformVec::create() {
    return StyleTransformVec(AzStyleTransformVec_create());
}

inline StyleTransformVec StyleTransformVec::with_capacity(size_t cap) {
    return StyleTransformVec(AzStyleTransformVec_withCapacity(cap));
}

inline size_t StyleTransformVec::len() const {
    return AzStyleTransformVec_len(&inner_);
}

inline size_t StyleTransformVec::capacity() const {
    return AzStyleTransformVec_capacity(&inner_);
}

inline bool StyleTransformVec::is_empty() const {
    return AzStyleTransformVec_isEmpty(&inner_);
}

inline OptionStyleTransform StyleTransformVec::get(size_t index) const {
    return OptionStyleTransform(AzStyleTransformVec_get(&inner_, index));
}

inline StyleTransformVec StyleTransformVec::from_item(AzStyleTransform item) {
    return StyleTransformVec(AzStyleTransformVec_fromItem(item));
}

inline StyleTransformVec StyleTransformVec::copy_from_ptr(const AzStyleTransform* ptr, size_t len) {
    return StyleTransformVec(AzStyleTransformVec_copyFromPtr(ptr, len));
}

inline OptionStyleTransform StyleTransformVec::c_get(size_t index) const {
    return OptionStyleTransform(AzStyleTransformVec_cGet(&inner_, index));
}

inline StyleTransformVecSlice StyleTransformVec::as_c_slice() const {
    return StyleTransformVecSlice(AzStyleTransformVec_asCSlice(&inner_));
}

inline StyleTransformVecSlice StyleTransformVec::as_c_slice_range(size_t start, size_t end) const {
    return StyleTransformVecSlice(AzStyleTransformVec_asCSliceRange(&inner_, start, end));
}

inline void StyleTransformVec::delete_() {
    AzStyleTransformVec_delete(&inner_);
}

inline StyleTransformVec StyleTransformVec::clone() const {
    return StyleTransformVec(AzStyleTransformVec_clone(&inner_));
}

inline bool StyleTransformVec::partialEq(const StyleTransformVec& b) const {
    return AzStyleTransformVec_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleTransformVec::hash() const {
    return AzStyleTransformVec_hash(&inner_);
}

inline uint8_t StyleTransformVec::partialCmp(const StyleTransformVec& b) const {
    return AzStyleTransformVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleTransformVec::cmp(const StyleTransformVec& b) const {
    return AzStyleTransformVec_cmp(&inner_, b.ptr());
}

inline String StyleTransformVec::toDbgString() const {
    return String(AzStyleTransformVec_toDbgString(&inner_));
}

inline SvgVertexVec SvgVertexVec::create() {
    return SvgVertexVec(AzSvgVertexVec_create());
}

inline SvgVertexVec SvgVertexVec::with_capacity(size_t cap) {
    return SvgVertexVec(AzSvgVertexVec_withCapacity(cap));
}

inline size_t SvgVertexVec::len() const {
    return AzSvgVertexVec_len(&inner_);
}

inline size_t SvgVertexVec::capacity() const {
    return AzSvgVertexVec_capacity(&inner_);
}

inline bool SvgVertexVec::is_empty() const {
    return AzSvgVertexVec_isEmpty(&inner_);
}

inline OptionSvgVertex SvgVertexVec::get(size_t index) const {
    return OptionSvgVertex(AzSvgVertexVec_get(&inner_, index));
}

inline SvgVertexVec SvgVertexVec::from_item(SvgVertex item) {
    return SvgVertexVec(AzSvgVertexVec_fromItem(item.release()));
}

inline SvgVertexVec SvgVertexVec::copy_from_ptr(const SvgVertex& ptr, size_t len) {
    return SvgVertexVec(AzSvgVertexVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionSvgVertex SvgVertexVec::c_get(size_t index) const {
    return OptionSvgVertex(AzSvgVertexVec_cGet(&inner_, index));
}

inline SvgVertexVecSlice SvgVertexVec::as_c_slice() const {
    return SvgVertexVecSlice(AzSvgVertexVec_asCSlice(&inner_));
}

inline SvgVertexVecSlice SvgVertexVec::as_c_slice_range(size_t start, size_t end) const {
    return SvgVertexVecSlice(AzSvgVertexVec_asCSliceRange(&inner_, start, end));
}

inline void SvgVertexVec::delete_() {
    AzSvgVertexVec_delete(&inner_);
}

inline SvgVertexVec SvgVertexVec::clone() const {
    return SvgVertexVec(AzSvgVertexVec_clone(&inner_));
}

inline bool SvgVertexVec::partialEq(const SvgVertexVec& b) const {
    return AzSvgVertexVec_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgVertexVec::partialCmp(const SvgVertexVec& b) const {
    return AzSvgVertexVec_partialCmp(&inner_, b.ptr());
}

inline String SvgVertexVec::toDbgString() const {
    return String(AzSvgVertexVec_toDbgString(&inner_));
}

inline U32Vec U32Vec::create() {
    return U32Vec(AzU32Vec_create());
}

inline U32Vec U32Vec::with_capacity(size_t cap) {
    return U32Vec(AzU32Vec_withCapacity(cap));
}

inline size_t U32Vec::len() const {
    return AzU32Vec_len(&inner_);
}

inline size_t U32Vec::capacity() const {
    return AzU32Vec_capacity(&inner_);
}

inline bool U32Vec::is_empty() const {
    return AzU32Vec_isEmpty(&inner_);
}

inline OptionU32 U32Vec::get(size_t index) const {
    return OptionU32(AzU32Vec_get(&inner_, index));
}

inline U32Vec U32Vec::from_item(uint32_t item) {
    return U32Vec(AzU32Vec_fromItem(item));
}

inline U32Vec U32Vec::copy_from_ptr(const uint32_t* ptr, size_t len) {
    return U32Vec(AzU32Vec_copyFromPtr(ptr, len));
}

inline OptionU32 U32Vec::c_get(size_t index) const {
    return OptionU32(AzU32Vec_cGet(&inner_, index));
}

inline U32VecSlice U32Vec::as_c_slice() const {
    return U32VecSlice(AzU32Vec_asCSlice(&inner_));
}

inline U32VecSlice U32Vec::as_c_slice_range(size_t start, size_t end) const {
    return U32VecSlice(AzU32Vec_asCSliceRange(&inner_, start, end));
}

inline void U32Vec::delete_() {
    AzU32Vec_delete(&inner_);
}

inline U32Vec U32Vec::clone() const {
    return U32Vec(AzU32Vec_clone(&inner_));
}

inline bool U32Vec::partialEq(const U32Vec& b) const {
    return AzU32Vec_partialEq(&inner_, b.ptr());
}

inline uint64_t U32Vec::hash() const {
    return AzU32Vec_hash(&inner_);
}

inline uint8_t U32Vec::partialCmp(const U32Vec& b) const {
    return AzU32Vec_partialCmp(&inner_, b.ptr());
}

inline uint8_t U32Vec::cmp(const U32Vec& b) const {
    return AzU32Vec_cmp(&inner_, b.ptr());
}

inline String U32Vec::toDbgString() const {
    return String(AzU32Vec_toDbgString(&inner_));
}

inline VirtualKeyCodeVec VirtualKeyCodeVec::create() {
    return VirtualKeyCodeVec(AzVirtualKeyCodeVec_create());
}

inline VirtualKeyCodeVec VirtualKeyCodeVec::with_capacity(size_t cap) {
    return VirtualKeyCodeVec(AzVirtualKeyCodeVec_withCapacity(cap));
}

inline size_t VirtualKeyCodeVec::len() const {
    return AzVirtualKeyCodeVec_len(&inner_);
}

inline size_t VirtualKeyCodeVec::capacity() const {
    return AzVirtualKeyCodeVec_capacity(&inner_);
}

inline bool VirtualKeyCodeVec::is_empty() const {
    return AzVirtualKeyCodeVec_isEmpty(&inner_);
}

inline OptionVirtualKeyCode VirtualKeyCodeVec::get(size_t index) const {
    return OptionVirtualKeyCode(AzVirtualKeyCodeVec_get(&inner_, index));
}

inline VirtualKeyCodeVec VirtualKeyCodeVec::from_item(AzVirtualKeyCode item) {
    return VirtualKeyCodeVec(AzVirtualKeyCodeVec_fromItem(item));
}

inline VirtualKeyCodeVec VirtualKeyCodeVec::copy_from_ptr(const AzVirtualKeyCode* ptr, size_t len) {
    return VirtualKeyCodeVec(AzVirtualKeyCodeVec_copyFromPtr(ptr, len));
}

inline OptionVirtualKeyCode VirtualKeyCodeVec::c_get(size_t index) const {
    return OptionVirtualKeyCode(AzVirtualKeyCodeVec_cGet(&inner_, index));
}

inline VirtualKeyCodeVecSlice VirtualKeyCodeVec::as_c_slice() const {
    return VirtualKeyCodeVecSlice(AzVirtualKeyCodeVec_asCSlice(&inner_));
}

inline VirtualKeyCodeVecSlice VirtualKeyCodeVec::as_c_slice_range(size_t start, size_t end) const {
    return VirtualKeyCodeVecSlice(AzVirtualKeyCodeVec_asCSliceRange(&inner_, start, end));
}

inline void VirtualKeyCodeVec::delete_() {
    AzVirtualKeyCodeVec_delete(&inner_);
}

inline VirtualKeyCodeVec VirtualKeyCodeVec::clone() const {
    return VirtualKeyCodeVec(AzVirtualKeyCodeVec_clone(&inner_));
}

inline bool VirtualKeyCodeVec::partialEq(const VirtualKeyCodeVec& b) const {
    return AzVirtualKeyCodeVec_partialEq(&inner_, b.ptr());
}

inline uint64_t VirtualKeyCodeVec::hash() const {
    return AzVirtualKeyCodeVec_hash(&inner_);
}

inline uint8_t VirtualKeyCodeVec::partialCmp(const VirtualKeyCodeVec& b) const {
    return AzVirtualKeyCodeVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t VirtualKeyCodeVec::cmp(const VirtualKeyCodeVec& b) const {
    return AzVirtualKeyCodeVec_cmp(&inner_, b.ptr());
}

inline String VirtualKeyCodeVec::toDbgString() const {
    return String(AzVirtualKeyCodeVec_toDbgString(&inner_));
}

inline CascadeInfoVec CascadeInfoVec::create() {
    return CascadeInfoVec(AzCascadeInfoVec_create());
}

inline CascadeInfoVec CascadeInfoVec::with_capacity(size_t cap) {
    return CascadeInfoVec(AzCascadeInfoVec_withCapacity(cap));
}

inline size_t CascadeInfoVec::len() const {
    return AzCascadeInfoVec_len(&inner_);
}

inline size_t CascadeInfoVec::capacity() const {
    return AzCascadeInfoVec_capacity(&inner_);
}

inline bool CascadeInfoVec::is_empty() const {
    return AzCascadeInfoVec_isEmpty(&inner_);
}

inline OptionCascadeInfo CascadeInfoVec::get(size_t index) const {
    return OptionCascadeInfo(AzCascadeInfoVec_get(&inner_, index));
}

inline CascadeInfoVec CascadeInfoVec::from_item(CascadeInfo item) {
    return CascadeInfoVec(AzCascadeInfoVec_fromItem(item.release()));
}

inline CascadeInfoVec CascadeInfoVec::copy_from_ptr(const CascadeInfo& ptr, size_t len) {
    return CascadeInfoVec(AzCascadeInfoVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionCascadeInfo CascadeInfoVec::c_get(size_t index) const {
    return OptionCascadeInfo(AzCascadeInfoVec_cGet(&inner_, index));
}

inline CascadeInfoVecSlice CascadeInfoVec::as_c_slice() const {
    return CascadeInfoVecSlice(AzCascadeInfoVec_asCSlice(&inner_));
}

inline CascadeInfoVecSlice CascadeInfoVec::as_c_slice_range(size_t start, size_t end) const {
    return CascadeInfoVecSlice(AzCascadeInfoVec_asCSliceRange(&inner_, start, end));
}

inline void CascadeInfoVec::delete_() {
    AzCascadeInfoVec_delete(&inner_);
}

inline CascadeInfoVec CascadeInfoVec::clone() const {
    return CascadeInfoVec(AzCascadeInfoVec_clone(&inner_));
}

inline bool CascadeInfoVec::partialEq(const CascadeInfoVec& b) const {
    return AzCascadeInfoVec_partialEq(&inner_, b.ptr());
}

inline uint8_t CascadeInfoVec::partialCmp(const CascadeInfoVec& b) const {
    return AzCascadeInfoVec_partialCmp(&inner_, b.ptr());
}

inline String CascadeInfoVec::toDbgString() const {
    return String(AzCascadeInfoVec_toDbgString(&inner_));
}

inline CssDeclarationVec CssDeclarationVec::create() {
    return CssDeclarationVec(AzCssDeclarationVec_create());
}

inline CssDeclarationVec CssDeclarationVec::with_capacity(size_t cap) {
    return CssDeclarationVec(AzCssDeclarationVec_withCapacity(cap));
}

inline size_t CssDeclarationVec::len() const {
    return AzCssDeclarationVec_len(&inner_);
}

inline size_t CssDeclarationVec::capacity() const {
    return AzCssDeclarationVec_capacity(&inner_);
}

inline bool CssDeclarationVec::is_empty() const {
    return AzCssDeclarationVec_isEmpty(&inner_);
}

inline OptionCssDeclaration CssDeclarationVec::get(size_t index) const {
    return OptionCssDeclaration(AzCssDeclarationVec_get(&inner_, index));
}

inline CssDeclarationVec CssDeclarationVec::from_item(AzCssDeclaration item) {
    return CssDeclarationVec(AzCssDeclarationVec_fromItem(item));
}

inline CssDeclarationVec CssDeclarationVec::copy_from_ptr(const AzCssDeclaration* ptr, size_t len) {
    return CssDeclarationVec(AzCssDeclarationVec_copyFromPtr(ptr, len));
}

inline OptionCssDeclaration CssDeclarationVec::c_get(size_t index) const {
    return OptionCssDeclaration(AzCssDeclarationVec_cGet(&inner_, index));
}

inline CssDeclarationVecSlice CssDeclarationVec::as_c_slice() const {
    return CssDeclarationVecSlice(AzCssDeclarationVec_asCSlice(&inner_));
}

inline CssDeclarationVecSlice CssDeclarationVec::as_c_slice_range(size_t start, size_t end) const {
    return CssDeclarationVecSlice(AzCssDeclarationVec_asCSliceRange(&inner_, start, end));
}

inline void CssDeclarationVec::delete_() {
    AzCssDeclarationVec_delete(&inner_);
}

inline CssDeclarationVec CssDeclarationVec::clone() const {
    return CssDeclarationVec(AzCssDeclarationVec_clone(&inner_));
}

inline bool CssDeclarationVec::partialEq(const CssDeclarationVec& b) const {
    return AzCssDeclarationVec_partialEq(&inner_, b.ptr());
}

inline uint64_t CssDeclarationVec::hash() const {
    return AzCssDeclarationVec_hash(&inner_);
}

inline uint8_t CssDeclarationVec::partialCmp(const CssDeclarationVec& b) const {
    return AzCssDeclarationVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t CssDeclarationVec::cmp(const CssDeclarationVec& b) const {
    return AzCssDeclarationVec_cmp(&inner_, b.ptr());
}

inline String CssDeclarationVec::toDbgString() const {
    return String(AzCssDeclarationVec_toDbgString(&inner_));
}

inline CssPathSelectorVec CssPathSelectorVec::create() {
    return CssPathSelectorVec(AzCssPathSelectorVec_create());
}

inline CssPathSelectorVec CssPathSelectorVec::with_capacity(size_t cap) {
    return CssPathSelectorVec(AzCssPathSelectorVec_withCapacity(cap));
}

inline size_t CssPathSelectorVec::len() const {
    return AzCssPathSelectorVec_len(&inner_);
}

inline size_t CssPathSelectorVec::capacity() const {
    return AzCssPathSelectorVec_capacity(&inner_);
}

inline bool CssPathSelectorVec::is_empty() const {
    return AzCssPathSelectorVec_isEmpty(&inner_);
}

inline OptionCssPathSelector CssPathSelectorVec::get(size_t index) const {
    return OptionCssPathSelector(AzCssPathSelectorVec_get(&inner_, index));
}

inline CssPathSelectorVec CssPathSelectorVec::from_item(AzCssPathSelector item) {
    return CssPathSelectorVec(AzCssPathSelectorVec_fromItem(item));
}

inline CssPathSelectorVec CssPathSelectorVec::copy_from_ptr(const AzCssPathSelector* ptr, size_t len) {
    return CssPathSelectorVec(AzCssPathSelectorVec_copyFromPtr(ptr, len));
}

inline OptionCssPathSelector CssPathSelectorVec::c_get(size_t index) const {
    return OptionCssPathSelector(AzCssPathSelectorVec_cGet(&inner_, index));
}

inline CssPathSelectorVecSlice CssPathSelectorVec::as_c_slice() const {
    return CssPathSelectorVecSlice(AzCssPathSelectorVec_asCSlice(&inner_));
}

inline CssPathSelectorVecSlice CssPathSelectorVec::as_c_slice_range(size_t start, size_t end) const {
    return CssPathSelectorVecSlice(AzCssPathSelectorVec_asCSliceRange(&inner_, start, end));
}

inline void CssPathSelectorVec::delete_() {
    AzCssPathSelectorVec_delete(&inner_);
}

inline CssPathSelectorVec CssPathSelectorVec::clone() const {
    return CssPathSelectorVec(AzCssPathSelectorVec_clone(&inner_));
}

inline bool CssPathSelectorVec::partialEq(const CssPathSelectorVec& b) const {
    return AzCssPathSelectorVec_partialEq(&inner_, b.ptr());
}

inline uint64_t CssPathSelectorVec::hash() const {
    return AzCssPathSelectorVec_hash(&inner_);
}

inline uint8_t CssPathSelectorVec::partialCmp(const CssPathSelectorVec& b) const {
    return AzCssPathSelectorVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t CssPathSelectorVec::cmp(const CssPathSelectorVec& b) const {
    return AzCssPathSelectorVec_cmp(&inner_, b.ptr());
}

inline String CssPathSelectorVec::toDbgString() const {
    return String(AzCssPathSelectorVec_toDbgString(&inner_));
}

inline CssVec CssVec::create() {
    return CssVec(AzCssVec_create());
}

inline CssVec CssVec::with_capacity(size_t cap) {
    return CssVec(AzCssVec_withCapacity(cap));
}

inline size_t CssVec::len() const {
    return AzCssVec_len(&inner_);
}

inline size_t CssVec::capacity() const {
    return AzCssVec_capacity(&inner_);
}

inline bool CssVec::is_empty() const {
    return AzCssVec_isEmpty(&inner_);
}

inline OptionCss CssVec::get(size_t index) const {
    return OptionCss(AzCssVec_get(&inner_, index));
}

inline CssVec CssVec::from_item(Css item) {
    return CssVec(AzCssVec_fromItem(item.release()));
}

inline CssVec CssVec::copy_from_ptr(const Css& ptr, size_t len) {
    return CssVec(AzCssVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionCss CssVec::c_get(size_t index) const {
    return OptionCss(AzCssVec_cGet(&inner_, index));
}

inline CssVecSlice CssVec::as_c_slice() const {
    return CssVecSlice(AzCssVec_asCSlice(&inner_));
}

inline CssVecSlice CssVec::as_c_slice_range(size_t start, size_t end) const {
    return CssVecSlice(AzCssVec_asCSliceRange(&inner_, start, end));
}

inline void CssVec::delete_() {
    AzCssVec_delete(&inner_);
}

inline CssVec CssVec::clone() const {
    return CssVec(AzCssVec_clone(&inner_));
}

inline bool CssVec::partialEq(const CssVec& b) const {
    return AzCssVec_partialEq(&inner_, b.ptr());
}

inline uint8_t CssVec::partialCmp(const CssVec& b) const {
    return AzCssVec_partialCmp(&inner_, b.ptr());
}

inline String CssVec::toDbgString() const {
    return String(AzCssVec_toDbgString(&inner_));
}

inline CssRuleBlockVec CssRuleBlockVec::create() {
    return CssRuleBlockVec(AzCssRuleBlockVec_create());
}

inline CssRuleBlockVec CssRuleBlockVec::with_capacity(size_t cap) {
    return CssRuleBlockVec(AzCssRuleBlockVec_withCapacity(cap));
}

inline size_t CssRuleBlockVec::len() const {
    return AzCssRuleBlockVec_len(&inner_);
}

inline size_t CssRuleBlockVec::capacity() const {
    return AzCssRuleBlockVec_capacity(&inner_);
}

inline bool CssRuleBlockVec::is_empty() const {
    return AzCssRuleBlockVec_isEmpty(&inner_);
}

inline OptionCssRuleBlock CssRuleBlockVec::get(size_t index) const {
    return OptionCssRuleBlock(AzCssRuleBlockVec_get(&inner_, index));
}

inline CssRuleBlockVec CssRuleBlockVec::from_item(CssRuleBlock item) {
    return CssRuleBlockVec(AzCssRuleBlockVec_fromItem(item.release()));
}

inline CssRuleBlockVec CssRuleBlockVec::copy_from_ptr(const CssRuleBlock& ptr, size_t len) {
    return CssRuleBlockVec(AzCssRuleBlockVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionCssRuleBlock CssRuleBlockVec::c_get(size_t index) const {
    return OptionCssRuleBlock(AzCssRuleBlockVec_cGet(&inner_, index));
}

inline CssRuleBlockVecSlice CssRuleBlockVec::as_c_slice() const {
    return CssRuleBlockVecSlice(AzCssRuleBlockVec_asCSlice(&inner_));
}

inline CssRuleBlockVecSlice CssRuleBlockVec::as_c_slice_range(size_t start, size_t end) const {
    return CssRuleBlockVecSlice(AzCssRuleBlockVec_asCSliceRange(&inner_, start, end));
}

inline void CssRuleBlockVec::delete_() {
    AzCssRuleBlockVec_delete(&inner_);
}

inline CssRuleBlockVec CssRuleBlockVec::clone() const {
    return CssRuleBlockVec(AzCssRuleBlockVec_clone(&inner_));
}

inline bool CssRuleBlockVec::partialEq(const CssRuleBlockVec& b) const {
    return AzCssRuleBlockVec_partialEq(&inner_, b.ptr());
}

inline uint8_t CssRuleBlockVec::partialCmp(const CssRuleBlockVec& b) const {
    return AzCssRuleBlockVec_partialCmp(&inner_, b.ptr());
}

inline String CssRuleBlockVec::toDbgString() const {
    return String(AzCssRuleBlockVec_toDbgString(&inner_));
}

inline U16Vec U16Vec::create() {
    return U16Vec(AzU16Vec_create());
}

inline U16Vec U16Vec::with_capacity(size_t cap) {
    return U16Vec(AzU16Vec_withCapacity(cap));
}

inline size_t U16Vec::len() const {
    return AzU16Vec_len(&inner_);
}

inline size_t U16Vec::capacity() const {
    return AzU16Vec_capacity(&inner_);
}

inline bool U16Vec::is_empty() const {
    return AzU16Vec_isEmpty(&inner_);
}

inline OptionU16 U16Vec::get(size_t index) const {
    return OptionU16(AzU16Vec_get(&inner_, index));
}

inline U16Vec U16Vec::from_item(uint16_t item) {
    return U16Vec(AzU16Vec_fromItem(item));
}

inline U16Vec U16Vec::copy_from_ptr(const uint16_t* ptr, size_t len) {
    return U16Vec(AzU16Vec_copyFromPtr(ptr, len));
}

inline OptionU16 U16Vec::c_get(size_t index) const {
    return OptionU16(AzU16Vec_cGet(&inner_, index));
}

inline U16VecSlice U16Vec::as_c_slice() const {
    return U16VecSlice(AzU16Vec_asCSlice(&inner_));
}

inline U16VecSlice U16Vec::as_c_slice_range(size_t start, size_t end) const {
    return U16VecSlice(AzU16Vec_asCSliceRange(&inner_, start, end));
}

inline void U16Vec::delete_() {
    AzU16Vec_delete(&inner_);
}

inline U16Vec U16Vec::clone() const {
    return U16Vec(AzU16Vec_clone(&inner_));
}

inline bool U16Vec::partialEq(const U16Vec& b) const {
    return AzU16Vec_partialEq(&inner_, b.ptr());
}

inline uint64_t U16Vec::hash() const {
    return AzU16Vec_hash(&inner_);
}

inline uint8_t U16Vec::partialCmp(const U16Vec& b) const {
    return AzU16Vec_partialCmp(&inner_, b.ptr());
}

inline uint8_t U16Vec::cmp(const U16Vec& b) const {
    return AzU16Vec_cmp(&inner_, b.ptr());
}

inline String U16Vec::toDbgString() const {
    return String(AzU16Vec_toDbgString(&inner_));
}

inline F32Vec F32Vec::create() {
    return F32Vec(AzF32Vec_create());
}

inline F32Vec F32Vec::with_capacity(size_t cap) {
    return F32Vec(AzF32Vec_withCapacity(cap));
}

inline size_t F32Vec::len() const {
    return AzF32Vec_len(&inner_);
}

inline size_t F32Vec::capacity() const {
    return AzF32Vec_capacity(&inner_);
}

inline bool F32Vec::is_empty() const {
    return AzF32Vec_isEmpty(&inner_);
}

inline OptionF32 F32Vec::get(size_t index) const {
    return OptionF32(AzF32Vec_get(&inner_, index));
}

inline F32Vec F32Vec::from_item(float item) {
    return F32Vec(AzF32Vec_fromItem(item));
}

inline F32Vec F32Vec::copy_from_ptr(const float* ptr, size_t len) {
    return F32Vec(AzF32Vec_copyFromPtr(ptr, len));
}

inline OptionF32 F32Vec::c_get(size_t index) const {
    return OptionF32(AzF32Vec_cGet(&inner_, index));
}

inline F32VecSlice F32Vec::as_c_slice() const {
    return F32VecSlice(AzF32Vec_asCSlice(&inner_));
}

inline F32VecSlice F32Vec::as_c_slice_range(size_t start, size_t end) const {
    return F32VecSlice(AzF32Vec_asCSliceRange(&inner_, start, end));
}

inline void F32Vec::delete_() {
    AzF32Vec_delete(&inner_);
}

inline F32Vec F32Vec::clone() const {
    return F32Vec(AzF32Vec_clone(&inner_));
}

inline bool F32Vec::partialEq(const F32Vec& b) const {
    return AzF32Vec_partialEq(&inner_, b.ptr());
}

inline uint8_t F32Vec::partialCmp(const F32Vec& b) const {
    return AzF32Vec_partialCmp(&inner_, b.ptr());
}

inline String F32Vec::toDbgString() const {
    return String(AzF32Vec_toDbgString(&inner_));
}

inline U8Vec U8Vec::copy_from_bytes(const uint8_t* ptr, size_t start, size_t len) {
    return U8Vec(AzU8Vec_copyFromBytes(ptr, start, len));
}

inline U8VecRef U8Vec::as_ref_vec() const {
    return U8VecRef(AzU8Vec_asRefVec(&inner_));
}

inline U8Vec U8Vec::create() {
    return U8Vec(AzU8Vec_create());
}

inline U8Vec U8Vec::with_capacity(size_t cap) {
    return U8Vec(AzU8Vec_withCapacity(cap));
}

inline size_t U8Vec::len() const {
    return AzU8Vec_len(&inner_);
}

inline size_t U8Vec::capacity() const {
    return AzU8Vec_capacity(&inner_);
}

inline bool U8Vec::is_empty() const {
    return AzU8Vec_isEmpty(&inner_);
}

inline OptionU8 U8Vec::get(size_t index) const {
    return OptionU8(AzU8Vec_get(&inner_, index));
}

inline U8Vec U8Vec::from_item(uint8_t item) {
    return U8Vec(AzU8Vec_fromItem(item));
}

inline U8Vec U8Vec::copy_from_ptr(const uint8_t* ptr, size_t len) {
    return U8Vec(AzU8Vec_copyFromPtr(ptr, len));
}

inline OptionU8 U8Vec::c_get(size_t index) const {
    return OptionU8(AzU8Vec_cGet(&inner_, index));
}

inline U8VecSlice U8Vec::as_c_slice() const {
    return U8VecSlice(AzU8Vec_asCSlice(&inner_));
}

inline U8VecSlice U8Vec::as_c_slice_range(size_t start, size_t end) const {
    return U8VecSlice(AzU8Vec_asCSliceRange(&inner_, start, end));
}

inline void U8Vec::delete_() {
    AzU8Vec_delete(&inner_);
}

inline U8Vec U8Vec::clone() const {
    return U8Vec(AzU8Vec_clone(&inner_));
}

inline bool U8Vec::partialEq(const U8Vec& b) const {
    return AzU8Vec_partialEq(&inner_, b.ptr());
}

inline uint64_t U8Vec::hash() const {
    return AzU8Vec_hash(&inner_);
}

inline uint8_t U8Vec::partialCmp(const U8Vec& b) const {
    return AzU8Vec_partialCmp(&inner_, b.ptr());
}

inline uint8_t U8Vec::cmp(const U8Vec& b) const {
    return AzU8Vec_cmp(&inner_, b.ptr());
}

inline String U8Vec::toDbgString() const {
    return String(AzU8Vec_toDbgString(&inner_));
}

inline GLuintVec GLuintVec::create() {
    return GLuintVec(AzGLuintVec_create());
}

inline GLuintVec GLuintVec::with_capacity(size_t cap) {
    return GLuintVec(AzGLuintVec_withCapacity(cap));
}

inline size_t GLuintVec::len() const {
    return AzGLuintVec_len(&inner_);
}

inline size_t GLuintVec::capacity() const {
    return AzGLuintVec_capacity(&inner_);
}

inline bool GLuintVec::is_empty() const {
    return AzGLuintVec_isEmpty(&inner_);
}

inline OptionU32 GLuintVec::get(size_t index) const {
    return OptionU32(AzGLuintVec_get(&inner_, index));
}

inline GLuintVec GLuintVec::from_item(AzGLuint item) {
    return GLuintVec(AzGLuintVec_fromItem(item));
}

inline GLuintVec GLuintVec::copy_from_ptr(const AzGLuint* ptr, size_t len) {
    return GLuintVec(AzGLuintVec_copyFromPtr(ptr, len));
}

inline OptionU32 GLuintVec::c_get(size_t index) const {
    return OptionU32(AzGLuintVec_cGet(&inner_, index));
}

inline GLuintVecSlice GLuintVec::as_c_slice() const {
    return GLuintVecSlice(AzGLuintVec_asCSlice(&inner_));
}

inline GLuintVecSlice GLuintVec::as_c_slice_range(size_t start, size_t end) const {
    return GLuintVecSlice(AzGLuintVec_asCSliceRange(&inner_, start, end));
}

inline void GLuintVec::delete_() {
    AzGLuintVec_delete(&inner_);
}

inline GLuintVec GLuintVec::clone() const {
    return GLuintVec(AzGLuintVec_clone(&inner_));
}

inline bool GLuintVec::partialEq(const GLuintVec& b) const {
    return AzGLuintVec_partialEq(&inner_, b.ptr());
}

inline uint64_t GLuintVec::hash() const {
    return AzGLuintVec_hash(&inner_);
}

inline uint8_t GLuintVec::partialCmp(const GLuintVec& b) const {
    return AzGLuintVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t GLuintVec::cmp(const GLuintVec& b) const {
    return AzGLuintVec_cmp(&inner_, b.ptr());
}

inline String GLuintVec::toDbgString() const {
    return String(AzGLuintVec_toDbgString(&inner_));
}

inline GLintVec GLintVec::create() {
    return GLintVec(AzGLintVec_create());
}

inline GLintVec GLintVec::with_capacity(size_t cap) {
    return GLintVec(AzGLintVec_withCapacity(cap));
}

inline size_t GLintVec::len() const {
    return AzGLintVec_len(&inner_);
}

inline size_t GLintVec::capacity() const {
    return AzGLintVec_capacity(&inner_);
}

inline bool GLintVec::is_empty() const {
    return AzGLintVec_isEmpty(&inner_);
}

inline OptionI32 GLintVec::get(size_t index) const {
    return OptionI32(AzGLintVec_get(&inner_, index));
}

inline GLintVec GLintVec::from_item(AzGLint item) {
    return GLintVec(AzGLintVec_fromItem(item));
}

inline GLintVec GLintVec::copy_from_ptr(const AzGLint* ptr, size_t len) {
    return GLintVec(AzGLintVec_copyFromPtr(ptr, len));
}

inline OptionI32 GLintVec::c_get(size_t index) const {
    return OptionI32(AzGLintVec_cGet(&inner_, index));
}

inline GLintVecSlice GLintVec::as_c_slice() const {
    return GLintVecSlice(AzGLintVec_asCSlice(&inner_));
}

inline GLintVecSlice GLintVec::as_c_slice_range(size_t start, size_t end) const {
    return GLintVecSlice(AzGLintVec_asCSliceRange(&inner_, start, end));
}

inline void GLintVec::delete_() {
    AzGLintVec_delete(&inner_);
}

inline GLintVec GLintVec::clone() const {
    return GLintVec(AzGLintVec_clone(&inner_));
}

inline bool GLintVec::partialEq(const GLintVec& b) const {
    return AzGLintVec_partialEq(&inner_, b.ptr());
}

inline uint64_t GLintVec::hash() const {
    return AzGLintVec_hash(&inner_);
}

inline uint8_t GLintVec::partialCmp(const GLintVec& b) const {
    return AzGLintVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t GLintVec::cmp(const GLintVec& b) const {
    return AzGLintVec_cmp(&inner_, b.ptr());
}

inline String GLintVec::toDbgString() const {
    return String(AzGLintVec_toDbgString(&inner_));
}

inline StringVec StringVec::create() {
    return StringVec(AzStringVec_create());
}

inline StringVec StringVec::with_capacity(size_t cap) {
    return StringVec(AzStringVec_withCapacity(cap));
}

inline size_t StringVec::len() const {
    return AzStringVec_len(&inner_);
}

inline size_t StringVec::capacity() const {
    return AzStringVec_capacity(&inner_);
}

inline bool StringVec::is_empty() const {
    return AzStringVec_isEmpty(&inner_);
}

inline OptionString StringVec::get(size_t index) const {
    return OptionString(AzStringVec_get(&inner_, index));
}

inline StringVec StringVec::from_item(String item) {
    return StringVec(AzStringVec_fromItem(item.release()));
}

inline StringVec StringVec::copy_from_ptr(const String& ptr, size_t len) {
    return StringVec(AzStringVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionString StringVec::c_get(size_t index) const {
    return OptionString(AzStringVec_cGet(&inner_, index));
}

inline StringVecSlice StringVec::as_c_slice() const {
    return StringVecSlice(AzStringVec_asCSlice(&inner_));
}

inline StringVecSlice StringVec::as_c_slice_range(size_t start, size_t end) const {
    return StringVecSlice(AzStringVec_asCSliceRange(&inner_, start, end));
}

inline void StringVec::delete_() {
    AzStringVec_delete(&inner_);
}

inline StringVec StringVec::clone() const {
    return StringVec(AzStringVec_clone(&inner_));
}

inline bool StringVec::partialEq(const StringVec& b) const {
    return AzStringVec_partialEq(&inner_, b.ptr());
}

inline uint64_t StringVec::hash() const {
    return AzStringVec_hash(&inner_);
}

inline uint8_t StringVec::partialCmp(const StringVec& b) const {
    return AzStringVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t StringVec::cmp(const StringVec& b) const {
    return AzStringVec_cmp(&inner_, b.ptr());
}

inline String StringVec::toDbgString() const {
    return String(AzStringVec_toDbgString(&inner_));
}

inline MimeTypeDataVec MimeTypeDataVec::create() {
    return MimeTypeDataVec(AzMimeTypeDataVec_create());
}

inline MimeTypeDataVec MimeTypeDataVec::with_capacity(size_t cap) {
    return MimeTypeDataVec(AzMimeTypeDataVec_withCapacity(cap));
}

inline size_t MimeTypeDataVec::len() const {
    return AzMimeTypeDataVec_len(&inner_);
}

inline size_t MimeTypeDataVec::capacity() const {
    return AzMimeTypeDataVec_capacity(&inner_);
}

inline bool MimeTypeDataVec::is_empty() const {
    return AzMimeTypeDataVec_isEmpty(&inner_);
}

inline OptionMimeTypeData MimeTypeDataVec::get(size_t index) const {
    return OptionMimeTypeData(AzMimeTypeDataVec_get(&inner_, index));
}

inline MimeTypeDataVec MimeTypeDataVec::from_item(MimeTypeData item) {
    return MimeTypeDataVec(AzMimeTypeDataVec_fromItem(item.release()));
}

inline MimeTypeDataVec MimeTypeDataVec::copy_from_ptr(const MimeTypeData& ptr, size_t len) {
    return MimeTypeDataVec(AzMimeTypeDataVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionMimeTypeData MimeTypeDataVec::c_get(size_t index) const {
    return OptionMimeTypeData(AzMimeTypeDataVec_cGet(&inner_, index));
}

inline MimeTypeDataVecSlice MimeTypeDataVec::as_c_slice() const {
    return MimeTypeDataVecSlice(AzMimeTypeDataVec_asCSlice(&inner_));
}

inline MimeTypeDataVecSlice MimeTypeDataVec::as_c_slice_range(size_t start, size_t end) const {
    return MimeTypeDataVecSlice(AzMimeTypeDataVec_asCSliceRange(&inner_, start, end));
}

inline void MimeTypeDataVec::delete_() {
    AzMimeTypeDataVec_delete(&inner_);
}

inline MimeTypeDataVec MimeTypeDataVec::clone() const {
    return MimeTypeDataVec(AzMimeTypeDataVec_clone(&inner_));
}

inline bool MimeTypeDataVec::partialEq(const MimeTypeDataVec& b) const {
    return AzMimeTypeDataVec_partialEq(&inner_, b.ptr());
}

inline uint64_t MimeTypeDataVec::hash() const {
    return AzMimeTypeDataVec_hash(&inner_);
}

inline uint8_t MimeTypeDataVec::partialCmp(const MimeTypeDataVec& b) const {
    return AzMimeTypeDataVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t MimeTypeDataVec::cmp(const MimeTypeDataVec& b) const {
    return AzMimeTypeDataVec_cmp(&inner_, b.ptr());
}

inline String MimeTypeDataVec::toDbgString() const {
    return String(AzMimeTypeDataVec_toDbgString(&inner_));
}

inline StringPairVec StringPairVec::create() {
    return StringPairVec(AzStringPairVec_create());
}

inline StringPairVec StringPairVec::with_capacity(size_t cap) {
    return StringPairVec(AzStringPairVec_withCapacity(cap));
}

inline size_t StringPairVec::len() const {
    return AzStringPairVec_len(&inner_);
}

inline size_t StringPairVec::capacity() const {
    return AzStringPairVec_capacity(&inner_);
}

inline bool StringPairVec::is_empty() const {
    return AzStringPairVec_isEmpty(&inner_);
}

inline OptionStringPair StringPairVec::get(size_t index) const {
    return OptionStringPair(AzStringPairVec_get(&inner_, index));
}

inline StringPairVec StringPairVec::from_item(StringPair item) {
    return StringPairVec(AzStringPairVec_fromItem(item.release()));
}

inline StringPairVec StringPairVec::copy_from_ptr(const StringPair& ptr, size_t len) {
    return StringPairVec(AzStringPairVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionStringPair StringPairVec::c_get(size_t index) const {
    return OptionStringPair(AzStringPairVec_cGet(&inner_, index));
}

inline StringPairVecSlice StringPairVec::as_c_slice() const {
    return StringPairVecSlice(AzStringPairVec_asCSlice(&inner_));
}

inline StringPairVecSlice StringPairVec::as_c_slice_range(size_t start, size_t end) const {
    return StringPairVecSlice(AzStringPairVec_asCSliceRange(&inner_, start, end));
}

inline void StringPairVec::delete_() {
    AzStringPairVec_delete(&inner_);
}

inline StringPairVec StringPairVec::clone() const {
    return StringPairVec(AzStringPairVec_clone(&inner_));
}

inline bool StringPairVec::partialEq(const StringPairVec& b) const {
    return AzStringPairVec_partialEq(&inner_, b.ptr());
}

inline uint64_t StringPairVec::hash() const {
    return AzStringPairVec_hash(&inner_);
}

inline uint8_t StringPairVec::partialCmp(const StringPairVec& b) const {
    return AzStringPairVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t StringPairVec::cmp(const StringPairVec& b) const {
    return AzStringPairVec_cmp(&inner_, b.ptr());
}

inline String StringPairVec::toDbgString() const {
    return String(AzStringPairVec_toDbgString(&inner_));
}

inline NormalizedLinearColorStopVec NormalizedLinearColorStopVec::create() {
    return NormalizedLinearColorStopVec(AzNormalizedLinearColorStopVec_create());
}

inline NormalizedLinearColorStopVec NormalizedLinearColorStopVec::with_capacity(size_t cap) {
    return NormalizedLinearColorStopVec(AzNormalizedLinearColorStopVec_withCapacity(cap));
}

inline size_t NormalizedLinearColorStopVec::len() const {
    return AzNormalizedLinearColorStopVec_len(&inner_);
}

inline size_t NormalizedLinearColorStopVec::capacity() const {
    return AzNormalizedLinearColorStopVec_capacity(&inner_);
}

inline bool NormalizedLinearColorStopVec::is_empty() const {
    return AzNormalizedLinearColorStopVec_isEmpty(&inner_);
}

inline OptionNormalizedLinearColorStop NormalizedLinearColorStopVec::get(size_t index) const {
    return OptionNormalizedLinearColorStop(AzNormalizedLinearColorStopVec_get(&inner_, index));
}

inline NormalizedLinearColorStopVec NormalizedLinearColorStopVec::from_item(NormalizedLinearColorStop item) {
    return NormalizedLinearColorStopVec(AzNormalizedLinearColorStopVec_fromItem(item.release()));
}

inline NormalizedLinearColorStopVec NormalizedLinearColorStopVec::copy_from_ptr(const NormalizedLinearColorStop& ptr, size_t len) {
    return NormalizedLinearColorStopVec(AzNormalizedLinearColorStopVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionNormalizedLinearColorStop NormalizedLinearColorStopVec::c_get(size_t index) const {
    return OptionNormalizedLinearColorStop(AzNormalizedLinearColorStopVec_cGet(&inner_, index));
}

inline NormalizedLinearColorStopVecSlice NormalizedLinearColorStopVec::as_c_slice() const {
    return NormalizedLinearColorStopVecSlice(AzNormalizedLinearColorStopVec_asCSlice(&inner_));
}

inline NormalizedLinearColorStopVecSlice NormalizedLinearColorStopVec::as_c_slice_range(size_t start, size_t end) const {
    return NormalizedLinearColorStopVecSlice(AzNormalizedLinearColorStopVec_asCSliceRange(&inner_, start, end));
}

inline void NormalizedLinearColorStopVec::delete_() {
    AzNormalizedLinearColorStopVec_delete(&inner_);
}

inline NormalizedLinearColorStopVec NormalizedLinearColorStopVec::clone() const {
    return NormalizedLinearColorStopVec(AzNormalizedLinearColorStopVec_clone(&inner_));
}

inline bool NormalizedLinearColorStopVec::partialEq(const NormalizedLinearColorStopVec& b) const {
    return AzNormalizedLinearColorStopVec_partialEq(&inner_, b.ptr());
}

inline uint64_t NormalizedLinearColorStopVec::hash() const {
    return AzNormalizedLinearColorStopVec_hash(&inner_);
}

inline uint8_t NormalizedLinearColorStopVec::partialCmp(const NormalizedLinearColorStopVec& b) const {
    return AzNormalizedLinearColorStopVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t NormalizedLinearColorStopVec::cmp(const NormalizedLinearColorStopVec& b) const {
    return AzNormalizedLinearColorStopVec_cmp(&inner_, b.ptr());
}

inline String NormalizedLinearColorStopVec::toDbgString() const {
    return String(AzNormalizedLinearColorStopVec_toDbgString(&inner_));
}

inline NormalizedRadialColorStopVec NormalizedRadialColorStopVec::create() {
    return NormalizedRadialColorStopVec(AzNormalizedRadialColorStopVec_create());
}

inline NormalizedRadialColorStopVec NormalizedRadialColorStopVec::with_capacity(size_t cap) {
    return NormalizedRadialColorStopVec(AzNormalizedRadialColorStopVec_withCapacity(cap));
}

inline size_t NormalizedRadialColorStopVec::len() const {
    return AzNormalizedRadialColorStopVec_len(&inner_);
}

inline size_t NormalizedRadialColorStopVec::capacity() const {
    return AzNormalizedRadialColorStopVec_capacity(&inner_);
}

inline bool NormalizedRadialColorStopVec::is_empty() const {
    return AzNormalizedRadialColorStopVec_isEmpty(&inner_);
}

inline OptionNormalizedRadialColorStop NormalizedRadialColorStopVec::get(size_t index) const {
    return OptionNormalizedRadialColorStop(AzNormalizedRadialColorStopVec_get(&inner_, index));
}

inline NormalizedRadialColorStopVec NormalizedRadialColorStopVec::from_item(NormalizedRadialColorStop item) {
    return NormalizedRadialColorStopVec(AzNormalizedRadialColorStopVec_fromItem(item.release()));
}

inline NormalizedRadialColorStopVec NormalizedRadialColorStopVec::copy_from_ptr(const NormalizedRadialColorStop& ptr, size_t len) {
    return NormalizedRadialColorStopVec(AzNormalizedRadialColorStopVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionNormalizedRadialColorStop NormalizedRadialColorStopVec::c_get(size_t index) const {
    return OptionNormalizedRadialColorStop(AzNormalizedRadialColorStopVec_cGet(&inner_, index));
}

inline NormalizedRadialColorStopVecSlice NormalizedRadialColorStopVec::as_c_slice() const {
    return NormalizedRadialColorStopVecSlice(AzNormalizedRadialColorStopVec_asCSlice(&inner_));
}

inline NormalizedRadialColorStopVecSlice NormalizedRadialColorStopVec::as_c_slice_range(size_t start, size_t end) const {
    return NormalizedRadialColorStopVecSlice(AzNormalizedRadialColorStopVec_asCSliceRange(&inner_, start, end));
}

inline void NormalizedRadialColorStopVec::delete_() {
    AzNormalizedRadialColorStopVec_delete(&inner_);
}

inline NormalizedRadialColorStopVec NormalizedRadialColorStopVec::clone() const {
    return NormalizedRadialColorStopVec(AzNormalizedRadialColorStopVec_clone(&inner_));
}

inline bool NormalizedRadialColorStopVec::partialEq(const NormalizedRadialColorStopVec& b) const {
    return AzNormalizedRadialColorStopVec_partialEq(&inner_, b.ptr());
}

inline uint64_t NormalizedRadialColorStopVec::hash() const {
    return AzNormalizedRadialColorStopVec_hash(&inner_);
}

inline uint8_t NormalizedRadialColorStopVec::partialCmp(const NormalizedRadialColorStopVec& b) const {
    return AzNormalizedRadialColorStopVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t NormalizedRadialColorStopVec::cmp(const NormalizedRadialColorStopVec& b) const {
    return AzNormalizedRadialColorStopVec_cmp(&inner_, b.ptr());
}

inline String NormalizedRadialColorStopVec::toDbgString() const {
    return String(AzNormalizedRadialColorStopVec_toDbgString(&inner_));
}

inline NodeHierarchyItemVec NodeHierarchyItemVec::create() {
    return NodeHierarchyItemVec(AzNodeHierarchyItemVec_create());
}

inline NodeHierarchyItemVec NodeHierarchyItemVec::with_capacity(size_t cap) {
    return NodeHierarchyItemVec(AzNodeHierarchyItemVec_withCapacity(cap));
}

inline size_t NodeHierarchyItemVec::len() const {
    return AzNodeHierarchyItemVec_len(&inner_);
}

inline size_t NodeHierarchyItemVec::capacity() const {
    return AzNodeHierarchyItemVec_capacity(&inner_);
}

inline bool NodeHierarchyItemVec::is_empty() const {
    return AzNodeHierarchyItemVec_isEmpty(&inner_);
}

inline OptionNodeHierarchyItem NodeHierarchyItemVec::get(size_t index) const {
    return OptionNodeHierarchyItem(AzNodeHierarchyItemVec_get(&inner_, index));
}

inline NodeHierarchyItemVec NodeHierarchyItemVec::from_item(NodeHierarchyItem item) {
    return NodeHierarchyItemVec(AzNodeHierarchyItemVec_fromItem(item.release()));
}

inline NodeHierarchyItemVec NodeHierarchyItemVec::copy_from_ptr(const NodeHierarchyItem& ptr, size_t len) {
    return NodeHierarchyItemVec(AzNodeHierarchyItemVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionNodeHierarchyItem NodeHierarchyItemVec::c_get(size_t index) const {
    return OptionNodeHierarchyItem(AzNodeHierarchyItemVec_cGet(&inner_, index));
}

inline NodeHierarchyItemVecSlice NodeHierarchyItemVec::as_c_slice() const {
    return NodeHierarchyItemVecSlice(AzNodeHierarchyItemVec_asCSlice(&inner_));
}

inline NodeHierarchyItemVecSlice NodeHierarchyItemVec::as_c_slice_range(size_t start, size_t end) const {
    return NodeHierarchyItemVecSlice(AzNodeHierarchyItemVec_asCSliceRange(&inner_, start, end));
}

inline void NodeHierarchyItemVec::delete_() {
    AzNodeHierarchyItemVec_delete(&inner_);
}

inline NodeHierarchyItemVec NodeHierarchyItemVec::clone() const {
    return NodeHierarchyItemVec(AzNodeHierarchyItemVec_clone(&inner_));
}

inline bool NodeHierarchyItemVec::partialEq(const NodeHierarchyItemVec& b) const {
    return AzNodeHierarchyItemVec_partialEq(&inner_, b.ptr());
}

inline uint8_t NodeHierarchyItemVec::partialCmp(const NodeHierarchyItemVec& b) const {
    return AzNodeHierarchyItemVec_partialCmp(&inner_, b.ptr());
}

inline String NodeHierarchyItemVec::toDbgString() const {
    return String(AzNodeHierarchyItemVec_toDbgString(&inner_));
}

inline TagIdToNodeIdMappingVec TagIdToNodeIdMappingVec::create() {
    return TagIdToNodeIdMappingVec(AzTagIdToNodeIdMappingVec_create());
}

inline TagIdToNodeIdMappingVec TagIdToNodeIdMappingVec::with_capacity(size_t cap) {
    return TagIdToNodeIdMappingVec(AzTagIdToNodeIdMappingVec_withCapacity(cap));
}

inline size_t TagIdToNodeIdMappingVec::len() const {
    return AzTagIdToNodeIdMappingVec_len(&inner_);
}

inline size_t TagIdToNodeIdMappingVec::capacity() const {
    return AzTagIdToNodeIdMappingVec_capacity(&inner_);
}

inline bool TagIdToNodeIdMappingVec::is_empty() const {
    return AzTagIdToNodeIdMappingVec_isEmpty(&inner_);
}

inline OptionTagIdToNodeIdMapping TagIdToNodeIdMappingVec::get(size_t index) const {
    return OptionTagIdToNodeIdMapping(AzTagIdToNodeIdMappingVec_get(&inner_, index));
}

inline TagIdToNodeIdMappingVec TagIdToNodeIdMappingVec::from_item(TagIdToNodeIdMapping item) {
    return TagIdToNodeIdMappingVec(AzTagIdToNodeIdMappingVec_fromItem(item.release()));
}

inline TagIdToNodeIdMappingVec TagIdToNodeIdMappingVec::copy_from_ptr(const TagIdToNodeIdMapping& ptr, size_t len) {
    return TagIdToNodeIdMappingVec(AzTagIdToNodeIdMappingVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionTagIdToNodeIdMapping TagIdToNodeIdMappingVec::c_get(size_t index) const {
    return OptionTagIdToNodeIdMapping(AzTagIdToNodeIdMappingVec_cGet(&inner_, index));
}

inline TagIdToNodeIdMappingVecSlice TagIdToNodeIdMappingVec::as_c_slice() const {
    return TagIdToNodeIdMappingVecSlice(AzTagIdToNodeIdMappingVec_asCSlice(&inner_));
}

inline TagIdToNodeIdMappingVecSlice TagIdToNodeIdMappingVec::as_c_slice_range(size_t start, size_t end) const {
    return TagIdToNodeIdMappingVecSlice(AzTagIdToNodeIdMappingVec_asCSliceRange(&inner_, start, end));
}

inline void TagIdToNodeIdMappingVec::delete_() {
    AzTagIdToNodeIdMappingVec_delete(&inner_);
}

inline TagIdToNodeIdMappingVec TagIdToNodeIdMappingVec::clone() const {
    return TagIdToNodeIdMappingVec(AzTagIdToNodeIdMappingVec_clone(&inner_));
}

inline bool TagIdToNodeIdMappingVec::partialEq(const TagIdToNodeIdMappingVec& b) const {
    return AzTagIdToNodeIdMappingVec_partialEq(&inner_, b.ptr());
}

inline uint8_t TagIdToNodeIdMappingVec::partialCmp(const TagIdToNodeIdMappingVec& b) const {
    return AzTagIdToNodeIdMappingVec_partialCmp(&inner_, b.ptr());
}

inline String TagIdToNodeIdMappingVec::toDbgString() const {
    return String(AzTagIdToNodeIdMappingVec_toDbgString(&inner_));
}

inline ParentWithNodeDepthVec ParentWithNodeDepthVec::create() {
    return ParentWithNodeDepthVec(AzParentWithNodeDepthVec_create());
}

inline ParentWithNodeDepthVec ParentWithNodeDepthVec::with_capacity(size_t cap) {
    return ParentWithNodeDepthVec(AzParentWithNodeDepthVec_withCapacity(cap));
}

inline size_t ParentWithNodeDepthVec::len() const {
    return AzParentWithNodeDepthVec_len(&inner_);
}

inline size_t ParentWithNodeDepthVec::capacity() const {
    return AzParentWithNodeDepthVec_capacity(&inner_);
}

inline bool ParentWithNodeDepthVec::is_empty() const {
    return AzParentWithNodeDepthVec_isEmpty(&inner_);
}

inline OptionParentWithNodeDepth ParentWithNodeDepthVec::get(size_t index) const {
    return OptionParentWithNodeDepth(AzParentWithNodeDepthVec_get(&inner_, index));
}

inline ParentWithNodeDepthVec ParentWithNodeDepthVec::from_item(ParentWithNodeDepth item) {
    return ParentWithNodeDepthVec(AzParentWithNodeDepthVec_fromItem(item.release()));
}

inline ParentWithNodeDepthVec ParentWithNodeDepthVec::copy_from_ptr(const ParentWithNodeDepth& ptr, size_t len) {
    return ParentWithNodeDepthVec(AzParentWithNodeDepthVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionParentWithNodeDepth ParentWithNodeDepthVec::c_get(size_t index) const {
    return OptionParentWithNodeDepth(AzParentWithNodeDepthVec_cGet(&inner_, index));
}

inline ParentWithNodeDepthVecSlice ParentWithNodeDepthVec::as_c_slice() const {
    return ParentWithNodeDepthVecSlice(AzParentWithNodeDepthVec_asCSlice(&inner_));
}

inline ParentWithNodeDepthVecSlice ParentWithNodeDepthVec::as_c_slice_range(size_t start, size_t end) const {
    return ParentWithNodeDepthVecSlice(AzParentWithNodeDepthVec_asCSliceRange(&inner_, start, end));
}

inline void ParentWithNodeDepthVec::delete_() {
    AzParentWithNodeDepthVec_delete(&inner_);
}

inline ParentWithNodeDepthVec ParentWithNodeDepthVec::clone() const {
    return ParentWithNodeDepthVec(AzParentWithNodeDepthVec_clone(&inner_));
}

inline bool ParentWithNodeDepthVec::partialEq(const ParentWithNodeDepthVec& b) const {
    return AzParentWithNodeDepthVec_partialEq(&inner_, b.ptr());
}

inline uint8_t ParentWithNodeDepthVec::partialCmp(const ParentWithNodeDepthVec& b) const {
    return AzParentWithNodeDepthVec_partialCmp(&inner_, b.ptr());
}

inline String ParentWithNodeDepthVec::toDbgString() const {
    return String(AzParentWithNodeDepthVec_toDbgString(&inner_));
}

inline NodeDataVec NodeDataVec::create() {
    return NodeDataVec(AzNodeDataVec_create());
}

inline NodeDataVec NodeDataVec::with_capacity(size_t cap) {
    return NodeDataVec(AzNodeDataVec_withCapacity(cap));
}

inline size_t NodeDataVec::len() const {
    return AzNodeDataVec_len(&inner_);
}

inline size_t NodeDataVec::capacity() const {
    return AzNodeDataVec_capacity(&inner_);
}

inline bool NodeDataVec::is_empty() const {
    return AzNodeDataVec_isEmpty(&inner_);
}

inline OptionNodeData NodeDataVec::get(size_t index) const {
    return OptionNodeData(AzNodeDataVec_get(&inner_, index));
}

inline NodeDataVec NodeDataVec::from_item(NodeData item) {
    return NodeDataVec(AzNodeDataVec_fromItem(item.release()));
}

inline NodeDataVec NodeDataVec::copy_from_ptr(const NodeData& ptr, size_t len) {
    return NodeDataVec(AzNodeDataVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionNodeData NodeDataVec::c_get(size_t index) const {
    return OptionNodeData(AzNodeDataVec_cGet(&inner_, index));
}

inline NodeDataVecSlice NodeDataVec::as_c_slice() const {
    return NodeDataVecSlice(AzNodeDataVec_asCSlice(&inner_));
}

inline NodeDataVecSlice NodeDataVec::as_c_slice_range(size_t start, size_t end) const {
    return NodeDataVecSlice(AzNodeDataVec_asCSliceRange(&inner_, start, end));
}

inline void NodeDataVec::delete_() {
    AzNodeDataVec_delete(&inner_);
}

inline NodeDataVec NodeDataVec::clone() const {
    return NodeDataVec(AzNodeDataVec_clone(&inner_));
}

inline bool NodeDataVec::partialEq(const NodeDataVec& b) const {
    return AzNodeDataVec_partialEq(&inner_, b.ptr());
}

inline uint64_t NodeDataVec::hash() const {
    return AzNodeDataVec_hash(&inner_);
}

inline uint8_t NodeDataVec::partialCmp(const NodeDataVec& b) const {
    return AzNodeDataVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t NodeDataVec::cmp(const NodeDataVec& b) const {
    return AzNodeDataVec_cmp(&inner_, b.ptr());
}

inline String NodeDataVec::toDbgString() const {
    return String(AzNodeDataVec_toDbgString(&inner_));
}

inline AttributeTypeVec AttributeTypeVec::create() {
    return AttributeTypeVec(AzAttributeTypeVec_create());
}

inline AttributeTypeVec AttributeTypeVec::with_capacity(size_t cap) {
    return AttributeTypeVec(AzAttributeTypeVec_withCapacity(cap));
}

inline size_t AttributeTypeVec::len() const {
    return AzAttributeTypeVec_len(&inner_);
}

inline size_t AttributeTypeVec::capacity() const {
    return AzAttributeTypeVec_capacity(&inner_);
}

inline bool AttributeTypeVec::is_empty() const {
    return AzAttributeTypeVec_isEmpty(&inner_);
}

inline OptionAttributeType AttributeTypeVec::get(size_t index) const {
    return OptionAttributeType(AzAttributeTypeVec_get(&inner_, index));
}

inline AttributeTypeVec AttributeTypeVec::from_item(AzAttributeType item) {
    return AttributeTypeVec(AzAttributeTypeVec_fromItem(item));
}

inline AttributeTypeVec AttributeTypeVec::copy_from_ptr(const AzAttributeType* ptr, size_t len) {
    return AttributeTypeVec(AzAttributeTypeVec_copyFromPtr(ptr, len));
}

inline OptionAttributeType AttributeTypeVec::c_get(size_t index) const {
    return OptionAttributeType(AzAttributeTypeVec_cGet(&inner_, index));
}

inline AttributeTypeVecSlice AttributeTypeVec::as_c_slice() const {
    return AttributeTypeVecSlice(AzAttributeTypeVec_asCSlice(&inner_));
}

inline AttributeTypeVecSlice AttributeTypeVec::as_c_slice_range(size_t start, size_t end) const {
    return AttributeTypeVecSlice(AzAttributeTypeVec_asCSliceRange(&inner_, start, end));
}

inline void AttributeTypeVec::delete_() {
    AzAttributeTypeVec_delete(&inner_);
}

inline AttributeTypeVec AttributeTypeVec::clone() const {
    return AttributeTypeVec(AzAttributeTypeVec_clone(&inner_));
}

inline bool AttributeTypeVec::partialEq(const AttributeTypeVec& b) const {
    return AzAttributeTypeVec_partialEq(&inner_, b.ptr());
}

inline uint64_t AttributeTypeVec::hash() const {
    return AzAttributeTypeVec_hash(&inner_);
}

inline uint8_t AttributeTypeVec::partialCmp(const AttributeTypeVec& b) const {
    return AzAttributeTypeVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t AttributeTypeVec::cmp(const AttributeTypeVec& b) const {
    return AzAttributeTypeVec_cmp(&inner_, b.ptr());
}

inline String AttributeTypeVec::toDbgString() const {
    return String(AzAttributeTypeVec_toDbgString(&inner_));
}

inline CoreCallbackDataVec CoreCallbackDataVec::create() {
    return CoreCallbackDataVec(AzCoreCallbackDataVec_create());
}

inline CoreCallbackDataVec CoreCallbackDataVec::with_capacity(size_t cap) {
    return CoreCallbackDataVec(AzCoreCallbackDataVec_withCapacity(cap));
}

inline size_t CoreCallbackDataVec::len() const {
    return AzCoreCallbackDataVec_len(&inner_);
}

inline size_t CoreCallbackDataVec::capacity() const {
    return AzCoreCallbackDataVec_capacity(&inner_);
}

inline bool CoreCallbackDataVec::is_empty() const {
    return AzCoreCallbackDataVec_isEmpty(&inner_);
}

inline OptionCoreCallbackData CoreCallbackDataVec::get(size_t index) const {
    return OptionCoreCallbackData(AzCoreCallbackDataVec_get(&inner_, index));
}

inline CoreCallbackDataVec CoreCallbackDataVec::from_item(CoreCallbackData item) {
    return CoreCallbackDataVec(AzCoreCallbackDataVec_fromItem(item.release()));
}

inline CoreCallbackDataVec CoreCallbackDataVec::copy_from_ptr(const CoreCallbackData& ptr, size_t len) {
    return CoreCallbackDataVec(AzCoreCallbackDataVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionCoreCallbackData CoreCallbackDataVec::c_get(size_t index) const {
    return OptionCoreCallbackData(AzCoreCallbackDataVec_cGet(&inner_, index));
}

inline CoreCallbackDataVecSlice CoreCallbackDataVec::as_c_slice() const {
    return CoreCallbackDataVecSlice(AzCoreCallbackDataVec_asCSlice(&inner_));
}

inline CoreCallbackDataVecSlice CoreCallbackDataVec::as_c_slice_range(size_t start, size_t end) const {
    return CoreCallbackDataVecSlice(AzCoreCallbackDataVec_asCSliceRange(&inner_, start, end));
}

inline void CoreCallbackDataVec::delete_() {
    AzCoreCallbackDataVec_delete(&inner_);
}

inline CoreCallbackDataVec CoreCallbackDataVec::clone() const {
    return CoreCallbackDataVec(AzCoreCallbackDataVec_clone(&inner_));
}

inline bool CoreCallbackDataVec::partialEq(const CoreCallbackDataVec& b) const {
    return AzCoreCallbackDataVec_partialEq(&inner_, b.ptr());
}

inline uint64_t CoreCallbackDataVec::hash() const {
    return AzCoreCallbackDataVec_hash(&inner_);
}

inline uint8_t CoreCallbackDataVec::partialCmp(const CoreCallbackDataVec& b) const {
    return AzCoreCallbackDataVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t CoreCallbackDataVec::cmp(const CoreCallbackDataVec& b) const {
    return AzCoreCallbackDataVec_cmp(&inner_, b.ptr());
}

inline String CoreCallbackDataVec::toDbgString() const {
    return String(AzCoreCallbackDataVec_toDbgString(&inner_));
}

inline AccessibilityActionVec AccessibilityActionVec::create() {
    return AccessibilityActionVec(AzAccessibilityActionVec_create());
}

inline AccessibilityActionVec AccessibilityActionVec::with_capacity(size_t cap) {
    return AccessibilityActionVec(AzAccessibilityActionVec_withCapacity(cap));
}

inline size_t AccessibilityActionVec::len() const {
    return AzAccessibilityActionVec_len(&inner_);
}

inline size_t AccessibilityActionVec::capacity() const {
    return AzAccessibilityActionVec_capacity(&inner_);
}

inline bool AccessibilityActionVec::is_empty() const {
    return AzAccessibilityActionVec_isEmpty(&inner_);
}

inline OptionAccessibilityAction AccessibilityActionVec::get(size_t index) const {
    return OptionAccessibilityAction(AzAccessibilityActionVec_get(&inner_, index));
}

inline AccessibilityActionVec AccessibilityActionVec::from_item(AzAccessibilityAction item) {
    return AccessibilityActionVec(AzAccessibilityActionVec_fromItem(item));
}

inline AccessibilityActionVec AccessibilityActionVec::copy_from_ptr(const AzAccessibilityAction* ptr, size_t len) {
    return AccessibilityActionVec(AzAccessibilityActionVec_copyFromPtr(ptr, len));
}

inline OptionAccessibilityAction AccessibilityActionVec::c_get(size_t index) const {
    return OptionAccessibilityAction(AzAccessibilityActionVec_cGet(&inner_, index));
}

inline AccessibilityActionVecSlice AccessibilityActionVec::as_c_slice() const {
    return AccessibilityActionVecSlice(AzAccessibilityActionVec_asCSlice(&inner_));
}

inline AccessibilityActionVecSlice AccessibilityActionVec::as_c_slice_range(size_t start, size_t end) const {
    return AccessibilityActionVecSlice(AzAccessibilityActionVec_asCSliceRange(&inner_, start, end));
}

inline void AccessibilityActionVec::delete_() {
    AzAccessibilityActionVec_delete(&inner_);
}

inline AccessibilityActionVec AccessibilityActionVec::clone() const {
    return AccessibilityActionVec(AzAccessibilityActionVec_clone(&inner_));
}

inline bool AccessibilityActionVec::partialEq(const AccessibilityActionVec& b) const {
    return AzAccessibilityActionVec_partialEq(&inner_, b.ptr());
}

inline uint64_t AccessibilityActionVec::hash() const {
    return AzAccessibilityActionVec_hash(&inner_);
}

inline uint8_t AccessibilityActionVec::partialCmp(const AccessibilityActionVec& b) const {
    return AzAccessibilityActionVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t AccessibilityActionVec::cmp(const AccessibilityActionVec& b) const {
    return AzAccessibilityActionVec_cmp(&inner_, b.ptr());
}

inline String AccessibilityActionVec::toDbgString() const {
    return String(AzAccessibilityActionVec_toDbgString(&inner_));
}

inline GridTrackSizingVec GridTrackSizingVec::create() {
    return GridTrackSizingVec(AzGridTrackSizingVec_create());
}

inline GridTrackSizingVec GridTrackSizingVec::with_capacity(size_t cap) {
    return GridTrackSizingVec(AzGridTrackSizingVec_withCapacity(cap));
}

inline size_t GridTrackSizingVec::len() const {
    return AzGridTrackSizingVec_len(&inner_);
}

inline size_t GridTrackSizingVec::capacity() const {
    return AzGridTrackSizingVec_capacity(&inner_);
}

inline bool GridTrackSizingVec::is_empty() const {
    return AzGridTrackSizingVec_isEmpty(&inner_);
}

inline OptionGridTrackSizing GridTrackSizingVec::get(size_t index) const {
    return OptionGridTrackSizing(AzGridTrackSizingVec_get(&inner_, index));
}

inline GridTrackSizingVec GridTrackSizingVec::from_item(AzGridTrackSizing item) {
    return GridTrackSizingVec(AzGridTrackSizingVec_fromItem(item));
}

inline GridTrackSizingVec GridTrackSizingVec::copy_from_ptr(const AzGridTrackSizing* ptr, size_t len) {
    return GridTrackSizingVec(AzGridTrackSizingVec_copyFromPtr(ptr, len));
}

inline OptionGridTrackSizing GridTrackSizingVec::c_get(size_t index) const {
    return OptionGridTrackSizing(AzGridTrackSizingVec_cGet(&inner_, index));
}

inline GridTrackSizingVecSlice GridTrackSizingVec::as_c_slice() const {
    return GridTrackSizingVecSlice(AzGridTrackSizingVec_asCSlice(&inner_));
}

inline GridTrackSizingVecSlice GridTrackSizingVec::as_c_slice_range(size_t start, size_t end) const {
    return GridTrackSizingVecSlice(AzGridTrackSizingVec_asCSliceRange(&inner_, start, end));
}

inline void GridTrackSizingVec::delete_() {
    AzGridTrackSizingVec_delete(&inner_);
}

inline GridTrackSizingVec GridTrackSizingVec::clone() const {
    return GridTrackSizingVec(AzGridTrackSizingVec_clone(&inner_));
}

inline bool GridTrackSizingVec::partialEq(const GridTrackSizingVec& b) const {
    return AzGridTrackSizingVec_partialEq(&inner_, b.ptr());
}

inline uint64_t GridTrackSizingVec::hash() const {
    return AzGridTrackSizingVec_hash(&inner_);
}

inline uint8_t GridTrackSizingVec::partialCmp(const GridTrackSizingVec& b) const {
    return AzGridTrackSizingVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t GridTrackSizingVec::cmp(const GridTrackSizingVec& b) const {
    return AzGridTrackSizingVec_cmp(&inner_, b.ptr());
}

inline String GridTrackSizingVec::toDbgString() const {
    return String(AzGridTrackSizingVec_toDbgString(&inner_));
}

inline VertexAttributeVec VertexAttributeVec::create() {
    return VertexAttributeVec(AzVertexAttributeVec_create());
}

inline VertexAttributeVec VertexAttributeVec::with_capacity(size_t cap) {
    return VertexAttributeVec(AzVertexAttributeVec_withCapacity(cap));
}

inline size_t VertexAttributeVec::len() const {
    return AzVertexAttributeVec_len(&inner_);
}

inline size_t VertexAttributeVec::capacity() const {
    return AzVertexAttributeVec_capacity(&inner_);
}

inline bool VertexAttributeVec::is_empty() const {
    return AzVertexAttributeVec_isEmpty(&inner_);
}

inline OptionVertexAttribute VertexAttributeVec::get(size_t index) const {
    return OptionVertexAttribute(AzVertexAttributeVec_get(&inner_, index));
}

inline VertexAttributeVec VertexAttributeVec::from_item(VertexAttribute item) {
    return VertexAttributeVec(AzVertexAttributeVec_fromItem(item.release()));
}

inline VertexAttributeVec VertexAttributeVec::copy_from_ptr(const VertexAttribute& ptr, size_t len) {
    return VertexAttributeVec(AzVertexAttributeVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionVertexAttribute VertexAttributeVec::c_get(size_t index) const {
    return OptionVertexAttribute(AzVertexAttributeVec_cGet(&inner_, index));
}

inline VertexAttributeVecSlice VertexAttributeVec::as_c_slice() const {
    return VertexAttributeVecSlice(AzVertexAttributeVec_asCSlice(&inner_));
}

inline VertexAttributeVecSlice VertexAttributeVec::as_c_slice_range(size_t start, size_t end) const {
    return VertexAttributeVecSlice(AzVertexAttributeVec_asCSliceRange(&inner_, start, end));
}

inline void VertexAttributeVec::delete_() {
    AzVertexAttributeVec_delete(&inner_);
}

inline VertexAttributeVec VertexAttributeVec::clone() const {
    return VertexAttributeVec(AzVertexAttributeVec_clone(&inner_));
}

inline bool VertexAttributeVec::partialEq(const VertexAttributeVec& b) const {
    return AzVertexAttributeVec_partialEq(&inner_, b.ptr());
}

inline uint64_t VertexAttributeVec::hash() const {
    return AzVertexAttributeVec_hash(&inner_);
}

inline uint8_t VertexAttributeVec::partialCmp(const VertexAttributeVec& b) const {
    return AzVertexAttributeVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t VertexAttributeVec::cmp(const VertexAttributeVec& b) const {
    return AzVertexAttributeVec_cmp(&inner_, b.ptr());
}

inline String VertexAttributeVec::toDbgString() const {
    return String(AzVertexAttributeVec_toDbgString(&inner_));
}

inline DebugMessageVec DebugMessageVec::create() {
    return DebugMessageVec(AzDebugMessageVec_create());
}

inline DebugMessageVec DebugMessageVec::with_capacity(size_t cap) {
    return DebugMessageVec(AzDebugMessageVec_withCapacity(cap));
}

inline size_t DebugMessageVec::len() const {
    return AzDebugMessageVec_len(&inner_);
}

inline size_t DebugMessageVec::capacity() const {
    return AzDebugMessageVec_capacity(&inner_);
}

inline bool DebugMessageVec::is_empty() const {
    return AzDebugMessageVec_isEmpty(&inner_);
}

inline OptionDebugMessage DebugMessageVec::get(size_t index) const {
    return OptionDebugMessage(AzDebugMessageVec_get(&inner_, index));
}

inline DebugMessageVec DebugMessageVec::from_item(DebugMessage item) {
    return DebugMessageVec(AzDebugMessageVec_fromItem(item.release()));
}

inline DebugMessageVec DebugMessageVec::copy_from_ptr(const DebugMessage& ptr, size_t len) {
    return DebugMessageVec(AzDebugMessageVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionDebugMessage DebugMessageVec::c_get(size_t index) const {
    return OptionDebugMessage(AzDebugMessageVec_cGet(&inner_, index));
}

inline DebugMessageVecSlice DebugMessageVec::as_c_slice() const {
    return DebugMessageVecSlice(AzDebugMessageVec_asCSlice(&inner_));
}

inline DebugMessageVecSlice DebugMessageVec::as_c_slice_range(size_t start, size_t end) const {
    return DebugMessageVecSlice(AzDebugMessageVec_asCSliceRange(&inner_, start, end));
}

inline void DebugMessageVec::delete_() {
    AzDebugMessageVec_delete(&inner_);
}

inline DebugMessageVec DebugMessageVec::clone() const {
    return DebugMessageVec(AzDebugMessageVec_clone(&inner_));
}

inline bool DebugMessageVec::partialEq(const DebugMessageVec& b) const {
    return AzDebugMessageVec_partialEq(&inner_, b.ptr());
}

inline uint64_t DebugMessageVec::hash() const {
    return AzDebugMessageVec_hash(&inner_);
}

inline uint8_t DebugMessageVec::partialCmp(const DebugMessageVec& b) const {
    return AzDebugMessageVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t DebugMessageVec::cmp(const DebugMessageVec& b) const {
    return AzDebugMessageVec_cmp(&inner_, b.ptr());
}

inline String DebugMessageVec::toDbgString() const {
    return String(AzDebugMessageVec_toDbgString(&inner_));
}

inline ShapePointVec ShapePointVec::create() {
    return ShapePointVec(AzShapePointVec_create());
}

inline ShapePointVec ShapePointVec::with_capacity(size_t cap) {
    return ShapePointVec(AzShapePointVec_withCapacity(cap));
}

inline size_t ShapePointVec::len() const {
    return AzShapePointVec_len(&inner_);
}

inline size_t ShapePointVec::capacity() const {
    return AzShapePointVec_capacity(&inner_);
}

inline bool ShapePointVec::is_empty() const {
    return AzShapePointVec_isEmpty(&inner_);
}

inline OptionShapePoint ShapePointVec::get(size_t index) const {
    return OptionShapePoint(AzShapePointVec_get(&inner_, index));
}

inline ShapePointVec ShapePointVec::from_item(ShapePoint item) {
    return ShapePointVec(AzShapePointVec_fromItem(item.release()));
}

inline ShapePointVec ShapePointVec::copy_from_ptr(const ShapePoint& ptr, size_t len) {
    return ShapePointVec(AzShapePointVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionShapePoint ShapePointVec::c_get(size_t index) const {
    return OptionShapePoint(AzShapePointVec_cGet(&inner_, index));
}

inline ShapePointVecSlice ShapePointVec::as_c_slice() const {
    return ShapePointVecSlice(AzShapePointVec_asCSlice(&inner_));
}

inline ShapePointVecSlice ShapePointVec::as_c_slice_range(size_t start, size_t end) const {
    return ShapePointVecSlice(AzShapePointVec_asCSliceRange(&inner_, start, end));
}

inline void ShapePointVec::delete_() {
    AzShapePointVec_delete(&inner_);
}

inline ShapePointVec ShapePointVec::clone() const {
    return ShapePointVec(AzShapePointVec_clone(&inner_));
}

inline bool ShapePointVec::partialEq(const ShapePointVec& b) const {
    return AzShapePointVec_partialEq(&inner_, b.ptr());
}

inline uint64_t ShapePointVec::hash() const {
    return AzShapePointVec_hash(&inner_);
}

inline uint8_t ShapePointVec::partialCmp(const ShapePointVec& b) const {
    return AzShapePointVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t ShapePointVec::cmp(const ShapePointVec& b) const {
    return AzShapePointVec_cmp(&inner_, b.ptr());
}

inline String ShapePointVec::toDbgString() const {
    return String(AzShapePointVec_toDbgString(&inner_));
}

inline MonitorVec MonitorVec::create() {
    return MonitorVec(AzMonitorVec_create());
}

inline MonitorVec MonitorVec::with_capacity(size_t cap) {
    return MonitorVec(AzMonitorVec_withCapacity(cap));
}

inline size_t MonitorVec::len() const {
    return AzMonitorVec_len(&inner_);
}

inline size_t MonitorVec::capacity() const {
    return AzMonitorVec_capacity(&inner_);
}

inline bool MonitorVec::is_empty() const {
    return AzMonitorVec_isEmpty(&inner_);
}

inline OptionMonitor MonitorVec::get(size_t index) const {
    return OptionMonitor(AzMonitorVec_get(&inner_, index));
}

inline MonitorVec MonitorVec::from_item(Monitor item) {
    return MonitorVec(AzMonitorVec_fromItem(item.release()));
}

inline MonitorVec MonitorVec::copy_from_ptr(const Monitor& ptr, size_t len) {
    return MonitorVec(AzMonitorVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionMonitor MonitorVec::c_get(size_t index) const {
    return OptionMonitor(AzMonitorVec_cGet(&inner_, index));
}

inline MonitorVecSlice MonitorVec::as_c_slice() const {
    return MonitorVecSlice(AzMonitorVec_asCSlice(&inner_));
}

inline MonitorVecSlice MonitorVec::as_c_slice_range(size_t start, size_t end) const {
    return MonitorVecSlice(AzMonitorVec_asCSliceRange(&inner_, start, end));
}

inline void MonitorVec::delete_() {
    AzMonitorVec_delete(&inner_);
}

inline MonitorVec MonitorVec::clone() const {
    return MonitorVec(AzMonitorVec_clone(&inner_));
}

inline bool MonitorVec::partialEq(const MonitorVec& b) const {
    return AzMonitorVec_partialEq(&inner_, b.ptr());
}

inline uint8_t MonitorVec::partialCmp(const MonitorVec& b) const {
    return AzMonitorVec_partialCmp(&inner_, b.ptr());
}

inline String MonitorVec::toDbgString() const {
    return String(AzMonitorVec_toDbgString(&inner_));
}

inline VideoModeVec VideoModeVec::create() {
    return VideoModeVec(AzVideoModeVec_create());
}

inline VideoModeVec VideoModeVec::with_capacity(size_t cap) {
    return VideoModeVec(AzVideoModeVec_withCapacity(cap));
}

inline size_t VideoModeVec::len() const {
    return AzVideoModeVec_len(&inner_);
}

inline size_t VideoModeVec::capacity() const {
    return AzVideoModeVec_capacity(&inner_);
}

inline bool VideoModeVec::is_empty() const {
    return AzVideoModeVec_isEmpty(&inner_);
}

inline OptionVideoMode VideoModeVec::get(size_t index) const {
    return OptionVideoMode(AzVideoModeVec_get(&inner_, index));
}

inline VideoModeVec VideoModeVec::from_item(VideoMode item) {
    return VideoModeVec(AzVideoModeVec_fromItem(item.release()));
}

inline VideoModeVec VideoModeVec::copy_from_ptr(const VideoMode& ptr, size_t len) {
    return VideoModeVec(AzVideoModeVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionVideoMode VideoModeVec::c_get(size_t index) const {
    return OptionVideoMode(AzVideoModeVec_cGet(&inner_, index));
}

inline VideoModeVecSlice VideoModeVec::as_c_slice() const {
    return VideoModeVecSlice(AzVideoModeVec_asCSlice(&inner_));
}

inline VideoModeVecSlice VideoModeVec::as_c_slice_range(size_t start, size_t end) const {
    return VideoModeVecSlice(AzVideoModeVec_asCSliceRange(&inner_, start, end));
}

inline void VideoModeVec::delete_() {
    AzVideoModeVec_delete(&inner_);
}

inline VideoModeVec VideoModeVec::clone() const {
    return VideoModeVec(AzVideoModeVec_clone(&inner_));
}

inline bool VideoModeVec::partialEq(const VideoModeVec& b) const {
    return AzVideoModeVec_partialEq(&inner_, b.ptr());
}

inline uint8_t VideoModeVec::partialCmp(const VideoModeVec& b) const {
    return AzVideoModeVec_partialCmp(&inner_, b.ptr());
}

inline String VideoModeVec::toDbgString() const {
    return String(AzVideoModeVec_toDbgString(&inner_));
}

inline XWindowTypeVec XWindowTypeVec::create() {
    return XWindowTypeVec(AzXWindowTypeVec_create());
}

inline XWindowTypeVec XWindowTypeVec::with_capacity(size_t cap) {
    return XWindowTypeVec(AzXWindowTypeVec_withCapacity(cap));
}

inline size_t XWindowTypeVec::len() const {
    return AzXWindowTypeVec_len(&inner_);
}

inline size_t XWindowTypeVec::capacity() const {
    return AzXWindowTypeVec_capacity(&inner_);
}

inline bool XWindowTypeVec::is_empty() const {
    return AzXWindowTypeVec_isEmpty(&inner_);
}

inline OptionXWindowType XWindowTypeVec::get(size_t index) const {
    return OptionXWindowType(AzXWindowTypeVec_get(&inner_, index));
}

inline XWindowTypeVec XWindowTypeVec::from_item(AzXWindowType item) {
    return XWindowTypeVec(AzXWindowTypeVec_fromItem(item));
}

inline XWindowTypeVec XWindowTypeVec::copy_from_ptr(const AzXWindowType* ptr, size_t len) {
    return XWindowTypeVec(AzXWindowTypeVec_copyFromPtr(ptr, len));
}

inline OptionXWindowType XWindowTypeVec::c_get(size_t index) const {
    return OptionXWindowType(AzXWindowTypeVec_cGet(&inner_, index));
}

inline XWindowTypeVecSlice XWindowTypeVec::as_c_slice() const {
    return XWindowTypeVecSlice(AzXWindowTypeVec_asCSlice(&inner_));
}

inline XWindowTypeVecSlice XWindowTypeVec::as_c_slice_range(size_t start, size_t end) const {
    return XWindowTypeVecSlice(AzXWindowTypeVec_asCSliceRange(&inner_, start, end));
}

inline void XWindowTypeVec::delete_() {
    AzXWindowTypeVec_delete(&inner_);
}

inline XWindowTypeVec XWindowTypeVec::clone() const {
    return XWindowTypeVec(AzXWindowTypeVec_clone(&inner_));
}

inline bool XWindowTypeVec::partialEq(const XWindowTypeVec& b) const {
    return AzXWindowTypeVec_partialEq(&inner_, b.ptr());
}

inline uint64_t XWindowTypeVec::hash() const {
    return AzXWindowTypeVec_hash(&inner_);
}

inline uint8_t XWindowTypeVec::partialCmp(const XWindowTypeVec& b) const {
    return AzXWindowTypeVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t XWindowTypeVec::cmp(const XWindowTypeVec& b) const {
    return AzXWindowTypeVec_cmp(&inner_, b.ptr());
}

inline String XWindowTypeVec::toDbgString() const {
    return String(AzXWindowTypeVec_toDbgString(&inner_));
}

inline ScanCodeVec ScanCodeVec::create() {
    return ScanCodeVec(AzScanCodeVec_create());
}

inline ScanCodeVec ScanCodeVec::with_capacity(size_t cap) {
    return ScanCodeVec(AzScanCodeVec_withCapacity(cap));
}

inline size_t ScanCodeVec::len() const {
    return AzScanCodeVec_len(&inner_);
}

inline size_t ScanCodeVec::capacity() const {
    return AzScanCodeVec_capacity(&inner_);
}

inline bool ScanCodeVec::is_empty() const {
    return AzScanCodeVec_isEmpty(&inner_);
}

inline OptionU32 ScanCodeVec::get(size_t index) const {
    return OptionU32(AzScanCodeVec_get(&inner_, index));
}

inline ScanCodeVec ScanCodeVec::from_item(AzScanCode item) {
    return ScanCodeVec(AzScanCodeVec_fromItem(item));
}

inline ScanCodeVec ScanCodeVec::copy_from_ptr(const AzScanCode* ptr, size_t len) {
    return ScanCodeVec(AzScanCodeVec_copyFromPtr(ptr, len));
}

inline OptionU32 ScanCodeVec::c_get(size_t index) const {
    return OptionU32(AzScanCodeVec_cGet(&inner_, index));
}

inline ScanCodeVecSlice ScanCodeVec::as_c_slice() const {
    return ScanCodeVecSlice(AzScanCodeVec_asCSlice(&inner_));
}

inline ScanCodeVecSlice ScanCodeVec::as_c_slice_range(size_t start, size_t end) const {
    return ScanCodeVecSlice(AzScanCodeVec_asCSliceRange(&inner_, start, end));
}

inline void ScanCodeVec::delete_() {
    AzScanCodeVec_delete(&inner_);
}

inline ScanCodeVec ScanCodeVec::clone() const {
    return ScanCodeVec(AzScanCodeVec_clone(&inner_));
}

inline bool ScanCodeVec::partialEq(const ScanCodeVec& b) const {
    return AzScanCodeVec_partialEq(&inner_, b.ptr());
}

inline uint64_t ScanCodeVec::hash() const {
    return AzScanCodeVec_hash(&inner_);
}

inline uint8_t ScanCodeVec::partialCmp(const ScanCodeVec& b) const {
    return AzScanCodeVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t ScanCodeVec::cmp(const ScanCodeVec& b) const {
    return AzScanCodeVec_cmp(&inner_, b.ptr());
}

inline String ScanCodeVec::toDbgString() const {
    return String(AzScanCodeVec_toDbgString(&inner_));
}

inline ContentGroupVec ContentGroupVec::create() {
    return ContentGroupVec(AzContentGroupVec_create());
}

inline ContentGroupVec ContentGroupVec::with_capacity(size_t cap) {
    return ContentGroupVec(AzContentGroupVec_withCapacity(cap));
}

inline size_t ContentGroupVec::len() const {
    return AzContentGroupVec_len(&inner_);
}

inline size_t ContentGroupVec::capacity() const {
    return AzContentGroupVec_capacity(&inner_);
}

inline bool ContentGroupVec::is_empty() const {
    return AzContentGroupVec_isEmpty(&inner_);
}

inline OptionContentGroup ContentGroupVec::get(size_t index) const {
    return OptionContentGroup(AzContentGroupVec_get(&inner_, index));
}

inline ContentGroupVec ContentGroupVec::from_item(ContentGroup item) {
    return ContentGroupVec(AzContentGroupVec_fromItem(item.release()));
}

inline ContentGroupVec ContentGroupVec::copy_from_ptr(const ContentGroup& ptr, size_t len) {
    return ContentGroupVec(AzContentGroupVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionContentGroup ContentGroupVec::c_get(size_t index) const {
    return OptionContentGroup(AzContentGroupVec_cGet(&inner_, index));
}

inline ContentGroupVecSlice ContentGroupVec::as_c_slice() const {
    return ContentGroupVecSlice(AzContentGroupVec_asCSlice(&inner_));
}

inline ContentGroupVecSlice ContentGroupVec::as_c_slice_range(size_t start, size_t end) const {
    return ContentGroupVecSlice(AzContentGroupVec_asCSliceRange(&inner_, start, end));
}

inline void ContentGroupVec::delete_() {
    AzContentGroupVec_delete(&inner_);
}

inline ContentGroupVec ContentGroupVec::clone() const {
    return ContentGroupVec(AzContentGroupVec_clone(&inner_));
}

inline bool ContentGroupVec::partialEq(const ContentGroupVec& b) const {
    return AzContentGroupVec_partialEq(&inner_, b.ptr());
}

inline uint8_t ContentGroupVec::partialCmp(const ContentGroupVec& b) const {
    return AzContentGroupVec_partialCmp(&inner_, b.ptr());
}

inline String ContentGroupVec::toDbgString() const {
    return String(AzContentGroupVec_toDbgString(&inner_));
}

inline StyledNodeVec StyledNodeVec::create() {
    return StyledNodeVec(AzStyledNodeVec_create());
}

inline StyledNodeVec StyledNodeVec::with_capacity(size_t cap) {
    return StyledNodeVec(AzStyledNodeVec_withCapacity(cap));
}

inline size_t StyledNodeVec::len() const {
    return AzStyledNodeVec_len(&inner_);
}

inline size_t StyledNodeVec::capacity() const {
    return AzStyledNodeVec_capacity(&inner_);
}

inline bool StyledNodeVec::is_empty() const {
    return AzStyledNodeVec_isEmpty(&inner_);
}

inline OptionStyledNode StyledNodeVec::get(size_t index) const {
    return OptionStyledNode(AzStyledNodeVec_get(&inner_, index));
}

inline StyledNodeVec StyledNodeVec::from_item(StyledNode item) {
    return StyledNodeVec(AzStyledNodeVec_fromItem(item.release()));
}

inline StyledNodeVec StyledNodeVec::copy_from_ptr(const StyledNode& ptr, size_t len) {
    return StyledNodeVec(AzStyledNodeVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionStyledNode StyledNodeVec::c_get(size_t index) const {
    return OptionStyledNode(AzStyledNodeVec_cGet(&inner_, index));
}

inline StyledNodeVecSlice StyledNodeVec::as_c_slice() const {
    return StyledNodeVecSlice(AzStyledNodeVec_asCSlice(&inner_));
}

inline StyledNodeVecSlice StyledNodeVec::as_c_slice_range(size_t start, size_t end) const {
    return StyledNodeVecSlice(AzStyledNodeVec_asCSliceRange(&inner_, start, end));
}

inline void StyledNodeVec::delete_() {
    AzStyledNodeVec_delete(&inner_);
}

inline StyledNodeVec StyledNodeVec::clone() const {
    return StyledNodeVec(AzStyledNodeVec_clone(&inner_));
}

inline bool StyledNodeVec::partialEq(const StyledNodeVec& b) const {
    return AzStyledNodeVec_partialEq(&inner_, b.ptr());
}

inline uint8_t StyledNodeVec::partialCmp(const StyledNodeVec& b) const {
    return AzStyledNodeVec_partialCmp(&inner_, b.ptr());
}

inline String StyledNodeVec::toDbgString() const {
    return String(AzStyledNodeVec_toDbgString(&inner_));
}

inline DomIdVec DomIdVec::create() {
    return DomIdVec(AzDomIdVec_create());
}

inline DomIdVec DomIdVec::with_capacity(size_t cap) {
    return DomIdVec(AzDomIdVec_withCapacity(cap));
}

inline size_t DomIdVec::len() const {
    return AzDomIdVec_len(&inner_);
}

inline size_t DomIdVec::capacity() const {
    return AzDomIdVec_capacity(&inner_);
}

inline bool DomIdVec::is_empty() const {
    return AzDomIdVec_isEmpty(&inner_);
}

inline OptionDomId DomIdVec::get(size_t index) const {
    return OptionDomId(AzDomIdVec_get(&inner_, index));
}

inline DomIdVec DomIdVec::from_item(DomId item) {
    return DomIdVec(AzDomIdVec_fromItem(item.release()));
}

inline DomIdVec DomIdVec::copy_from_ptr(const DomId& ptr, size_t len) {
    return DomIdVec(AzDomIdVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionDomId DomIdVec::c_get(size_t index) const {
    return OptionDomId(AzDomIdVec_cGet(&inner_, index));
}

inline DomIdVecSlice DomIdVec::as_c_slice() const {
    return DomIdVecSlice(AzDomIdVec_asCSlice(&inner_));
}

inline DomIdVecSlice DomIdVec::as_c_slice_range(size_t start, size_t end) const {
    return DomIdVecSlice(AzDomIdVec_asCSliceRange(&inner_, start, end));
}

inline void DomIdVec::delete_() {
    AzDomIdVec_delete(&inner_);
}

inline DomIdVec DomIdVec::clone() const {
    return DomIdVec(AzDomIdVec_clone(&inner_));
}

inline bool DomIdVec::partialEq(const DomIdVec& b) const {
    return AzDomIdVec_partialEq(&inner_, b.ptr());
}

inline uint8_t DomIdVec::partialCmp(const DomIdVec& b) const {
    return AzDomIdVec_partialCmp(&inner_, b.ptr());
}

inline String DomIdVec::toDbgString() const {
    return String(AzDomIdVec_toDbgString(&inner_));
}

inline TimerIdVec TimerIdVec::create() {
    return TimerIdVec(AzTimerIdVec_create());
}

inline TimerIdVec TimerIdVec::with_capacity(size_t cap) {
    return TimerIdVec(AzTimerIdVec_withCapacity(cap));
}

inline size_t TimerIdVec::len() const {
    return AzTimerIdVec_len(&inner_);
}

inline size_t TimerIdVec::capacity() const {
    return AzTimerIdVec_capacity(&inner_);
}

inline bool TimerIdVec::is_empty() const {
    return AzTimerIdVec_isEmpty(&inner_);
}

inline OptionTimerId TimerIdVec::get(size_t index) const {
    return OptionTimerId(AzTimerIdVec_get(&inner_, index));
}

inline TimerIdVec TimerIdVec::from_item(TimerId item) {
    return TimerIdVec(AzTimerIdVec_fromItem(item.release()));
}

inline TimerIdVec TimerIdVec::copy_from_ptr(const TimerId& ptr, size_t len) {
    return TimerIdVec(AzTimerIdVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionTimerId TimerIdVec::c_get(size_t index) const {
    return OptionTimerId(AzTimerIdVec_cGet(&inner_, index));
}

inline TimerIdVecSlice TimerIdVec::as_c_slice() const {
    return TimerIdVecSlice(AzTimerIdVec_asCSlice(&inner_));
}

inline TimerIdVecSlice TimerIdVec::as_c_slice_range(size_t start, size_t end) const {
    return TimerIdVecSlice(AzTimerIdVec_asCSliceRange(&inner_, start, end));
}

inline void TimerIdVec::delete_() {
    AzTimerIdVec_delete(&inner_);
}

inline TimerIdVec TimerIdVec::clone() const {
    return TimerIdVec(AzTimerIdVec_clone(&inner_));
}

inline bool TimerIdVec::partialEq(const TimerIdVec& b) const {
    return AzTimerIdVec_partialEq(&inner_, b.ptr());
}

inline uint8_t TimerIdVec::partialCmp(const TimerIdVec& b) const {
    return AzTimerIdVec_partialCmp(&inner_, b.ptr());
}

inline String TimerIdVec::toDbgString() const {
    return String(AzTimerIdVec_toDbgString(&inner_));
}

inline SelectionRangeVec SelectionRangeVec::create() {
    return SelectionRangeVec(AzSelectionRangeVec_create());
}

inline SelectionRangeVec SelectionRangeVec::with_capacity(size_t cap) {
    return SelectionRangeVec(AzSelectionRangeVec_withCapacity(cap));
}

inline size_t SelectionRangeVec::len() const {
    return AzSelectionRangeVec_len(&inner_);
}

inline size_t SelectionRangeVec::capacity() const {
    return AzSelectionRangeVec_capacity(&inner_);
}

inline bool SelectionRangeVec::is_empty() const {
    return AzSelectionRangeVec_isEmpty(&inner_);
}

inline OptionSelectionRange SelectionRangeVec::get(size_t index) const {
    return OptionSelectionRange(AzSelectionRangeVec_get(&inner_, index));
}

inline SelectionRangeVec SelectionRangeVec::from_item(SelectionRange item) {
    return SelectionRangeVec(AzSelectionRangeVec_fromItem(item.release()));
}

inline SelectionRangeVec SelectionRangeVec::copy_from_ptr(const SelectionRange& ptr, size_t len) {
    return SelectionRangeVec(AzSelectionRangeVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionSelectionRange SelectionRangeVec::c_get(size_t index) const {
    return OptionSelectionRange(AzSelectionRangeVec_cGet(&inner_, index));
}

inline SelectionRangeVecSlice SelectionRangeVec::as_c_slice() const {
    return SelectionRangeVecSlice(AzSelectionRangeVec_asCSlice(&inner_));
}

inline SelectionRangeVecSlice SelectionRangeVec::as_c_slice_range(size_t start, size_t end) const {
    return SelectionRangeVecSlice(AzSelectionRangeVec_asCSliceRange(&inner_, start, end));
}

inline void SelectionRangeVec::delete_() {
    AzSelectionRangeVec_delete(&inner_);
}

inline SelectionRangeVec SelectionRangeVec::clone() const {
    return SelectionRangeVec(AzSelectionRangeVec_clone(&inner_));
}

inline bool SelectionRangeVec::partialEq(const SelectionRangeVec& b) const {
    return AzSelectionRangeVec_partialEq(&inner_, b.ptr());
}

inline uint8_t SelectionRangeVec::partialCmp(const SelectionRangeVec& b) const {
    return AzSelectionRangeVec_partialCmp(&inner_, b.ptr());
}

inline String SelectionRangeVec::toDbgString() const {
    return String(AzSelectionRangeVec_toDbgString(&inner_));
}

inline ThreadIdVec ThreadIdVec::create() {
    return ThreadIdVec(AzThreadIdVec_create());
}

inline ThreadIdVec ThreadIdVec::with_capacity(size_t cap) {
    return ThreadIdVec(AzThreadIdVec_withCapacity(cap));
}

inline size_t ThreadIdVec::len() const {
    return AzThreadIdVec_len(&inner_);
}

inline size_t ThreadIdVec::capacity() const {
    return AzThreadIdVec_capacity(&inner_);
}

inline bool ThreadIdVec::is_empty() const {
    return AzThreadIdVec_isEmpty(&inner_);
}

inline OptionThreadId ThreadIdVec::get(size_t index) const {
    return OptionThreadId(AzThreadIdVec_get(&inner_, index));
}

inline ThreadIdVec ThreadIdVec::from_item(ThreadId item) {
    return ThreadIdVec(AzThreadIdVec_fromItem(item.release()));
}

inline ThreadIdVec ThreadIdVec::copy_from_ptr(const ThreadId& ptr, size_t len) {
    return ThreadIdVec(AzThreadIdVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionThreadId ThreadIdVec::c_get(size_t index) const {
    return OptionThreadId(AzThreadIdVec_cGet(&inner_, index));
}

inline ThreadIdVecSlice ThreadIdVec::as_c_slice() const {
    return ThreadIdVecSlice(AzThreadIdVec_asCSlice(&inner_));
}

inline ThreadIdVecSlice ThreadIdVec::as_c_slice_range(size_t start, size_t end) const {
    return ThreadIdVecSlice(AzThreadIdVec_asCSliceRange(&inner_, start, end));
}

inline void ThreadIdVec::delete_() {
    AzThreadIdVec_delete(&inner_);
}

inline ThreadIdVec ThreadIdVec::clone() const {
    return ThreadIdVec(AzThreadIdVec_clone(&inner_));
}

inline bool ThreadIdVec::partialEq(const ThreadIdVec& b) const {
    return AzThreadIdVec_partialEq(&inner_, b.ptr());
}

inline uint8_t ThreadIdVec::partialCmp(const ThreadIdVec& b) const {
    return AzThreadIdVec_partialCmp(&inner_, b.ptr());
}

inline String ThreadIdVec::toDbgString() const {
    return String(AzThreadIdVec_toDbgString(&inner_));
}

inline StyledTextRunVec StyledTextRunVec::create() {
    return StyledTextRunVec(AzStyledTextRunVec_create());
}

inline StyledTextRunVec StyledTextRunVec::with_capacity(size_t cap) {
    return StyledTextRunVec(AzStyledTextRunVec_withCapacity(cap));
}

inline size_t StyledTextRunVec::len() const {
    return AzStyledTextRunVec_len(&inner_);
}

inline size_t StyledTextRunVec::capacity() const {
    return AzStyledTextRunVec_capacity(&inner_);
}

inline bool StyledTextRunVec::is_empty() const {
    return AzStyledTextRunVec_isEmpty(&inner_);
}

inline OptionStyledTextRun StyledTextRunVec::get(size_t index) const {
    return OptionStyledTextRun(AzStyledTextRunVec_get(&inner_, index));
}

inline StyledTextRunVec StyledTextRunVec::from_item(StyledTextRun item) {
    return StyledTextRunVec(AzStyledTextRunVec_fromItem(item.release()));
}

inline StyledTextRunVec StyledTextRunVec::copy_from_ptr(const StyledTextRun& ptr, size_t len) {
    return StyledTextRunVec(AzStyledTextRunVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionStyledTextRun StyledTextRunVec::c_get(size_t index) const {
    return OptionStyledTextRun(AzStyledTextRunVec_cGet(&inner_, index));
}

inline StyledTextRunVecSlice StyledTextRunVec::as_c_slice() const {
    return StyledTextRunVecSlice(AzStyledTextRunVec_asCSlice(&inner_));
}

inline StyledTextRunVecSlice StyledTextRunVec::as_c_slice_range(size_t start, size_t end) const {
    return StyledTextRunVecSlice(AzStyledTextRunVec_asCSliceRange(&inner_, start, end));
}

inline void StyledTextRunVec::delete_() {
    AzStyledTextRunVec_delete(&inner_);
}

inline StyledTextRunVec StyledTextRunVec::clone() const {
    return StyledTextRunVec(AzStyledTextRunVec_clone(&inner_));
}

inline bool StyledTextRunVec::partialEq(const StyledTextRunVec& b) const {
    return AzStyledTextRunVec_partialEq(&inner_, b.ptr());
}

inline String StyledTextRunVec::toDbgString() const {
    return String(AzStyledTextRunVec_toDbgString(&inner_));
}

inline SelectionVec SelectionVec::create() {
    return SelectionVec(AzSelectionVec_create());
}

inline SelectionVec SelectionVec::with_capacity(size_t cap) {
    return SelectionVec(AzSelectionVec_withCapacity(cap));
}

inline size_t SelectionVec::len() const {
    return AzSelectionVec_len(&inner_);
}

inline size_t SelectionVec::capacity() const {
    return AzSelectionVec_capacity(&inner_);
}

inline bool SelectionVec::is_empty() const {
    return AzSelectionVec_isEmpty(&inner_);
}

inline OptionSelection SelectionVec::get(size_t index) const {
    return OptionSelection(AzSelectionVec_get(&inner_, index));
}

inline SelectionVec SelectionVec::from_item(AzSelection item) {
    return SelectionVec(AzSelectionVec_fromItem(item));
}

inline SelectionVec SelectionVec::copy_from_ptr(const AzSelection* ptr, size_t len) {
    return SelectionVec(AzSelectionVec_copyFromPtr(ptr, len));
}

inline OptionSelection SelectionVec::c_get(size_t index) const {
    return OptionSelection(AzSelectionVec_cGet(&inner_, index));
}

inline SelectionVecSlice SelectionVec::as_c_slice() const {
    return SelectionVecSlice(AzSelectionVec_asCSlice(&inner_));
}

inline SelectionVecSlice SelectionVec::as_c_slice_range(size_t start, size_t end) const {
    return SelectionVecSlice(AzSelectionVec_asCSliceRange(&inner_, start, end));
}

inline void SelectionVec::delete_() {
    AzSelectionVec_delete(&inner_);
}

inline SelectionVec SelectionVec::clone() const {
    return SelectionVec(AzSelectionVec_clone(&inner_));
}

inline bool SelectionVec::partialEq(const SelectionVec& b) const {
    return AzSelectionVec_partialEq(&inner_, b.ptr());
}

inline uint8_t SelectionVec::partialCmp(const SelectionVec& b) const {
    return AzSelectionVec_partialCmp(&inner_, b.ptr());
}

inline String SelectionVec::toDbgString() const {
    return String(AzSelectionVec_toDbgString(&inner_));
}

inline HttpHeaderVec HttpHeaderVec::create() {
    return HttpHeaderVec(AzHttpHeaderVec_create());
}

inline HttpHeaderVec HttpHeaderVec::with_capacity(size_t cap) {
    return HttpHeaderVec(AzHttpHeaderVec_withCapacity(cap));
}

inline size_t HttpHeaderVec::len() const {
    return AzHttpHeaderVec_len(&inner_);
}

inline size_t HttpHeaderVec::capacity() const {
    return AzHttpHeaderVec_capacity(&inner_);
}

inline bool HttpHeaderVec::is_empty() const {
    return AzHttpHeaderVec_isEmpty(&inner_);
}

inline OptionHttpHeader HttpHeaderVec::get(size_t index) const {
    return OptionHttpHeader(AzHttpHeaderVec_get(&inner_, index));
}

inline HttpHeaderVec HttpHeaderVec::from_item(HttpHeader item) {
    return HttpHeaderVec(AzHttpHeaderVec_fromItem(item.release()));
}

inline HttpHeaderVec HttpHeaderVec::copy_from_ptr(const HttpHeader& ptr, size_t len) {
    return HttpHeaderVec(AzHttpHeaderVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionHttpHeader HttpHeaderVec::c_get(size_t index) const {
    return OptionHttpHeader(AzHttpHeaderVec_cGet(&inner_, index));
}

inline HttpHeaderVecSlice HttpHeaderVec::as_c_slice() const {
    return HttpHeaderVecSlice(AzHttpHeaderVec_asCSlice(&inner_));
}

inline HttpHeaderVecSlice HttpHeaderVec::as_c_slice_range(size_t start, size_t end) const {
    return HttpHeaderVecSlice(AzHttpHeaderVec_asCSliceRange(&inner_, start, end));
}

inline void HttpHeaderVec::delete_() {
    AzHttpHeaderVec_delete(&inner_);
}

inline HttpHeaderVec HttpHeaderVec::clone() const {
    return HttpHeaderVec(AzHttpHeaderVec_clone(&inner_));
}

inline bool HttpHeaderVec::partialEq(const HttpHeaderVec& b) const {
    return AzHttpHeaderVec_partialEq(&inner_, b.ptr());
}

inline String HttpHeaderVec::toDbgString() const {
    return String(AzHttpHeaderVec_toDbgString(&inner_));
}

inline FmtArgVec FmtArgVec::create() {
    return FmtArgVec(AzFmtArgVec_create());
}

inline FmtArgVec FmtArgVec::with_capacity(size_t cap) {
    return FmtArgVec(AzFmtArgVec_withCapacity(cap));
}

inline size_t FmtArgVec::len() const {
    return AzFmtArgVec_len(&inner_);
}

inline size_t FmtArgVec::capacity() const {
    return AzFmtArgVec_capacity(&inner_);
}

inline bool FmtArgVec::is_empty() const {
    return AzFmtArgVec_isEmpty(&inner_);
}

inline OptionFmtArg FmtArgVec::get(size_t index) const {
    return OptionFmtArg(AzFmtArgVec_get(&inner_, index));
}

inline FmtArgVec FmtArgVec::from_item(FmtArg item) {
    return FmtArgVec(AzFmtArgVec_fromItem(item.release()));
}

inline FmtArgVec FmtArgVec::copy_from_ptr(const FmtArg& ptr, size_t len) {
    return FmtArgVec(AzFmtArgVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionFmtArg FmtArgVec::c_get(size_t index) const {
    return OptionFmtArg(AzFmtArgVec_cGet(&inner_, index));
}

inline FmtArgVecSlice FmtArgVec::as_c_slice() const {
    return FmtArgVecSlice(AzFmtArgVec_asCSlice(&inner_));
}

inline FmtArgVecSlice FmtArgVec::as_c_slice_range(size_t start, size_t end) const {
    return FmtArgVecSlice(AzFmtArgVec_asCSliceRange(&inner_, start, end));
}

inline void FmtArgVec::delete_() {
    AzFmtArgVec_delete(&inner_);
}

inline FmtArgVec FmtArgVec::clone() const {
    return FmtArgVec(AzFmtArgVec_clone(&inner_));
}

inline bool FmtArgVec::partialEq(const FmtArgVec& b) const {
    return AzFmtArgVec_partialEq(&inner_, b.ptr());
}

inline uint8_t FmtArgVec::partialCmp(const FmtArgVec& b) const {
    return AzFmtArgVec_partialCmp(&inner_, b.ptr());
}

inline String FmtArgVec::toDbgString() const {
    return String(AzFmtArgVec_toDbgString(&inner_));
}

inline JsonVec JsonVec::copy_from_array(const Json& ptr, size_t len) {
    return JsonVec(AzJsonVec_copyFromArray(ptr.ptr(), len));
}

inline JsonVec JsonVec::create() {
    return JsonVec(AzJsonVec_create());
}

inline JsonVec JsonVec::with_capacity(size_t cap) {
    return JsonVec(AzJsonVec_withCapacity(cap));
}

inline size_t JsonVec::len() const {
    return AzJsonVec_len(&inner_);
}

inline size_t JsonVec::capacity() const {
    return AzJsonVec_capacity(&inner_);
}

inline bool JsonVec::is_empty() const {
    return AzJsonVec_isEmpty(&inner_);
}

inline OptionJson JsonVec::get(size_t index) const {
    return OptionJson(AzJsonVec_get(&inner_, index));
}

inline JsonVec JsonVec::from_item(Json item) {
    return JsonVec(AzJsonVec_fromItem(item.release()));
}

inline JsonVec JsonVec::copy_from_ptr(const Json& ptr, size_t len) {
    return JsonVec(AzJsonVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionJson JsonVec::c_get(size_t index) const {
    return OptionJson(AzJsonVec_cGet(&inner_, index));
}

inline JsonVecSlice JsonVec::as_c_slice() const {
    return JsonVecSlice(AzJsonVec_asCSlice(&inner_));
}

inline JsonVecSlice JsonVec::as_c_slice_range(size_t start, size_t end) const {
    return JsonVecSlice(AzJsonVec_asCSliceRange(&inner_, start, end));
}

inline void JsonVec::delete_() {
    AzJsonVec_delete(&inner_);
}

inline JsonVec JsonVec::clone() const {
    return JsonVec(AzJsonVec_clone(&inner_));
}

inline bool JsonVec::partialEq(const JsonVec& b) const {
    return AzJsonVec_partialEq(&inner_, b.ptr());
}

inline String JsonVec::toDbgString() const {
    return String(AzJsonVec_toDbgString(&inner_));
}

inline DirEntryVec DirEntryVec::create() {
    return DirEntryVec(AzDirEntryVec_create());
}

inline DirEntryVec DirEntryVec::with_capacity(size_t cap) {
    return DirEntryVec(AzDirEntryVec_withCapacity(cap));
}

inline size_t DirEntryVec::len() const {
    return AzDirEntryVec_len(&inner_);
}

inline size_t DirEntryVec::capacity() const {
    return AzDirEntryVec_capacity(&inner_);
}

inline bool DirEntryVec::is_empty() const {
    return AzDirEntryVec_isEmpty(&inner_);
}

inline OptionDirEntry DirEntryVec::get(size_t index) const {
    return OptionDirEntry(AzDirEntryVec_get(&inner_, index));
}

inline DirEntryVec DirEntryVec::from_item(DirEntry item) {
    return DirEntryVec(AzDirEntryVec_fromItem(item.release()));
}

inline DirEntryVec DirEntryVec::copy_from_ptr(const DirEntry& ptr, size_t len) {
    return DirEntryVec(AzDirEntryVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionDirEntry DirEntryVec::c_get(size_t index) const {
    return OptionDirEntry(AzDirEntryVec_cGet(&inner_, index));
}

inline DirEntryVecSlice DirEntryVec::as_c_slice() const {
    return DirEntryVecSlice(AzDirEntryVec_asCSlice(&inner_));
}

inline DirEntryVecSlice DirEntryVec::as_c_slice_range(size_t start, size_t end) const {
    return DirEntryVecSlice(AzDirEntryVec_asCSliceRange(&inner_, start, end));
}

inline void DirEntryVec::delete_() {
    AzDirEntryVec_delete(&inner_);
}

inline DirEntryVec DirEntryVec::clone() const {
    return DirEntryVec(AzDirEntryVec_clone(&inner_));
}

inline String DirEntryVec::toDbgString() const {
    return String(AzDirEntryVec_toDbgString(&inner_));
}

inline JsonKeyValueVec JsonKeyValueVec::copy_from_array(const JsonKeyValue& ptr, size_t len) {
    return JsonKeyValueVec(AzJsonKeyValueVec_copyFromArray(ptr.ptr(), len));
}

inline JsonKeyValueVec JsonKeyValueVec::create() {
    return JsonKeyValueVec(AzJsonKeyValueVec_create());
}

inline JsonKeyValueVec JsonKeyValueVec::with_capacity(size_t cap) {
    return JsonKeyValueVec(AzJsonKeyValueVec_withCapacity(cap));
}

inline size_t JsonKeyValueVec::len() const {
    return AzJsonKeyValueVec_len(&inner_);
}

inline size_t JsonKeyValueVec::capacity() const {
    return AzJsonKeyValueVec_capacity(&inner_);
}

inline bool JsonKeyValueVec::is_empty() const {
    return AzJsonKeyValueVec_isEmpty(&inner_);
}

inline OptionJsonKeyValue JsonKeyValueVec::get(size_t index) const {
    return OptionJsonKeyValue(AzJsonKeyValueVec_get(&inner_, index));
}

inline JsonKeyValueVec JsonKeyValueVec::from_item(JsonKeyValue item) {
    return JsonKeyValueVec(AzJsonKeyValueVec_fromItem(item.release()));
}

inline JsonKeyValueVec JsonKeyValueVec::copy_from_ptr(const JsonKeyValue& ptr, size_t len) {
    return JsonKeyValueVec(AzJsonKeyValueVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionJsonKeyValue JsonKeyValueVec::c_get(size_t index) const {
    return OptionJsonKeyValue(AzJsonKeyValueVec_cGet(&inner_, index));
}

inline JsonKeyValueVecSlice JsonKeyValueVec::as_c_slice() const {
    return JsonKeyValueVecSlice(AzJsonKeyValueVec_asCSlice(&inner_));
}

inline JsonKeyValueVecSlice JsonKeyValueVec::as_c_slice_range(size_t start, size_t end) const {
    return JsonKeyValueVecSlice(AzJsonKeyValueVec_asCSliceRange(&inner_, start, end));
}

inline void JsonKeyValueVec::delete_() {
    AzJsonKeyValueVec_delete(&inner_);
}

inline JsonKeyValueVec JsonKeyValueVec::clone() const {
    return JsonKeyValueVec(AzJsonKeyValueVec_clone(&inner_));
}

inline String JsonKeyValueVec::toDbgString() const {
    return String(AzJsonKeyValueVec_toDbgString(&inner_));
}

inline NamedFontVec NamedFontVec::create() {
    return NamedFontVec(AzNamedFontVec_create());
}

inline NamedFontVec NamedFontVec::with_capacity(size_t cap) {
    return NamedFontVec(AzNamedFontVec_withCapacity(cap));
}

inline size_t NamedFontVec::len() const {
    return AzNamedFontVec_len(&inner_);
}

inline size_t NamedFontVec::capacity() const {
    return AzNamedFontVec_capacity(&inner_);
}

inline bool NamedFontVec::is_empty() const {
    return AzNamedFontVec_isEmpty(&inner_);
}

inline OptionNamedFont NamedFontVec::get(size_t index) const {
    return OptionNamedFont(AzNamedFontVec_get(&inner_, index));
}

inline NamedFontVec NamedFontVec::from_item(NamedFont item) {
    return NamedFontVec(AzNamedFontVec_fromItem(item.release()));
}

inline NamedFontVec NamedFontVec::copy_from_ptr(const NamedFont& ptr, size_t len) {
    return NamedFontVec(AzNamedFontVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionNamedFont NamedFontVec::c_get(size_t index) const {
    return OptionNamedFont(AzNamedFontVec_cGet(&inner_, index));
}

inline NamedFontVecSlice NamedFontVec::as_c_slice() const {
    return NamedFontVecSlice(AzNamedFontVec_asCSlice(&inner_));
}

inline NamedFontVecSlice NamedFontVec::as_c_slice_range(size_t start, size_t end) const {
    return NamedFontVecSlice(AzNamedFontVec_asCSliceRange(&inner_, start, end));
}

inline void NamedFontVec::delete_() {
    AzNamedFontVec_delete(&inner_);
}

inline NamedFontVec NamedFontVec::clone() const {
    return NamedFontVec(AzNamedFontVec_clone(&inner_));
}

inline bool NamedFontVec::partialEq(const NamedFontVec& b) const {
    return AzNamedFontVec_partialEq(&inner_, b.ptr());
}

inline uint64_t NamedFontVec::hash() const {
    return AzNamedFontVec_hash(&inner_);
}

inline uint8_t NamedFontVec::partialCmp(const NamedFontVec& b) const {
    return AzNamedFontVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t NamedFontVec::cmp(const NamedFontVec& b) const {
    return AzNamedFontVec_cmp(&inner_, b.ptr());
}

inline String NamedFontVec::toDbgString() const {
    return String(AzNamedFontVec_toDbgString(&inner_));
}

inline ExternalResourceVec ExternalResourceVec::create() {
    return ExternalResourceVec(AzExternalResourceVec_create());
}

inline ExternalResourceVec ExternalResourceVec::with_capacity(size_t cap) {
    return ExternalResourceVec(AzExternalResourceVec_withCapacity(cap));
}

inline size_t ExternalResourceVec::len() const {
    return AzExternalResourceVec_len(&inner_);
}

inline size_t ExternalResourceVec::capacity() const {
    return AzExternalResourceVec_capacity(&inner_);
}

inline bool ExternalResourceVec::is_empty() const {
    return AzExternalResourceVec_isEmpty(&inner_);
}

inline OptionExternalResource ExternalResourceVec::get(size_t index) const {
    return OptionExternalResource(AzExternalResourceVec_get(&inner_, index));
}

inline ExternalResourceVec ExternalResourceVec::from_item(ExternalResource item) {
    return ExternalResourceVec(AzExternalResourceVec_fromItem(item.release()));
}

inline ExternalResourceVec ExternalResourceVec::copy_from_ptr(const ExternalResource& ptr, size_t len) {
    return ExternalResourceVec(AzExternalResourceVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionExternalResource ExternalResourceVec::c_get(size_t index) const {
    return OptionExternalResource(AzExternalResourceVec_cGet(&inner_, index));
}

inline ExternalResourceVecSlice ExternalResourceVec::as_c_slice() const {
    return ExternalResourceVecSlice(AzExternalResourceVec_asCSlice(&inner_));
}

inline ExternalResourceVecSlice ExternalResourceVec::as_c_slice_range(size_t start, size_t end) const {
    return ExternalResourceVecSlice(AzExternalResourceVec_asCSliceRange(&inner_, start, end));
}

inline void ExternalResourceVec::delete_() {
    AzExternalResourceVec_delete(&inner_);
}

inline ExternalResourceVec ExternalResourceVec::clone() const {
    return ExternalResourceVec(AzExternalResourceVec_clone(&inner_));
}

inline bool ExternalResourceVec::partialEq(const ExternalResourceVec& b) const {
    return AzExternalResourceVec_partialEq(&inner_, b.ptr());
}

inline uint64_t ExternalResourceVec::hash() const {
    return AzExternalResourceVec_hash(&inner_);
}

inline uint8_t ExternalResourceVec::partialCmp(const ExternalResourceVec& b) const {
    return AzExternalResourceVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t ExternalResourceVec::cmp(const ExternalResourceVec& b) const {
    return AzExternalResourceVec_cmp(&inner_, b.ptr());
}

inline String ExternalResourceVec::toDbgString() const {
    return String(AzExternalResourceVec_toDbgString(&inner_));
}

inline NodeHierarchyItemIdVec NodeHierarchyItemIdVec::create() {
    return NodeHierarchyItemIdVec(AzNodeHierarchyItemIdVec_create());
}

inline NodeHierarchyItemIdVec NodeHierarchyItemIdVec::with_capacity(size_t cap) {
    return NodeHierarchyItemIdVec(AzNodeHierarchyItemIdVec_withCapacity(cap));
}

inline size_t NodeHierarchyItemIdVec::len() const {
    return AzNodeHierarchyItemIdVec_len(&inner_);
}

inline size_t NodeHierarchyItemIdVec::capacity() const {
    return AzNodeHierarchyItemIdVec_capacity(&inner_);
}

inline bool NodeHierarchyItemIdVec::is_empty() const {
    return AzNodeHierarchyItemIdVec_isEmpty(&inner_);
}

inline NodeHierarchyItemIdVec NodeHierarchyItemIdVec::from_item(NodeHierarchyItemId item) {
    return NodeHierarchyItemIdVec(AzNodeHierarchyItemIdVec_fromItem(item.release()));
}

inline NodeHierarchyItemIdVec NodeHierarchyItemIdVec::copy_from_ptr(const NodeHierarchyItemId& ptr, size_t len) {
    return NodeHierarchyItemIdVec(AzNodeHierarchyItemIdVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionNodeHierarchyItemId NodeHierarchyItemIdVec::c_get(size_t index) const {
    return OptionNodeHierarchyItemId(AzNodeHierarchyItemIdVec_cGet(&inner_, index));
}

inline NodeHierarchyItemIdVecSlice NodeHierarchyItemIdVec::as_c_slice() const {
    return NodeHierarchyItemIdVecSlice(AzNodeHierarchyItemIdVec_asCSlice(&inner_));
}

inline NodeHierarchyItemIdVecSlice NodeHierarchyItemIdVec::as_c_slice_range(size_t start, size_t end) const {
    return NodeHierarchyItemIdVecSlice(AzNodeHierarchyItemIdVec_asCSliceRange(&inner_, start, end));
}

inline void NodeHierarchyItemIdVec::delete_() {
    AzNodeHierarchyItemIdVec_delete(&inner_);
}

inline NodeHierarchyItemIdVec NodeHierarchyItemIdVec::clone() const {
    return NodeHierarchyItemIdVec(AzNodeHierarchyItemIdVec_clone(&inner_));
}

inline bool NodeHierarchyItemIdVec::partialEq(const NodeHierarchyItemIdVec& b) const {
    return AzNodeHierarchyItemIdVec_partialEq(&inner_, b.ptr());
}

inline uint64_t NodeHierarchyItemIdVec::hash() const {
    return AzNodeHierarchyItemIdVec_hash(&inner_);
}

inline uint8_t NodeHierarchyItemIdVec::partialCmp(const NodeHierarchyItemIdVec& b) const {
    return AzNodeHierarchyItemIdVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t NodeHierarchyItemIdVec::cmp(const NodeHierarchyItemIdVec& b) const {
    return AzNodeHierarchyItemIdVec_cmp(&inner_, b.ptr());
}

inline String NodeHierarchyItemIdVec::toDbgString() const {
    return String(AzNodeHierarchyItemIdVec_toDbgString(&inner_));
}

inline CalcAstItemVec CalcAstItemVec::create() {
    return CalcAstItemVec(AzCalcAstItemVec_create());
}

inline CalcAstItemVec CalcAstItemVec::with_capacity(size_t cap) {
    return CalcAstItemVec(AzCalcAstItemVec_withCapacity(cap));
}

inline size_t CalcAstItemVec::len() const {
    return AzCalcAstItemVec_len(&inner_);
}

inline size_t CalcAstItemVec::capacity() const {
    return AzCalcAstItemVec_capacity(&inner_);
}

inline bool CalcAstItemVec::is_empty() const {
    return AzCalcAstItemVec_isEmpty(&inner_);
}

inline CalcAstItemVec CalcAstItemVec::from_item(AzCalcAstItem item) {
    return CalcAstItemVec(AzCalcAstItemVec_fromItem(item));
}

inline CalcAstItemVec CalcAstItemVec::copy_from_ptr(const AzCalcAstItem* ptr, size_t len) {
    return CalcAstItemVec(AzCalcAstItemVec_copyFromPtr(ptr, len));
}

inline OptionCalcAstItem CalcAstItemVec::c_get(size_t index) const {
    return OptionCalcAstItem(AzCalcAstItemVec_cGet(&inner_, index));
}

inline CalcAstItemVecSlice CalcAstItemVec::as_c_slice() const {
    return CalcAstItemVecSlice(AzCalcAstItemVec_asCSlice(&inner_));
}

inline CalcAstItemVecSlice CalcAstItemVec::as_c_slice_range(size_t start, size_t end) const {
    return CalcAstItemVecSlice(AzCalcAstItemVec_asCSliceRange(&inner_, start, end));
}

inline void CalcAstItemVec::delete_() {
    AzCalcAstItemVec_delete(&inner_);
}

inline CalcAstItemVec CalcAstItemVec::clone() const {
    return CalcAstItemVec(AzCalcAstItemVec_clone(&inner_));
}

inline bool CalcAstItemVec::partialEq(const CalcAstItemVec& b) const {
    return AzCalcAstItemVec_partialEq(&inner_, b.ptr());
}

inline uint64_t CalcAstItemVec::hash() const {
    return AzCalcAstItemVec_hash(&inner_);
}

inline uint8_t CalcAstItemVec::partialCmp(const CalcAstItemVec& b) const {
    return AzCalcAstItemVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t CalcAstItemVec::cmp(const CalcAstItemVec& b) const {
    return AzCalcAstItemVec_cmp(&inner_, b.ptr());
}

inline String CalcAstItemVec::toDbgString() const {
    return String(AzCalcAstItemVec_toDbgString(&inner_));
}

inline GridAreaDefinitionVec GridAreaDefinitionVec::create() {
    return GridAreaDefinitionVec(AzGridAreaDefinitionVec_create());
}

inline GridAreaDefinitionVec GridAreaDefinitionVec::with_capacity(size_t cap) {
    return GridAreaDefinitionVec(AzGridAreaDefinitionVec_withCapacity(cap));
}

inline size_t GridAreaDefinitionVec::len() const {
    return AzGridAreaDefinitionVec_len(&inner_);
}

inline size_t GridAreaDefinitionVec::capacity() const {
    return AzGridAreaDefinitionVec_capacity(&inner_);
}

inline bool GridAreaDefinitionVec::is_empty() const {
    return AzGridAreaDefinitionVec_isEmpty(&inner_);
}

inline GridAreaDefinitionVec GridAreaDefinitionVec::from_item(GridAreaDefinition item) {
    return GridAreaDefinitionVec(AzGridAreaDefinitionVec_fromItem(item.release()));
}

inline GridAreaDefinitionVec GridAreaDefinitionVec::copy_from_ptr(const GridAreaDefinition& ptr, size_t len) {
    return GridAreaDefinitionVec(AzGridAreaDefinitionVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionGridAreaDefinition GridAreaDefinitionVec::c_get(size_t index) const {
    return OptionGridAreaDefinition(AzGridAreaDefinitionVec_cGet(&inner_, index));
}

inline GridAreaDefinitionVecSlice GridAreaDefinitionVec::as_c_slice() const {
    return GridAreaDefinitionVecSlice(AzGridAreaDefinitionVec_asCSlice(&inner_));
}

inline GridAreaDefinitionVecSlice GridAreaDefinitionVec::as_c_slice_range(size_t start, size_t end) const {
    return GridAreaDefinitionVecSlice(AzGridAreaDefinitionVec_asCSliceRange(&inner_, start, end));
}

inline void GridAreaDefinitionVec::delete_() {
    AzGridAreaDefinitionVec_delete(&inner_);
}

inline GridAreaDefinitionVec GridAreaDefinitionVec::clone() const {
    return GridAreaDefinitionVec(AzGridAreaDefinitionVec_clone(&inner_));
}

inline bool GridAreaDefinitionVec::partialEq(const GridAreaDefinitionVec& b) const {
    return AzGridAreaDefinitionVec_partialEq(&inner_, b.ptr());
}

inline uint64_t GridAreaDefinitionVec::hash() const {
    return AzGridAreaDefinitionVec_hash(&inner_);
}

inline uint8_t GridAreaDefinitionVec::partialCmp(const GridAreaDefinitionVec& b) const {
    return AzGridAreaDefinitionVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t GridAreaDefinitionVec::cmp(const GridAreaDefinitionVec& b) const {
    return AzGridAreaDefinitionVec_cmp(&inner_, b.ptr());
}

inline String GridAreaDefinitionVec::toDbgString() const {
    return String(AzGridAreaDefinitionVec_toDbgString(&inner_));
}

inline ComponentDataFieldVec ComponentDataFieldVec::create() {
    return ComponentDataFieldVec(AzComponentDataFieldVec_create());
}

inline ComponentDataFieldVec ComponentDataFieldVec::with_capacity(size_t cap) {
    return ComponentDataFieldVec(AzComponentDataFieldVec_withCapacity(cap));
}

inline size_t ComponentDataFieldVec::len() const {
    return AzComponentDataFieldVec_len(&inner_);
}

inline size_t ComponentDataFieldVec::capacity() const {
    return AzComponentDataFieldVec_capacity(&inner_);
}

inline bool ComponentDataFieldVec::is_empty() const {
    return AzComponentDataFieldVec_isEmpty(&inner_);
}

inline ComponentDataFieldVec ComponentDataFieldVec::from_item(ComponentDataField item) {
    return ComponentDataFieldVec(AzComponentDataFieldVec_fromItem(item.release()));
}

inline ComponentDataFieldVec ComponentDataFieldVec::copy_from_ptr(const ComponentDataField& ptr, size_t len) {
    return ComponentDataFieldVec(AzComponentDataFieldVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionComponentDataField ComponentDataFieldVec::c_get(size_t index) const {
    return OptionComponentDataField(AzComponentDataFieldVec_cGet(&inner_, index));
}

inline ComponentDataFieldVecSlice ComponentDataFieldVec::as_c_slice() const {
    return ComponentDataFieldVecSlice(AzComponentDataFieldVec_asCSlice(&inner_));
}

inline ComponentDataFieldVecSlice ComponentDataFieldVec::as_c_slice_range(size_t start, size_t end) const {
    return ComponentDataFieldVecSlice(AzComponentDataFieldVec_asCSliceRange(&inner_, start, end));
}

inline void ComponentDataFieldVec::delete_() {
    AzComponentDataFieldVec_delete(&inner_);
}

inline ComponentDataFieldVec ComponentDataFieldVec::clone() const {
    return ComponentDataFieldVec(AzComponentDataFieldVec_clone(&inner_));
}

inline bool ComponentDataFieldVec::partialEq(const ComponentDataFieldVec& b) const {
    return AzComponentDataFieldVec_partialEq(&inner_, b.ptr());
}

inline String ComponentDataFieldVec::toDbgString() const {
    return String(AzComponentDataFieldVec_toDbgString(&inner_));
}

inline ComponentDefVec ComponentDefVec::create() {
    return ComponentDefVec(AzComponentDefVec_create());
}

inline ComponentDefVec ComponentDefVec::with_capacity(size_t cap) {
    return ComponentDefVec(AzComponentDefVec_withCapacity(cap));
}

inline size_t ComponentDefVec::len() const {
    return AzComponentDefVec_len(&inner_);
}

inline size_t ComponentDefVec::capacity() const {
    return AzComponentDefVec_capacity(&inner_);
}

inline bool ComponentDefVec::is_empty() const {
    return AzComponentDefVec_isEmpty(&inner_);
}

inline ComponentDefVec ComponentDefVec::from_item(ComponentDef item) {
    return ComponentDefVec(AzComponentDefVec_fromItem(item.release()));
}

inline ComponentDefVec ComponentDefVec::copy_from_ptr(const ComponentDef& ptr, size_t len) {
    return ComponentDefVec(AzComponentDefVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionComponentDef ComponentDefVec::c_get(size_t index) const {
    return OptionComponentDef(AzComponentDefVec_cGet(&inner_, index));
}

inline ComponentDefVecSlice ComponentDefVec::as_c_slice() const {
    return ComponentDefVecSlice(AzComponentDefVec_asCSlice(&inner_));
}

inline ComponentDefVecSlice ComponentDefVec::as_c_slice_range(size_t start, size_t end) const {
    return ComponentDefVecSlice(AzComponentDefVec_asCSliceRange(&inner_, start, end));
}

inline void ComponentDefVec::delete_() {
    AzComponentDefVec_delete(&inner_);
}

inline ComponentDefVec ComponentDefVec::clone() const {
    return ComponentDefVec(AzComponentDefVec_clone(&inner_));
}

inline String ComponentDefVec::toDbgString() const {
    return String(AzComponentDefVec_toDbgString(&inner_));
}

inline ComponentLibraryVec ComponentLibraryVec::create() {
    return ComponentLibraryVec(AzComponentLibraryVec_create());
}

inline ComponentLibraryVec ComponentLibraryVec::with_capacity(size_t cap) {
    return ComponentLibraryVec(AzComponentLibraryVec_withCapacity(cap));
}

inline size_t ComponentLibraryVec::len() const {
    return AzComponentLibraryVec_len(&inner_);
}

inline size_t ComponentLibraryVec::capacity() const {
    return AzComponentLibraryVec_capacity(&inner_);
}

inline bool ComponentLibraryVec::is_empty() const {
    return AzComponentLibraryVec_isEmpty(&inner_);
}

inline ComponentLibraryVec ComponentLibraryVec::from_item(ComponentLibrary item) {
    return ComponentLibraryVec(AzComponentLibraryVec_fromItem(item.release()));
}

inline ComponentLibraryVec ComponentLibraryVec::copy_from_ptr(const ComponentLibrary& ptr, size_t len) {
    return ComponentLibraryVec(AzComponentLibraryVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionComponentLibrary ComponentLibraryVec::c_get(size_t index) const {
    return OptionComponentLibrary(AzComponentLibraryVec_cGet(&inner_, index));
}

inline ComponentLibraryVecSlice ComponentLibraryVec::as_c_slice() const {
    return ComponentLibraryVecSlice(AzComponentLibraryVec_asCSlice(&inner_));
}

inline ComponentLibraryVecSlice ComponentLibraryVec::as_c_slice_range(size_t start, size_t end) const {
    return ComponentLibraryVecSlice(AzComponentLibraryVec_asCSliceRange(&inner_, start, end));
}

inline void ComponentLibraryVec::delete_() {
    AzComponentLibraryVec_delete(&inner_);
}

inline ComponentLibraryVec ComponentLibraryVec::clone() const {
    return ComponentLibraryVec(AzComponentLibraryVec_clone(&inner_));
}

inline String ComponentLibraryVec::toDbgString() const {
    return String(AzComponentLibraryVec_toDbgString(&inner_));
}

inline ComponentDataModelVec ComponentDataModelVec::create() {
    return ComponentDataModelVec(AzComponentDataModelVec_create());
}

inline ComponentDataModelVec ComponentDataModelVec::with_capacity(size_t cap) {
    return ComponentDataModelVec(AzComponentDataModelVec_withCapacity(cap));
}

inline size_t ComponentDataModelVec::len() const {
    return AzComponentDataModelVec_len(&inner_);
}

inline size_t ComponentDataModelVec::capacity() const {
    return AzComponentDataModelVec_capacity(&inner_);
}

inline bool ComponentDataModelVec::is_empty() const {
    return AzComponentDataModelVec_isEmpty(&inner_);
}

inline ComponentDataModelVec ComponentDataModelVec::from_item(ComponentDataModel item) {
    return ComponentDataModelVec(AzComponentDataModelVec_fromItem(item.release()));
}

inline ComponentDataModelVec ComponentDataModelVec::copy_from_ptr(const ComponentDataModel& ptr, size_t len) {
    return ComponentDataModelVec(AzComponentDataModelVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionComponentDataModel ComponentDataModelVec::c_get(size_t index) const {
    return OptionComponentDataModel(AzComponentDataModelVec_cGet(&inner_, index));
}

inline ComponentDataModelVecSlice ComponentDataModelVec::as_c_slice() const {
    return ComponentDataModelVecSlice(AzComponentDataModelVec_asCSlice(&inner_));
}

inline ComponentDataModelVecSlice ComponentDataModelVec::as_c_slice_range(size_t start, size_t end) const {
    return ComponentDataModelVecSlice(AzComponentDataModelVec_asCSliceRange(&inner_, start, end));
}

inline void ComponentDataModelVec::delete_() {
    AzComponentDataModelVec_delete(&inner_);
}

inline ComponentDataModelVec ComponentDataModelVec::clone() const {
    return ComponentDataModelVec(AzComponentDataModelVec_clone(&inner_));
}

inline String ComponentDataModelVec::toDbgString() const {
    return String(AzComponentDataModelVec_toDbgString(&inner_));
}

inline ComponentEnumModelVec ComponentEnumModelVec::create() {
    return ComponentEnumModelVec(AzComponentEnumModelVec_create());
}

inline ComponentEnumModelVec ComponentEnumModelVec::with_capacity(size_t cap) {
    return ComponentEnumModelVec(AzComponentEnumModelVec_withCapacity(cap));
}

inline size_t ComponentEnumModelVec::len() const {
    return AzComponentEnumModelVec_len(&inner_);
}

inline size_t ComponentEnumModelVec::capacity() const {
    return AzComponentEnumModelVec_capacity(&inner_);
}

inline bool ComponentEnumModelVec::is_empty() const {
    return AzComponentEnumModelVec_isEmpty(&inner_);
}

inline ComponentEnumModelVec ComponentEnumModelVec::from_item(ComponentEnumModel item) {
    return ComponentEnumModelVec(AzComponentEnumModelVec_fromItem(item.release()));
}

inline ComponentEnumModelVec ComponentEnumModelVec::copy_from_ptr(const ComponentEnumModel& ptr, size_t len) {
    return ComponentEnumModelVec(AzComponentEnumModelVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionComponentEnumModel ComponentEnumModelVec::c_get(size_t index) const {
    return OptionComponentEnumModel(AzComponentEnumModelVec_cGet(&inner_, index));
}

inline ComponentEnumModelVecSlice ComponentEnumModelVec::as_c_slice() const {
    return ComponentEnumModelVecSlice(AzComponentEnumModelVec_asCSlice(&inner_));
}

inline ComponentEnumModelVecSlice ComponentEnumModelVec::as_c_slice_range(size_t start, size_t end) const {
    return ComponentEnumModelVecSlice(AzComponentEnumModelVec_asCSliceRange(&inner_, start, end));
}

inline void ComponentEnumModelVec::delete_() {
    AzComponentEnumModelVec_delete(&inner_);
}

inline ComponentEnumModelVec ComponentEnumModelVec::clone() const {
    return ComponentEnumModelVec(AzComponentEnumModelVec_clone(&inner_));
}

inline bool ComponentEnumModelVec::partialEq(const ComponentEnumModelVec& b) const {
    return AzComponentEnumModelVec_partialEq(&inner_, b.ptr());
}

inline String ComponentEnumModelVec::toDbgString() const {
    return String(AzComponentEnumModelVec_toDbgString(&inner_));
}

inline ComponentEnumVariantVec ComponentEnumVariantVec::create() {
    return ComponentEnumVariantVec(AzComponentEnumVariantVec_create());
}

inline ComponentEnumVariantVec ComponentEnumVariantVec::with_capacity(size_t cap) {
    return ComponentEnumVariantVec(AzComponentEnumVariantVec_withCapacity(cap));
}

inline size_t ComponentEnumVariantVec::len() const {
    return AzComponentEnumVariantVec_len(&inner_);
}

inline size_t ComponentEnumVariantVec::capacity() const {
    return AzComponentEnumVariantVec_capacity(&inner_);
}

inline bool ComponentEnumVariantVec::is_empty() const {
    return AzComponentEnumVariantVec_isEmpty(&inner_);
}

inline ComponentEnumVariantVec ComponentEnumVariantVec::from_item(ComponentEnumVariant item) {
    return ComponentEnumVariantVec(AzComponentEnumVariantVec_fromItem(item.release()));
}

inline ComponentEnumVariantVec ComponentEnumVariantVec::copy_from_ptr(const ComponentEnumVariant& ptr, size_t len) {
    return ComponentEnumVariantVec(AzComponentEnumVariantVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionComponentEnumVariant ComponentEnumVariantVec::c_get(size_t index) const {
    return OptionComponentEnumVariant(AzComponentEnumVariantVec_cGet(&inner_, index));
}

inline ComponentEnumVariantVecSlice ComponentEnumVariantVec::as_c_slice() const {
    return ComponentEnumVariantVecSlice(AzComponentEnumVariantVec_asCSlice(&inner_));
}

inline ComponentEnumVariantVecSlice ComponentEnumVariantVec::as_c_slice_range(size_t start, size_t end) const {
    return ComponentEnumVariantVecSlice(AzComponentEnumVariantVec_asCSliceRange(&inner_, start, end));
}

inline void ComponentEnumVariantVec::delete_() {
    AzComponentEnumVariantVec_delete(&inner_);
}

inline ComponentEnumVariantVec ComponentEnumVariantVec::clone() const {
    return ComponentEnumVariantVec(AzComponentEnumVariantVec_clone(&inner_));
}

inline bool ComponentEnumVariantVec::partialEq(const ComponentEnumVariantVec& b) const {
    return AzComponentEnumVariantVec_partialEq(&inner_, b.ptr());
}

inline String ComponentEnumVariantVec::toDbgString() const {
    return String(AzComponentEnumVariantVec_toDbgString(&inner_));
}

inline ComponentCallbackArgVec ComponentCallbackArgVec::create() {
    return ComponentCallbackArgVec(AzComponentCallbackArgVec_create());
}

inline ComponentCallbackArgVec ComponentCallbackArgVec::with_capacity(size_t cap) {
    return ComponentCallbackArgVec(AzComponentCallbackArgVec_withCapacity(cap));
}

inline size_t ComponentCallbackArgVec::len() const {
    return AzComponentCallbackArgVec_len(&inner_);
}

inline size_t ComponentCallbackArgVec::capacity() const {
    return AzComponentCallbackArgVec_capacity(&inner_);
}

inline bool ComponentCallbackArgVec::is_empty() const {
    return AzComponentCallbackArgVec_isEmpty(&inner_);
}

inline ComponentCallbackArgVec ComponentCallbackArgVec::from_item(ComponentCallbackArg item) {
    return ComponentCallbackArgVec(AzComponentCallbackArgVec_fromItem(item.release()));
}

inline ComponentCallbackArgVec ComponentCallbackArgVec::copy_from_ptr(const ComponentCallbackArg& ptr, size_t len) {
    return ComponentCallbackArgVec(AzComponentCallbackArgVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionComponentCallbackArg ComponentCallbackArgVec::c_get(size_t index) const {
    return OptionComponentCallbackArg(AzComponentCallbackArgVec_cGet(&inner_, index));
}

inline ComponentCallbackArgVecSlice ComponentCallbackArgVec::as_c_slice() const {
    return ComponentCallbackArgVecSlice(AzComponentCallbackArgVec_asCSlice(&inner_));
}

inline ComponentCallbackArgVecSlice ComponentCallbackArgVec::as_c_slice_range(size_t start, size_t end) const {
    return ComponentCallbackArgVecSlice(AzComponentCallbackArgVec_asCSliceRange(&inner_, start, end));
}

inline void ComponentCallbackArgVec::delete_() {
    AzComponentCallbackArgVec_delete(&inner_);
}

inline ComponentCallbackArgVec ComponentCallbackArgVec::clone() const {
    return ComponentCallbackArgVec(AzComponentCallbackArgVec_clone(&inner_));
}

inline bool ComponentCallbackArgVec::partialEq(const ComponentCallbackArgVec& b) const {
    return AzComponentCallbackArgVec_partialEq(&inner_, b.ptr());
}

inline uint64_t ComponentCallbackArgVec::hash() const {
    return AzComponentCallbackArgVec_hash(&inner_);
}

inline uint8_t ComponentCallbackArgVec::partialCmp(const ComponentCallbackArgVec& b) const {
    return AzComponentCallbackArgVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t ComponentCallbackArgVec::cmp(const ComponentCallbackArgVec& b) const {
    return AzComponentCallbackArgVec_cmp(&inner_, b.ptr());
}

inline String ComponentCallbackArgVec::toDbgString() const {
    return String(AzComponentCallbackArgVec_toDbgString(&inner_));
}

inline ComponentFieldOverrideVec ComponentFieldOverrideVec::create() {
    return ComponentFieldOverrideVec(AzComponentFieldOverrideVec_create());
}

inline ComponentFieldOverrideVec ComponentFieldOverrideVec::with_capacity(size_t cap) {
    return ComponentFieldOverrideVec(AzComponentFieldOverrideVec_withCapacity(cap));
}

inline size_t ComponentFieldOverrideVec::len() const {
    return AzComponentFieldOverrideVec_len(&inner_);
}

inline size_t ComponentFieldOverrideVec::capacity() const {
    return AzComponentFieldOverrideVec_capacity(&inner_);
}

inline bool ComponentFieldOverrideVec::is_empty() const {
    return AzComponentFieldOverrideVec_isEmpty(&inner_);
}

inline ComponentFieldOverrideVec ComponentFieldOverrideVec::from_item(ComponentFieldOverride item) {
    return ComponentFieldOverrideVec(AzComponentFieldOverrideVec_fromItem(item.release()));
}

inline ComponentFieldOverrideVec ComponentFieldOverrideVec::copy_from_ptr(const ComponentFieldOverride& ptr, size_t len) {
    return ComponentFieldOverrideVec(AzComponentFieldOverrideVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionComponentFieldOverride ComponentFieldOverrideVec::c_get(size_t index) const {
    return OptionComponentFieldOverride(AzComponentFieldOverrideVec_cGet(&inner_, index));
}

inline ComponentFieldOverrideVecSlice ComponentFieldOverrideVec::as_c_slice() const {
    return ComponentFieldOverrideVecSlice(AzComponentFieldOverrideVec_asCSlice(&inner_));
}

inline ComponentFieldOverrideVecSlice ComponentFieldOverrideVec::as_c_slice_range(size_t start, size_t end) const {
    return ComponentFieldOverrideVecSlice(AzComponentFieldOverrideVec_asCSliceRange(&inner_, start, end));
}

inline void ComponentFieldOverrideVec::delete_() {
    AzComponentFieldOverrideVec_delete(&inner_);
}

inline ComponentFieldOverrideVec ComponentFieldOverrideVec::clone() const {
    return ComponentFieldOverrideVec(AzComponentFieldOverrideVec_clone(&inner_));
}

inline bool ComponentFieldOverrideVec::partialEq(const ComponentFieldOverrideVec& b) const {
    return AzComponentFieldOverrideVec_partialEq(&inner_, b.ptr());
}

inline String ComponentFieldOverrideVec::toDbgString() const {
    return String(AzComponentFieldOverrideVec_toDbgString(&inner_));
}

inline SvgPathElementVec SvgPathElementVec::create() {
    return SvgPathElementVec(AzSvgPathElementVec_create());
}

inline SvgPathElementVec SvgPathElementVec::with_capacity(size_t cap) {
    return SvgPathElementVec(AzSvgPathElementVec_withCapacity(cap));
}

inline size_t SvgPathElementVec::len() const {
    return AzSvgPathElementVec_len(&inner_);
}

inline size_t SvgPathElementVec::capacity() const {
    return AzSvgPathElementVec_capacity(&inner_);
}

inline bool SvgPathElementVec::is_empty() const {
    return AzSvgPathElementVec_isEmpty(&inner_);
}

inline SvgPathElementVec SvgPathElementVec::from_item(AzSvgPathElement item) {
    return SvgPathElementVec(AzSvgPathElementVec_fromItem(item));
}

inline SvgPathElementVec SvgPathElementVec::copy_from_ptr(const AzSvgPathElement* ptr, size_t len) {
    return SvgPathElementVec(AzSvgPathElementVec_copyFromPtr(ptr, len));
}

inline OptionSvgPathElement SvgPathElementVec::c_get(size_t index) const {
    return OptionSvgPathElement(AzSvgPathElementVec_cGet(&inner_, index));
}

inline SvgPathElementVecSlice SvgPathElementVec::as_c_slice() const {
    return SvgPathElementVecSlice(AzSvgPathElementVec_asCSlice(&inner_));
}

inline SvgPathElementVecSlice SvgPathElementVec::as_c_slice_range(size_t start, size_t end) const {
    return SvgPathElementVecSlice(AzSvgPathElementVec_asCSliceRange(&inner_, start, end));
}

inline void SvgPathElementVec::delete_() {
    AzSvgPathElementVec_delete(&inner_);
}

inline SvgPathElementVec SvgPathElementVec::clone() const {
    return SvgPathElementVec(AzSvgPathElementVec_clone(&inner_));
}

inline bool SvgPathElementVec::partialEq(const SvgPathElementVec& b) const {
    return AzSvgPathElementVec_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgPathElementVec::partialCmp(const SvgPathElementVec& b) const {
    return AzSvgPathElementVec_partialCmp(&inner_, b.ptr());
}

inline String SvgPathElementVec::toDbgString() const {
    return String(AzSvgPathElementVec_toDbgString(&inner_));
}

inline SvgPathVec SvgPathVec::create() {
    return SvgPathVec(AzSvgPathVec_create());
}

inline SvgPathVec SvgPathVec::with_capacity(size_t cap) {
    return SvgPathVec(AzSvgPathVec_withCapacity(cap));
}

inline size_t SvgPathVec::len() const {
    return AzSvgPathVec_len(&inner_);
}

inline size_t SvgPathVec::capacity() const {
    return AzSvgPathVec_capacity(&inner_);
}

inline bool SvgPathVec::is_empty() const {
    return AzSvgPathVec_isEmpty(&inner_);
}

inline SvgPathVec SvgPathVec::from_item(SvgPath item) {
    return SvgPathVec(AzSvgPathVec_fromItem(item.release()));
}

inline SvgPathVec SvgPathVec::copy_from_ptr(const SvgPath& ptr, size_t len) {
    return SvgPathVec(AzSvgPathVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionSvgPath SvgPathVec::c_get(size_t index) const {
    return OptionSvgPath(AzSvgPathVec_cGet(&inner_, index));
}

inline SvgPathVecSlice SvgPathVec::as_c_slice() const {
    return SvgPathVecSlice(AzSvgPathVec_asCSlice(&inner_));
}

inline SvgPathVecSlice SvgPathVec::as_c_slice_range(size_t start, size_t end) const {
    return SvgPathVecSlice(AzSvgPathVec_asCSliceRange(&inner_, start, end));
}

inline void SvgPathVec::delete_() {
    AzSvgPathVec_delete(&inner_);
}

inline SvgPathVec SvgPathVec::clone() const {
    return SvgPathVec(AzSvgPathVec_clone(&inner_));
}

inline bool SvgPathVec::partialEq(const SvgPathVec& b) const {
    return AzSvgPathVec_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgPathVec::partialCmp(const SvgPathVec& b) const {
    return AzSvgPathVec_partialCmp(&inner_, b.ptr());
}

inline String SvgPathVec::toDbgString() const {
    return String(AzSvgPathVec_toDbgString(&inner_));
}

inline RibbonSectionVec RibbonSectionVec::create() {
    return RibbonSectionVec(AzRibbonSectionVec_create());
}

inline RibbonSectionVec RibbonSectionVec::with_capacity(size_t cap) {
    return RibbonSectionVec(AzRibbonSectionVec_withCapacity(cap));
}

inline size_t RibbonSectionVec::len() const {
    return AzRibbonSectionVec_len(&inner_);
}

inline size_t RibbonSectionVec::capacity() const {
    return AzRibbonSectionVec_capacity(&inner_);
}

inline bool RibbonSectionVec::is_empty() const {
    return AzRibbonSectionVec_isEmpty(&inner_);
}

inline RibbonSectionVec RibbonSectionVec::from_item(RibbonSection item) {
    return RibbonSectionVec(AzRibbonSectionVec_fromItem(item.release()));
}

inline RibbonSectionVec RibbonSectionVec::copy_from_ptr(const RibbonSection& ptr, size_t len) {
    return RibbonSectionVec(AzRibbonSectionVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionRibbonSection RibbonSectionVec::c_get(size_t index) const {
    return OptionRibbonSection(AzRibbonSectionVec_cGet(&inner_, index));
}

inline RibbonSectionVecSlice RibbonSectionVec::as_c_slice() const {
    return RibbonSectionVecSlice(AzRibbonSectionVec_asCSlice(&inner_));
}

inline RibbonSectionVecSlice RibbonSectionVec::as_c_slice_range(size_t start, size_t end) const {
    return RibbonSectionVecSlice(AzRibbonSectionVec_asCSliceRange(&inner_, start, end));
}

inline void RibbonSectionVec::delete_() {
    AzRibbonSectionVec_delete(&inner_);
}

inline RibbonSectionVec RibbonSectionVec::clone() const {
    return RibbonSectionVec(AzRibbonSectionVec_clone(&inner_));
}

inline String RibbonSectionVec::toDbgString() const {
    return String(AzRibbonSectionVec_toDbgString(&inner_));
}

inline RibbonTabVec RibbonTabVec::create() {
    return RibbonTabVec(AzRibbonTabVec_create());
}

inline RibbonTabVec RibbonTabVec::with_capacity(size_t cap) {
    return RibbonTabVec(AzRibbonTabVec_withCapacity(cap));
}

inline size_t RibbonTabVec::len() const {
    return AzRibbonTabVec_len(&inner_);
}

inline size_t RibbonTabVec::capacity() const {
    return AzRibbonTabVec_capacity(&inner_);
}

inline bool RibbonTabVec::is_empty() const {
    return AzRibbonTabVec_isEmpty(&inner_);
}

inline RibbonTabVec RibbonTabVec::from_item(RibbonTab item) {
    return RibbonTabVec(AzRibbonTabVec_fromItem(item.release()));
}

inline RibbonTabVec RibbonTabVec::copy_from_ptr(const RibbonTab& ptr, size_t len) {
    return RibbonTabVec(AzRibbonTabVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionRibbonTab RibbonTabVec::c_get(size_t index) const {
    return OptionRibbonTab(AzRibbonTabVec_cGet(&inner_, index));
}

inline RibbonTabVecSlice RibbonTabVec::as_c_slice() const {
    return RibbonTabVecSlice(AzRibbonTabVec_asCSlice(&inner_));
}

inline RibbonTabVecSlice RibbonTabVec::as_c_slice_range(size_t start, size_t end) const {
    return RibbonTabVecSlice(AzRibbonTabVec_asCSliceRange(&inner_, start, end));
}

inline void RibbonTabVec::delete_() {
    AzRibbonTabVec_delete(&inner_);
}

inline RibbonTabVec RibbonTabVec::clone() const {
    return RibbonTabVec(AzRibbonTabVec_clone(&inner_));
}

inline String RibbonTabVec::toDbgString() const {
    return String(AzRibbonTabVec_toDbgString(&inner_));
}

inline TreeViewNodeVec TreeViewNodeVec::create() {
    return TreeViewNodeVec(AzTreeViewNodeVec_create());
}

inline TreeViewNodeVec TreeViewNodeVec::with_capacity(size_t cap) {
    return TreeViewNodeVec(AzTreeViewNodeVec_withCapacity(cap));
}

inline size_t TreeViewNodeVec::len() const {
    return AzTreeViewNodeVec_len(&inner_);
}

inline size_t TreeViewNodeVec::capacity() const {
    return AzTreeViewNodeVec_capacity(&inner_);
}

inline bool TreeViewNodeVec::is_empty() const {
    return AzTreeViewNodeVec_isEmpty(&inner_);
}

inline TreeViewNodeVec TreeViewNodeVec::from_item(TreeViewNode item) {
    return TreeViewNodeVec(AzTreeViewNodeVec_fromItem(item.release()));
}

inline TreeViewNodeVec TreeViewNodeVec::copy_from_ptr(const TreeViewNode& ptr, size_t len) {
    return TreeViewNodeVec(AzTreeViewNodeVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionTreeViewNode TreeViewNodeVec::c_get(size_t index) const {
    return OptionTreeViewNode(AzTreeViewNodeVec_cGet(&inner_, index));
}

inline TreeViewNodeVecSlice TreeViewNodeVec::as_c_slice() const {
    return TreeViewNodeVecSlice(AzTreeViewNodeVec_asCSlice(&inner_));
}

inline TreeViewNodeVecSlice TreeViewNodeVec::as_c_slice_range(size_t start, size_t end) const {
    return TreeViewNodeVecSlice(AzTreeViewNodeVec_asCSliceRange(&inner_, start, end));
}

inline void TreeViewNodeVec::delete_() {
    AzTreeViewNodeVec_delete(&inner_);
}

inline TreeViewNodeVec TreeViewNodeVec::clone() const {
    return TreeViewNodeVec(AzTreeViewNodeVec_clone(&inner_));
}

inline bool TreeViewNodeVec::partialEq(const TreeViewNodeVec& b) const {
    return AzTreeViewNodeVec_partialEq(&inner_, b.ptr());
}

inline String TreeViewNodeVec::toDbgString() const {
    return String(AzTreeViewNodeVec_toDbgString(&inner_));
}

inline RouteVec RouteVec::create() {
    return RouteVec(AzRouteVec_create());
}

inline RouteVec RouteVec::with_capacity(size_t cap) {
    return RouteVec(AzRouteVec_withCapacity(cap));
}

inline size_t RouteVec::len() const {
    return AzRouteVec_len(&inner_);
}

inline size_t RouteVec::capacity() const {
    return AzRouteVec_capacity(&inner_);
}

inline bool RouteVec::is_empty() const {
    return AzRouteVec_isEmpty(&inner_);
}

inline RouteVec RouteVec::from_item(Route item) {
    return RouteVec(AzRouteVec_fromItem(item.release()));
}

inline RouteVec RouteVec::copy_from_ptr(const Route& ptr, size_t len) {
    return RouteVec(AzRouteVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionRoute RouteVec::c_get(size_t index) const {
    return OptionRoute(AzRouteVec_cGet(&inner_, index));
}

inline RouteVecSlice RouteVec::as_c_slice() const {
    return RouteVecSlice(AzRouteVec_asCSlice(&inner_));
}

inline RouteVecSlice RouteVec::as_c_slice_range(size_t start, size_t end) const {
    return RouteVecSlice(AzRouteVec_asCSliceRange(&inner_, start, end));
}

inline void RouteVec::delete_() {
    AzRouteVec_delete(&inner_);
}

inline RouteVec RouteVec::clone() const {
    return RouteVec(AzRouteVec_clone(&inner_));
}

inline bool RouteVec::partialEq(const RouteVec& b) const {
    return AzRouteVec_partialEq(&inner_, b.ptr());
}

inline uint64_t RouteVec::hash() const {
    return AzRouteVec_hash(&inner_);
}

inline uint8_t RouteVec::partialCmp(const RouteVec& b) const {
    return AzRouteVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t RouteVec::cmp(const RouteVec& b) const {
    return AzRouteVec_cmp(&inner_, b.ptr());
}

inline String RouteVec::toDbgString() const {
    return String(AzRouteVec_toDbgString(&inner_));
}

inline TouchPointVec TouchPointVec::create() {
    return TouchPointVec(AzTouchPointVec_create());
}

inline TouchPointVec TouchPointVec::with_capacity(size_t cap) {
    return TouchPointVec(AzTouchPointVec_withCapacity(cap));
}

inline size_t TouchPointVec::len() const {
    return AzTouchPointVec_len(&inner_);
}

inline size_t TouchPointVec::capacity() const {
    return AzTouchPointVec_capacity(&inner_);
}

inline bool TouchPointVec::is_empty() const {
    return AzTouchPointVec_isEmpty(&inner_);
}

inline TouchPointVec TouchPointVec::from_item(TouchPoint item) {
    return TouchPointVec(AzTouchPointVec_fromItem(item.release()));
}

inline TouchPointVec TouchPointVec::copy_from_ptr(const TouchPoint& ptr, size_t len) {
    return TouchPointVec(AzTouchPointVec_copyFromPtr(ptr.ptr(), len));
}

inline OptionTouchPoint TouchPointVec::c_get(size_t index) const {
    return OptionTouchPoint(AzTouchPointVec_cGet(&inner_, index));
}

inline TouchPointVecSlice TouchPointVec::as_c_slice() const {
    return TouchPointVecSlice(AzTouchPointVec_asCSlice(&inner_));
}

inline TouchPointVecSlice TouchPointVec::as_c_slice_range(size_t start, size_t end) const {
    return TouchPointVecSlice(AzTouchPointVec_asCSliceRange(&inner_, start, end));
}

inline void TouchPointVec::delete_() {
    AzTouchPointVec_delete(&inner_);
}

inline TouchPointVec TouchPointVec::clone() const {
    return TouchPointVec(AzTouchPointVec_clone(&inner_));
}

inline bool TouchPointVec::partialEq(const TouchPointVec& b) const {
    return AzTouchPointVec_partialEq(&inner_, b.ptr());
}

inline String TouchPointVec::toDbgString() const {
    return String(AzTouchPointVec_toDbgString(&inner_));
}

inline LayoutRectVec LayoutRectVec::create() {
    return LayoutRectVec(AzLayoutRectVec_create());
}

inline LayoutRectVec LayoutRectVec::with_capacity(size_t cap) {
    return LayoutRectVec(AzLayoutRectVec_withCapacity(cap));
}

inline LayoutRectVec LayoutRectVec::from_item(LayoutRect item) {
    return LayoutRectVec(AzLayoutRectVec_fromItem(item.release()));
}

inline LayoutRectVec LayoutRectVec::copy_from_ptr(const LayoutRect& ptr, size_t len) {
    return LayoutRectVec(AzLayoutRectVec_copyFromPtr(ptr.ptr(), len));
}

inline size_t LayoutRectVec::len() const {
    return AzLayoutRectVec_len(&inner_);
}

inline size_t LayoutRectVec::capacity() const {
    return AzLayoutRectVec_capacity(&inner_);
}

inline bool LayoutRectVec::is_empty() const {
    return AzLayoutRectVec_isEmpty(&inner_);
}

inline OptionLayoutRect LayoutRectVec::get(size_t index) const {
    return OptionLayoutRect(AzLayoutRectVec_get(&inner_, index));
}

inline OptionLayoutRect LayoutRectVec::c_get(size_t index) const {
    return OptionLayoutRect(AzLayoutRectVec_cGet(&inner_, index));
}

inline LayoutRectVecSlice LayoutRectVec::as_c_slice() const {
    return LayoutRectVecSlice(AzLayoutRectVec_asCSlice(&inner_));
}

inline LayoutRectVecSlice LayoutRectVec::as_c_slice_range(size_t start, size_t end) const {
    return LayoutRectVecSlice(AzLayoutRectVec_asCSliceRange(&inner_, start, end));
}

inline void LayoutRectVec::delete_() {
    AzLayoutRectVec_delete(&inner_);
}

inline LayoutRectVec LayoutRectVec::clone() const {
    return LayoutRectVec(AzLayoutRectVec_clone(&inner_));
}

inline bool LayoutRectVec::partialEq(const LayoutRectVec& b) const {
    return AzLayoutRectVec_partialEq(&inner_, b.ptr());
}

inline uint8_t LayoutRectVec::partialCmp(const LayoutRectVec& b) const {
    return AzLayoutRectVec_partialCmp(&inner_, b.ptr());
}

inline String LayoutRectVec::toDbgString() const {
    return String(AzLayoutRectVec_toDbgString(&inner_));
}

inline DbValueVec DbValueVec::create() {
    return DbValueVec(AzDbValueVec_create());
}

inline DbValueVec DbValueVec::with_capacity(size_t cap) {
    return DbValueVec(AzDbValueVec_withCapacity(cap));
}

inline size_t DbValueVec::len() const {
    return AzDbValueVec_len(&inner_);
}

inline size_t DbValueVec::capacity() const {
    return AzDbValueVec_capacity(&inner_);
}

inline bool DbValueVec::is_empty() const {
    return AzDbValueVec_isEmpty(&inner_);
}

inline DbValueVec DbValueVec::from_item(AzDbValue item) {
    return DbValueVec(AzDbValueVec_fromItem(item));
}

inline DbValueVec DbValueVec::copy_from_ptr(const AzDbValue* ptr, size_t len) {
    return DbValueVec(AzDbValueVec_copyFromPtr(ptr, len));
}

inline OptionDbValue DbValueVec::c_get(size_t index) const {
    return OptionDbValue(AzDbValueVec_cGet(&inner_, index));
}

inline DbValueVecSlice DbValueVec::as_c_slice() const {
    return DbValueVecSlice(AzDbValueVec_asCSlice(&inner_));
}

inline DbValueVecSlice DbValueVec::as_c_slice_range(size_t start, size_t end) const {
    return DbValueVecSlice(AzDbValueVec_asCSliceRange(&inner_, start, end));
}

inline void DbValueVec::delete_() {
    AzDbValueVec_delete(&inner_);
}

inline DbValueVec DbValueVec::clone() const {
    return DbValueVec(AzDbValueVec_clone(&inner_));
}

inline bool DbValueVec::partialEq(const DbValueVec& b) const {
    return AzDbValueVec_partialEq(&inner_, b.ptr());
}

inline String DbValueVec::toDbgString() const {
    return String(AzDbValueVec_toDbgString(&inner_));
}

inline LoadedFontVec LoadedFontVec::create() {
    return LoadedFontVec(AzLoadedFontVec_create());
}

inline LoadedFontVec LoadedFontVec::with_capacity(size_t cap) {
    return LoadedFontVec(AzLoadedFontVec_withCapacity(cap));
}

inline size_t LoadedFontVec::len() const {
    return AzLoadedFontVec_len(&inner_);
}

inline size_t LoadedFontVec::capacity() const {
    return AzLoadedFontVec_capacity(&inner_);
}

inline bool LoadedFontVec::is_empty() const {
    return AzLoadedFontVec_isEmpty(&inner_);
}

inline OptionLoadedFont LoadedFontVec::c_get(size_t index) const {
    return OptionLoadedFont(AzLoadedFontVec_cGet(&inner_, index));
}

inline LoadedFontVec LoadedFontVec::from_item(LoadedFont item) {
    return LoadedFontVec(AzLoadedFontVec_fromItem(item.release()));
}

inline LoadedFontVec LoadedFontVec::copy_from_ptr(const LoadedFont& ptr, size_t len) {
    return LoadedFontVec(AzLoadedFontVec_copyFromPtr(ptr.ptr(), len));
}

inline LoadedFontVecSlice LoadedFontVec::as_c_slice() const {
    return LoadedFontVecSlice(AzLoadedFontVec_asCSlice(&inner_));
}

inline LoadedFontVecSlice LoadedFontVec::as_c_slice_range(size_t start, size_t end) const {
    return LoadedFontVecSlice(AzLoadedFontVec_asCSliceRange(&inner_, start, end));
}

inline void LoadedFontVec::delete_() {
    AzLoadedFontVec_delete(&inner_);
}

inline LoadedFontVec LoadedFontVec::clone() const {
    return LoadedFontVec(AzLoadedFontVec_clone(&inner_));
}

inline bool LoadedFontVec::partialEq(const LoadedFontVec& b) const {
    return AzLoadedFontVec_partialEq(&inner_, b.ptr());
}

inline uint64_t LoadedFontVec::hash() const {
    return AzLoadedFontVec_hash(&inner_);
}

inline uint8_t LoadedFontVec::partialCmp(const LoadedFontVec& b) const {
    return AzLoadedFontVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t LoadedFontVec::cmp(const LoadedFontVec& b) const {
    return AzLoadedFontVec_cmp(&inner_, b.ptr());
}

inline String LoadedFontVec::toDbgString() const {
    return String(AzLoadedFontVec_toDbgString(&inner_));
}

inline SvgRenderOptions SvgRenderOptions::default_() {
    return SvgRenderOptions(AzSvgRenderOptions_default());
}

inline bool SvgRenderOptions::partialEq(const SvgRenderOptions& b) const {
    return AzSvgRenderOptions_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgRenderOptions::partialCmp(const SvgRenderOptions& b) const {
    return AzSvgRenderOptions_partialCmp(&inner_, b.ptr());
}

inline String SvgRenderOptions::toDbgString() const {
    return String(AzSvgRenderOptions_toDbgString(&inner_));
}

inline IconStyleOptions IconStyleOptions::default_() {
    return IconStyleOptions(AzIconStyleOptions_default());
}

inline void IconStyleOptions::delete_() {
    AzIconStyleOptions_delete(&inner_);
}

inline IconStyleOptions IconStyleOptions::clone() const {
    return IconStyleOptions(AzIconStyleOptions_clone(&inner_));
}

inline bool IconStyleOptions::partialEq(const IconStyleOptions& b) const {
    return AzIconStyleOptions_partialEq(&inner_, b.ptr());
}

inline String IconStyleOptions::toDbgString() const {
    return String(AzIconStyleOptions_toDbgString(&inner_));
}

inline void TaskBarIcon::delete_() {
    AzTaskBarIcon_delete(&inner_);
}

inline TaskBarIcon TaskBarIcon::clone() const {
    return TaskBarIcon(AzTaskBarIcon_clone(&inner_));
}

inline bool TaskBarIcon::partialEq(const TaskBarIcon& b) const {
    return AzTaskBarIcon_partialEq(&inner_, b.ptr());
}

inline uint64_t TaskBarIcon::hash() const {
    return AzTaskBarIcon_hash(&inner_);
}

inline uint8_t TaskBarIcon::partialCmp(const TaskBarIcon& b) const {
    return AzTaskBarIcon_partialCmp(&inner_, b.ptr());
}

inline uint8_t TaskBarIcon::cmp(const TaskBarIcon& b) const {
    return AzTaskBarIcon_cmp(&inner_, b.ptr());
}

inline String TaskBarIcon::toDbgString() const {
    return String(AzTaskBarIcon_toDbgString(&inner_));
}

inline void SmallWindowIconBytes::delete_() {
    AzSmallWindowIconBytes_delete(&inner_);
}

inline SmallWindowIconBytes SmallWindowIconBytes::clone() const {
    return SmallWindowIconBytes(AzSmallWindowIconBytes_clone(&inner_));
}

inline String SmallWindowIconBytes::toDbgString() const {
    return String(AzSmallWindowIconBytes_toDbgString(&inner_));
}

inline void LargeWindowIconBytes::delete_() {
    AzLargeWindowIconBytes_delete(&inner_);
}

inline LargeWindowIconBytes LargeWindowIconBytes::clone() const {
    return LargeWindowIconBytes(AzLargeWindowIconBytes_clone(&inner_));
}

inline String LargeWindowIconBytes::toDbgString() const {
    return String(AzLargeWindowIconBytes_toDbgString(&inner_));
}

inline OptionRefAny VirtualViewCallbackInfo::get_ctx() const {
    return OptionRefAny(AzVirtualViewCallbackInfo_getCtx(&inner_));
}

inline HidpiAdjustedBounds VirtualViewCallbackInfo::get_bounds() const {
    return HidpiAdjustedBounds(AzVirtualViewCallbackInfo_getBounds(&inner_));
}

inline void VirtualViewCallbackInfo::delete_() {
    AzVirtualViewCallbackInfo_delete(&inner_);
}

inline VirtualViewCallbackInfo VirtualViewCallbackInfo::clone() const {
    return VirtualViewCallbackInfo(AzVirtualViewCallbackInfo_clone(&inner_));
}

inline String VirtualViewCallbackInfo::toDbgString() const {
    return String(AzVirtualViewCallbackInfo_toDbgString(&inner_));
}

inline LayoutCallback LayoutCallback::create(AzLayoutCallbackType cb) {
    return LayoutCallback(AzLayoutCallback_create(cb));
}

inline LayoutCallback LayoutCallback::default_() {
    return LayoutCallback(AzLayoutCallback_default());
}

inline void LayoutCallback::delete_() {
    AzLayoutCallback_delete(&inner_);
}

inline LayoutCallback LayoutCallback::clone() const {
    return LayoutCallback(AzLayoutCallback_clone(&inner_));
}

inline bool LayoutCallback::partialEq(const LayoutCallback& b) const {
    return AzLayoutCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t LayoutCallback::hash() const {
    return AzLayoutCallback_hash(&inner_);
}

inline uint8_t LayoutCallback::partialCmp(const LayoutCallback& b) const {
    return AzLayoutCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t LayoutCallback::cmp(const LayoutCallback& b) const {
    return AzLayoutCallback_cmp(&inner_, b.ptr());
}

inline String LayoutCallback::toDbgString() const {
    return String(AzLayoutCallback_toDbgString(&inner_));
}

inline AzRelayoutReason LayoutCallbackInfo::relayout_reason() const {
    return AzLayoutCallbackInfo_relayoutReason(&inner_);
}

inline OptionRefAny LayoutCallbackInfo::get_ctx() const {
    return OptionRefAny(AzLayoutCallbackInfo_getCtx(&inner_));
}

inline OptionGlContextPtr LayoutCallbackInfo::get_gl_context() const {
    return OptionGlContextPtr(AzLayoutCallbackInfo_getGlContext(&inner_));
}

inline bool LayoutCallbackInfo::window_width_less_than(float px) const {
    return AzLayoutCallbackInfo_windowWidthLessThan(&inner_, px);
}

inline bool LayoutCallbackInfo::window_width_greater_than(float px) const {
    return AzLayoutCallbackInfo_windowWidthGreaterThan(&inner_, px);
}

inline bool LayoutCallbackInfo::window_width_between(float min_px, float max_px) const {
    return AzLayoutCallbackInfo_windowWidthBetween(&inner_, min_px, max_px);
}

inline bool LayoutCallbackInfo::window_height_less_than(float px) const {
    return AzLayoutCallbackInfo_windowHeightLessThan(&inner_, px);
}

inline bool LayoutCallbackInfo::window_height_greater_than(float px) const {
    return AzLayoutCallbackInfo_windowHeightGreaterThan(&inner_, px);
}

inline bool LayoutCallbackInfo::window_height_between(float min_px, float max_px) const {
    return AzLayoutCallbackInfo_windowHeightBetween(&inner_, min_px, max_px);
}

inline float LayoutCallbackInfo::get_window_width() const {
    return AzLayoutCallbackInfo_getWindowWidth(&inner_);
}

inline float LayoutCallbackInfo::get_window_height() const {
    return AzLayoutCallbackInfo_getWindowHeight(&inner_);
}

inline float LayoutCallbackInfo::get_dpi_factor() const {
    return AzLayoutCallbackInfo_getDpiFactor(&inner_);
}

inline void LayoutCallbackInfo::delete_() {
    AzLayoutCallbackInfo_delete(&inner_);
}

inline LayoutCallbackInfo LayoutCallbackInfo::clone() const {
    return LayoutCallbackInfo(AzLayoutCallbackInfo_clone(&inner_));
}

inline String LayoutCallbackInfo::toDbgString() const {
    return String(AzLayoutCallbackInfo_toDbgString(&inner_));
}

inline void TimerCallback::delete_() {
    AzTimerCallback_delete(&inner_);
}

inline TimerCallback TimerCallback::clone() const {
    return TimerCallback(AzTimerCallback_clone(&inner_));
}

inline bool TimerCallback::partialEq(const TimerCallback& b) const {
    return AzTimerCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t TimerCallback::hash() const {
    return AzTimerCallback_hash(&inner_);
}

inline uint8_t TimerCallback::partialCmp(const TimerCallback& b) const {
    return AzTimerCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t TimerCallback::cmp(const TimerCallback& b) const {
    return AzTimerCallback_cmp(&inner_, b.ptr());
}

inline String TimerCallback::toDbgString() const {
    return String(AzTimerCallback_toDbgString(&inner_));
}

inline void WriteBackCallback::delete_() {
    AzWriteBackCallback_delete(&inner_);
}

inline WriteBackCallback WriteBackCallback::clone() const {
    return WriteBackCallback(AzWriteBackCallback_clone(&inner_));
}

inline bool WriteBackCallback::partialEq(const WriteBackCallback& b) const {
    return AzWriteBackCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t WriteBackCallback::hash() const {
    return AzWriteBackCallback_hash(&inner_);
}

inline uint8_t WriteBackCallback::partialCmp(const WriteBackCallback& b) const {
    return AzWriteBackCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t WriteBackCallback::cmp(const WriteBackCallback& b) const {
    return AzWriteBackCallback_cmp(&inner_, b.ptr());
}

inline String WriteBackCallback::toDbgString() const {
    return String(AzWriteBackCallback_toDbgString(&inner_));
}

inline void ThreadCallback::delete_() {
    AzThreadCallback_delete(&inner_);
}

inline ThreadCallback ThreadCallback::clone() const {
    return ThreadCallback(AzThreadCallback_clone(&inner_));
}

inline bool ThreadCallback::partialEq(const ThreadCallback& b) const {
    return AzThreadCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t ThreadCallback::hash() const {
    return AzThreadCallback_hash(&inner_);
}

inline uint8_t ThreadCallback::partialCmp(const ThreadCallback& b) const {
    return AzThreadCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t ThreadCallback::cmp(const ThreadCallback& b) const {
    return AzThreadCallback_cmp(&inner_, b.ptr());
}

inline String ThreadCallback::toDbgString() const {
    return String(AzThreadCallback_toDbgString(&inner_));
}

inline HidpiAdjustedBounds RenderImageCallbackInfo::get_bounds() const {
    return HidpiAdjustedBounds(AzRenderImageCallbackInfo_getBounds(&inner_));
}

inline DomNodeId RenderImageCallbackInfo::get_callback_node_id() const {
    return DomNodeId(AzRenderImageCallbackInfo_getCallbackNodeId(&inner_));
}

inline OptionGlContextPtr RenderImageCallbackInfo::get_gl_context() const {
    return OptionGlContextPtr(AzRenderImageCallbackInfo_getGlContext(&inner_));
}

inline OptionRefAny RenderImageCallbackInfo::get_ctx() const {
    return OptionRefAny(AzRenderImageCallbackInfo_getCtx(&inner_));
}

inline void RenderImageCallbackInfo::delete_() {
    AzRenderImageCallbackInfo_delete(&inner_);
}

inline RenderImageCallbackInfo RenderImageCallbackInfo::clone() const {
    return RenderImageCallbackInfo(AzRenderImageCallbackInfo_clone(&inner_));
}

inline String RenderImageCallbackInfo::toDbgString() const {
    return String(AzRenderImageCallbackInfo_toDbgString(&inner_));
}

inline void ListViewOnColumnClickCallback::delete_() {
    AzListViewOnColumnClickCallback_delete(&inner_);
}

inline ListViewOnColumnClickCallback ListViewOnColumnClickCallback::clone() const {
    return ListViewOnColumnClickCallback(AzListViewOnColumnClickCallback_clone(&inner_));
}

inline bool ListViewOnColumnClickCallback::partialEq(const ListViewOnColumnClickCallback& b) const {
    return AzListViewOnColumnClickCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t ListViewOnColumnClickCallback::hash() const {
    return AzListViewOnColumnClickCallback_hash(&inner_);
}

inline uint8_t ListViewOnColumnClickCallback::partialCmp(const ListViewOnColumnClickCallback& b) const {
    return AzListViewOnColumnClickCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t ListViewOnColumnClickCallback::cmp(const ListViewOnColumnClickCallback& b) const {
    return AzListViewOnColumnClickCallback_cmp(&inner_, b.ptr());
}

inline String ListViewOnColumnClickCallback::toDbgString() const {
    return String(AzListViewOnColumnClickCallback_toDbgString(&inner_));
}

inline void CoreCallback::delete_() {
    AzCoreCallback_delete(&inner_);
}

inline CoreCallback CoreCallback::clone() const {
    return CoreCallback(AzCoreCallback_clone(&inner_));
}

inline bool CoreCallback::partialEq(const CoreCallback& b) const {
    return AzCoreCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t CoreCallback::hash() const {
    return AzCoreCallback_hash(&inner_);
}

inline uint8_t CoreCallback::partialCmp(const CoreCallback& b) const {
    return AzCoreCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t CoreCallback::cmp(const CoreCallback& b) const {
    return AzCoreCallback_cmp(&inner_, b.ptr());
}

inline String CoreCallback::toDbgString() const {
    return String(AzCoreCallback_toDbgString(&inner_));
}

inline void ListViewOnRowClickCallback::delete_() {
    AzListViewOnRowClickCallback_delete(&inner_);
}

inline ListViewOnRowClickCallback ListViewOnRowClickCallback::clone() const {
    return ListViewOnRowClickCallback(AzListViewOnRowClickCallback_clone(&inner_));
}

inline bool ListViewOnRowClickCallback::partialEq(const ListViewOnRowClickCallback& b) const {
    return AzListViewOnRowClickCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t ListViewOnRowClickCallback::hash() const {
    return AzListViewOnRowClickCallback_hash(&inner_);
}

inline uint8_t ListViewOnRowClickCallback::partialCmp(const ListViewOnRowClickCallback& b) const {
    return AzListViewOnRowClickCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t ListViewOnRowClickCallback::cmp(const ListViewOnRowClickCallback& b) const {
    return AzListViewOnRowClickCallback_cmp(&inner_, b.ptr());
}

inline String ListViewOnRowClickCallback::toDbgString() const {
    return String(AzListViewOnRowClickCallback_toDbgString(&inner_));
}

inline void CheckBoxOnToggleCallback::delete_() {
    AzCheckBoxOnToggleCallback_delete(&inner_);
}

inline CheckBoxOnToggleCallback CheckBoxOnToggleCallback::clone() const {
    return CheckBoxOnToggleCallback(AzCheckBoxOnToggleCallback_clone(&inner_));
}

inline bool CheckBoxOnToggleCallback::partialEq(const CheckBoxOnToggleCallback& b) const {
    return AzCheckBoxOnToggleCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t CheckBoxOnToggleCallback::hash() const {
    return AzCheckBoxOnToggleCallback_hash(&inner_);
}

inline uint8_t CheckBoxOnToggleCallback::partialCmp(const CheckBoxOnToggleCallback& b) const {
    return AzCheckBoxOnToggleCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t CheckBoxOnToggleCallback::cmp(const CheckBoxOnToggleCallback& b) const {
    return AzCheckBoxOnToggleCallback_cmp(&inner_, b.ptr());
}

inline String CheckBoxOnToggleCallback::toDbgString() const {
    return String(AzCheckBoxOnToggleCallback_toDbgString(&inner_));
}

inline void DropDownOnChoiceChangeCallback::delete_() {
    AzDropDownOnChoiceChangeCallback_delete(&inner_);
}

inline DropDownOnChoiceChangeCallback DropDownOnChoiceChangeCallback::clone() const {
    return DropDownOnChoiceChangeCallback(AzDropDownOnChoiceChangeCallback_clone(&inner_));
}

inline bool DropDownOnChoiceChangeCallback::partialEq(const DropDownOnChoiceChangeCallback& b) const {
    return AzDropDownOnChoiceChangeCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t DropDownOnChoiceChangeCallback::hash() const {
    return AzDropDownOnChoiceChangeCallback_hash(&inner_);
}

inline uint8_t DropDownOnChoiceChangeCallback::partialCmp(const DropDownOnChoiceChangeCallback& b) const {
    return AzDropDownOnChoiceChangeCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t DropDownOnChoiceChangeCallback::cmp(const DropDownOnChoiceChangeCallback& b) const {
    return AzDropDownOnChoiceChangeCallback_cmp(&inner_, b.ptr());
}

inline String DropDownOnChoiceChangeCallback::toDbgString() const {
    return String(AzDropDownOnChoiceChangeCallback_toDbgString(&inner_));
}

inline void TabOnClickCallback::delete_() {
    AzTabOnClickCallback_delete(&inner_);
}

inline TabOnClickCallback TabOnClickCallback::clone() const {
    return TabOnClickCallback(AzTabOnClickCallback_clone(&inner_));
}

inline bool TabOnClickCallback::partialEq(const TabOnClickCallback& b) const {
    return AzTabOnClickCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t TabOnClickCallback::hash() const {
    return AzTabOnClickCallback_hash(&inner_);
}

inline uint8_t TabOnClickCallback::partialCmp(const TabOnClickCallback& b) const {
    return AzTabOnClickCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t TabOnClickCallback::cmp(const TabOnClickCallback& b) const {
    return AzTabOnClickCallback_cmp(&inner_, b.ptr());
}

inline String TabOnClickCallback::toDbgString() const {
    return String(AzTabOnClickCallback_toDbgString(&inner_));
}

inline void ListViewOnLazyLoadScrollCallback::delete_() {
    AzListViewOnLazyLoadScrollCallback_delete(&inner_);
}

inline ListViewOnLazyLoadScrollCallback ListViewOnLazyLoadScrollCallback::clone() const {
    return ListViewOnLazyLoadScrollCallback(AzListViewOnLazyLoadScrollCallback_clone(&inner_));
}

inline bool ListViewOnLazyLoadScrollCallback::partialEq(const ListViewOnLazyLoadScrollCallback& b) const {
    return AzListViewOnLazyLoadScrollCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t ListViewOnLazyLoadScrollCallback::hash() const {
    return AzListViewOnLazyLoadScrollCallback_hash(&inner_);
}

inline uint8_t ListViewOnLazyLoadScrollCallback::partialCmp(const ListViewOnLazyLoadScrollCallback& b) const {
    return AzListViewOnLazyLoadScrollCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t ListViewOnLazyLoadScrollCallback::cmp(const ListViewOnLazyLoadScrollCallback& b) const {
    return AzListViewOnLazyLoadScrollCallback_cmp(&inner_, b.ptr());
}

inline String ListViewOnLazyLoadScrollCallback::toDbgString() const {
    return String(AzListViewOnLazyLoadScrollCallback_toDbgString(&inner_));
}

inline void ButtonOnClickCallback::delete_() {
    AzButtonOnClickCallback_delete(&inner_);
}

inline ButtonOnClickCallback ButtonOnClickCallback::clone() const {
    return ButtonOnClickCallback(AzButtonOnClickCallback_clone(&inner_));
}

inline bool ButtonOnClickCallback::partialEq(const ButtonOnClickCallback& b) const {
    return AzButtonOnClickCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t ButtonOnClickCallback::hash() const {
    return AzButtonOnClickCallback_hash(&inner_);
}

inline uint8_t ButtonOnClickCallback::partialCmp(const ButtonOnClickCallback& b) const {
    return AzButtonOnClickCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t ButtonOnClickCallback::cmp(const ButtonOnClickCallback& b) const {
    return AzButtonOnClickCallback_cmp(&inner_, b.ptr());
}

inline String ButtonOnClickCallback::toDbgString() const {
    return String(AzButtonOnClickCallback_toDbgString(&inner_));
}

inline XmlAttributeMap XmlAttributeMap::default_() {
    return XmlAttributeMap(AzXmlAttributeMap_default());
}

inline void XmlAttributeMap::delete_() {
    AzXmlAttributeMap_delete(&inner_);
}

inline XmlAttributeMap XmlAttributeMap::clone() const {
    return XmlAttributeMap(AzXmlAttributeMap_clone(&inner_));
}

inline bool XmlAttributeMap::partialEq(const XmlAttributeMap& b) const {
    return AzXmlAttributeMap_partialEq(&inner_, b.ptr());
}

inline uint64_t XmlAttributeMap::hash() const {
    return AzXmlAttributeMap_hash(&inner_);
}

inline uint8_t XmlAttributeMap::partialCmp(const XmlAttributeMap& b) const {
    return AzXmlAttributeMap_partialCmp(&inner_, b.ptr());
}

inline uint8_t XmlAttributeMap::cmp(const XmlAttributeMap& b) const {
    return AzXmlAttributeMap_cmp(&inner_, b.ptr());
}

inline String XmlAttributeMap::toDbgString() const {
    return String(AzXmlAttributeMap_toDbgString(&inner_));
}

inline Callback Callback::create(AzCallbackType cb) {
    return Callback(AzCallback_create(cb));
}

inline CoreCallback Callback::to_core() const {
    return CoreCallback(AzCallback_toCore(inner_));
}

inline void Callback::delete_() {
    AzCallback_delete(&inner_);
}

inline Callback Callback::clone() const {
    return Callback(AzCallback_clone(&inner_));
}

inline bool Callback::partialEq(const Callback& b) const {
    return AzCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t Callback::hash() const {
    return AzCallback_hash(&inner_);
}

inline uint8_t Callback::partialCmp(const Callback& b) const {
    return AzCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t Callback::cmp(const Callback& b) const {
    return AzCallback_cmp(&inner_, b.ptr());
}

inline String Callback::toDbgString() const {
    return String(AzCallback_toDbgString(&inner_));
}

inline KeyboardState KeyboardState::default_() {
    return KeyboardState(AzKeyboardState_default());
}

inline void KeyboardState::delete_() {
    AzKeyboardState_delete(&inner_);
}

inline KeyboardState KeyboardState::clone() const {
    return KeyboardState(AzKeyboardState_clone(&inner_));
}

inline bool KeyboardState::partialEq(const KeyboardState& b) const {
    return AzKeyboardState_partialEq(&inner_, b.ptr());
}

inline String KeyboardState::toDbgString() const {
    return String(AzKeyboardState_toDbgString(&inner_));
}

inline TouchState TouchState::default_() {
    return TouchState(AzTouchState_default());
}

inline void TouchState::delete_() {
    AzTouchState_delete(&inner_);
}

inline TouchState TouchState::clone() const {
    return TouchState(AzTouchState_clone(&inner_));
}

inline bool TouchState::partialEq(const TouchState& b) const {
    return AzTouchState_partialEq(&inner_, b.ptr());
}

inline String TouchState::toDbgString() const {
    return String(AzTouchState_toDbgString(&inner_));
}

inline void CoreRenderImageCallback::delete_() {
    AzCoreRenderImageCallback_delete(&inner_);
}

inline CoreRenderImageCallback CoreRenderImageCallback::clone() const {
    return CoreRenderImageCallback(AzCoreRenderImageCallback_clone(&inner_));
}

inline bool CoreRenderImageCallback::partialEq(const CoreRenderImageCallback& b) const {
    return AzCoreRenderImageCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t CoreRenderImageCallback::hash() const {
    return AzCoreRenderImageCallback_hash(&inner_);
}

inline uint8_t CoreRenderImageCallback::partialCmp(const CoreRenderImageCallback& b) const {
    return AzCoreRenderImageCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t CoreRenderImageCallback::cmp(const CoreRenderImageCallback& b) const {
    return AzCoreRenderImageCallback_cmp(&inner_, b.ptr());
}

inline String CoreRenderImageCallback::toDbgString() const {
    return String(AzCoreRenderImageCallback_toDbgString(&inner_));
}

inline void VirtualKeyCodeCombo::delete_() {
    AzVirtualKeyCodeCombo_delete(&inner_);
}

inline VirtualKeyCodeCombo VirtualKeyCodeCombo::clone() const {
    return VirtualKeyCodeCombo(AzVirtualKeyCodeCombo_clone(&inner_));
}

inline bool VirtualKeyCodeCombo::partialEq(const VirtualKeyCodeCombo& b) const {
    return AzVirtualKeyCodeCombo_partialEq(&inner_, b.ptr());
}

inline uint64_t VirtualKeyCodeCombo::hash() const {
    return AzVirtualKeyCodeCombo_hash(&inner_);
}

inline uint8_t VirtualKeyCodeCombo::partialCmp(const VirtualKeyCodeCombo& b) const {
    return AzVirtualKeyCodeCombo_partialCmp(&inner_, b.ptr());
}

inline uint8_t VirtualKeyCodeCombo::cmp(const VirtualKeyCodeCombo& b) const {
    return AzVirtualKeyCodeCombo_cmp(&inner_, b.ptr());
}

inline String VirtualKeyCodeCombo::toDbgString() const {
    return String(AzVirtualKeyCodeCombo_toDbgString(&inner_));
}

inline void TextInputOnVirtualKeyDownCallback::delete_() {
    AzTextInputOnVirtualKeyDownCallback_delete(&inner_);
}

inline TextInputOnVirtualKeyDownCallback TextInputOnVirtualKeyDownCallback::clone() const {
    return TextInputOnVirtualKeyDownCallback(AzTextInputOnVirtualKeyDownCallback_clone(&inner_));
}

inline bool TextInputOnVirtualKeyDownCallback::partialEq(const TextInputOnVirtualKeyDownCallback& b) const {
    return AzTextInputOnVirtualKeyDownCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t TextInputOnVirtualKeyDownCallback::hash() const {
    return AzTextInputOnVirtualKeyDownCallback_hash(&inner_);
}

inline uint8_t TextInputOnVirtualKeyDownCallback::partialCmp(const TextInputOnVirtualKeyDownCallback& b) const {
    return AzTextInputOnVirtualKeyDownCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t TextInputOnVirtualKeyDownCallback::cmp(const TextInputOnVirtualKeyDownCallback& b) const {
    return AzTextInputOnVirtualKeyDownCallback_cmp(&inner_, b.ptr());
}

inline String TextInputOnVirtualKeyDownCallback::toDbgString() const {
    return String(AzTextInputOnVirtualKeyDownCallback_toDbgString(&inner_));
}

inline void SelectionState::delete_() {
    AzSelectionState_delete(&inner_);
}

inline SelectionState SelectionState::clone() const {
    return SelectionState(AzSelectionState_clone(&inner_));
}

inline bool SelectionState::partialEq(const SelectionState& b) const {
    return AzSelectionState_partialEq(&inner_, b.ptr());
}

inline String SelectionState::toDbgString() const {
    return String(AzSelectionState_toDbgString(&inner_));
}

inline void TextOpExtendSelection::delete_() {
    AzTextOpExtendSelection_delete(&inner_);
}

inline TextOpExtendSelection TextOpExtendSelection::clone() const {
    return TextOpExtendSelection(AzTextOpExtendSelection_clone(&inner_));
}

inline String TextOpExtendSelection::toDbgString() const {
    return String(AzTextOpExtendSelection_toDbgString(&inner_));
}

inline RenderImageCallback RenderImageCallback::create(AzRenderImageCallbackType cb) {
    return RenderImageCallback(AzRenderImageCallback_create(cb));
}

inline CoreRenderImageCallback RenderImageCallback::to_core() const {
    return CoreRenderImageCallback(AzRenderImageCallback_toCore(inner_));
}

inline void RenderImageCallback::delete_() {
    AzRenderImageCallback_delete(&inner_);
}

inline RenderImageCallback RenderImageCallback::clone() const {
    return RenderImageCallback(AzRenderImageCallback_clone(&inner_));
}

inline bool RenderImageCallback::partialEq(const RenderImageCallback& b) const {
    return AzRenderImageCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t RenderImageCallback::hash() const {
    return AzRenderImageCallback_hash(&inner_);
}

inline uint8_t RenderImageCallback::partialCmp(const RenderImageCallback& b) const {
    return AzRenderImageCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t RenderImageCallback::cmp(const RenderImageCallback& b) const {
    return AzRenderImageCallback_cmp(&inner_, b.ptr());
}

inline String RenderImageCallback::toDbgString() const {
    return String(AzRenderImageCallback_toDbgString(&inner_));
}

inline void TextOpClearSelection::delete_() {
    AzTextOpClearSelection_delete(&inner_);
}

inline TextOpClearSelection TextOpClearSelection::clone() const {
    return TextOpClearSelection(AzTextOpClearSelection_clone(&inner_));
}

inline String TextOpClearSelection::toDbgString() const {
    return String(AzTextOpClearSelection_toDbgString(&inner_));
}

inline DatasetMergeCallback DatasetMergeCallback::from(AzDatasetMergeCallbackType cb) {
    return DatasetMergeCallback(AzDatasetMergeCallback_from(cb));
}

inline void DatasetMergeCallback::delete_() {
    AzDatasetMergeCallback_delete(&inner_);
}

inline DatasetMergeCallback DatasetMergeCallback::clone() const {
    return DatasetMergeCallback(AzDatasetMergeCallback_clone(&inner_));
}

inline bool DatasetMergeCallback::partialEq(const DatasetMergeCallback& b) const {
    return AzDatasetMergeCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t DatasetMergeCallback::hash() const {
    return AzDatasetMergeCallback_hash(&inner_);
}

inline uint8_t DatasetMergeCallback::partialCmp(const DatasetMergeCallback& b) const {
    return AzDatasetMergeCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t DatasetMergeCallback::cmp(const DatasetMergeCallback& b) const {
    return AzDatasetMergeCallback_cmp(&inner_, b.ptr());
}

inline String DatasetMergeCallback::toDbgString() const {
    return String(AzDatasetMergeCallback_toDbgString(&inner_));
}

inline FocusVisuals FocusVisuals::default_() {
    return FocusVisuals(AzFocusVisuals_default());
}

inline bool FocusVisuals::partialEq(const FocusVisuals& b) const {
    return AzFocusVisuals_partialEq(&inner_, b.ptr());
}

inline String FocusVisuals::toDbgString() const {
    return String(AzFocusVisuals_toDbgString(&inner_));
}

inline DragData DragData::new_() {
    return DragData(AzDragData_new());
}

inline DragData DragData::default_() {
    return DragData(AzDragData_default());
}

inline void DragData::set_data(String mime_type, U8Vec data) {
    AzDragData_setData(&inner_, mime_type.release(), data.release());
}

inline void DragData::delete_() {
    AzDragData_delete(&inner_);
}

inline DragData DragData::clone() const {
    return DragData(AzDragData_clone(&inner_));
}

inline bool DragData::partialEq(const DragData& b) const {
    return AzDragData_partialEq(&inner_, b.ptr());
}

inline String DragData::toDbgString() const {
    return String(AzDragData_toDbgString(&inner_));
}

inline void VirtualViewCallback::delete_() {
    AzVirtualViewCallback_delete(&inner_);
}

inline VirtualViewCallback VirtualViewCallback::clone() const {
    return VirtualViewCallback(AzVirtualViewCallback_clone(&inner_));
}

inline bool VirtualViewCallback::partialEq(const VirtualViewCallback& b) const {
    return AzVirtualViewCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t VirtualViewCallback::hash() const {
    return AzVirtualViewCallback_hash(&inner_);
}

inline uint8_t VirtualViewCallback::partialCmp(const VirtualViewCallback& b) const {
    return AzVirtualViewCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t VirtualViewCallback::cmp(const VirtualViewCallback& b) const {
    return AzVirtualViewCallback_cmp(&inner_, b.ptr());
}

inline String VirtualViewCallback::toDbgString() const {
    return String(AzVirtualViewCallback_toDbgString(&inner_));
}

inline void RibbonOnTabClickCallback::delete_() {
    AzRibbonOnTabClickCallback_delete(&inner_);
}

inline RibbonOnTabClickCallback RibbonOnTabClickCallback::clone() const {
    return RibbonOnTabClickCallback(AzRibbonOnTabClickCallback_clone(&inner_));
}

inline bool RibbonOnTabClickCallback::partialEq(const RibbonOnTabClickCallback& b) const {
    return AzRibbonOnTabClickCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t RibbonOnTabClickCallback::hash() const {
    return AzRibbonOnTabClickCallback_hash(&inner_);
}

inline uint8_t RibbonOnTabClickCallback::partialCmp(const RibbonOnTabClickCallback& b) const {
    return AzRibbonOnTabClickCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t RibbonOnTabClickCallback::cmp(const RibbonOnTabClickCallback& b) const {
    return AzRibbonOnTabClickCallback_cmp(&inner_, b.ptr());
}

inline String RibbonOnTabClickCallback::toDbgString() const {
    return String(AzRibbonOnTabClickCallback_toDbgString(&inner_));
}

inline void TreeViewOnNodeClickCallback::delete_() {
    AzTreeViewOnNodeClickCallback_delete(&inner_);
}

inline TreeViewOnNodeClickCallback TreeViewOnNodeClickCallback::clone() const {
    return TreeViewOnNodeClickCallback(AzTreeViewOnNodeClickCallback_clone(&inner_));
}

inline bool TreeViewOnNodeClickCallback::partialEq(const TreeViewOnNodeClickCallback& b) const {
    return AzTreeViewOnNodeClickCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t TreeViewOnNodeClickCallback::hash() const {
    return AzTreeViewOnNodeClickCallback_hash(&inner_);
}

inline uint8_t TreeViewOnNodeClickCallback::partialCmp(const TreeViewOnNodeClickCallback& b) const {
    return AzTreeViewOnNodeClickCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t TreeViewOnNodeClickCallback::cmp(const TreeViewOnNodeClickCallback& b) const {
    return AzTreeViewOnNodeClickCallback_cmp(&inner_, b.ptr());
}

inline String TreeViewOnNodeClickCallback::toDbgString() const {
    return String(AzTreeViewOnNodeClickCallback_toDbgString(&inner_));
}

inline void OnVideoFrameCallback::delete_() {
    AzOnVideoFrameCallback_delete(&inner_);
}

inline OnVideoFrameCallback OnVideoFrameCallback::clone() const {
    return OnVideoFrameCallback(AzOnVideoFrameCallback_clone(&inner_));
}

inline bool OnVideoFrameCallback::partialEq(const OnVideoFrameCallback& b) const {
    return AzOnVideoFrameCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t OnVideoFrameCallback::hash() const {
    return AzOnVideoFrameCallback_hash(&inner_);
}

inline uint8_t OnVideoFrameCallback::partialCmp(const OnVideoFrameCallback& b) const {
    return AzOnVideoFrameCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t OnVideoFrameCallback::cmp(const OnVideoFrameCallback& b) const {
    return AzOnVideoFrameCallback_cmp(&inner_, b.ptr());
}

inline String OnVideoFrameCallback::toDbgString() const {
    return String(AzOnVideoFrameCallback_toDbgString(&inner_));
}

inline void MapPinTapCallback::delete_() {
    AzMapPinTapCallback_delete(&inner_);
}

inline MapPinTapCallback MapPinTapCallback::clone() const {
    return MapPinTapCallback(AzMapPinTapCallback_clone(&inner_));
}

inline bool MapPinTapCallback::partialEq(const MapPinTapCallback& b) const {
    return AzMapPinTapCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t MapPinTapCallback::hash() const {
    return AzMapPinTapCallback_hash(&inner_);
}

inline uint8_t MapPinTapCallback::partialCmp(const MapPinTapCallback& b) const {
    return AzMapPinTapCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t MapPinTapCallback::cmp(const MapPinTapCallback& b) const {
    return AzMapPinTapCallback_cmp(&inner_, b.ptr());
}

inline String MapPinTapCallback::toDbgString() const {
    return String(AzMapPinTapCallback_toDbgString(&inner_));
}

inline void OnAudioFrameCallback::delete_() {
    AzOnAudioFrameCallback_delete(&inner_);
}

inline OnAudioFrameCallback OnAudioFrameCallback::clone() const {
    return OnAudioFrameCallback(AzOnAudioFrameCallback_clone(&inner_));
}

inline bool OnAudioFrameCallback::partialEq(const OnAudioFrameCallback& b) const {
    return AzOnAudioFrameCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t OnAudioFrameCallback::hash() const {
    return AzOnAudioFrameCallback_hash(&inner_);
}

inline uint8_t OnAudioFrameCallback::partialCmp(const OnAudioFrameCallback& b) const {
    return AzOnAudioFrameCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t OnAudioFrameCallback::cmp(const OnAudioFrameCallback& b) const {
    return AzOnAudioFrameCallback_cmp(&inner_, b.ptr());
}

inline String OnAudioFrameCallback::toDbgString() const {
    return String(AzOnAudioFrameCallback_toDbgString(&inner_));
}

inline Menu Menu::create(MenuItemVec items) {
    return Menu(AzMenu_create(items.release()));
}

inline Menu Menu::default_() {
    return Menu(AzMenu_default());
}

inline void Menu::set_popup_position(AzMenuPopupPosition position) {
    AzMenu_setPopupPosition(&inner_, position);
}

inline Menu Menu::with_popup_position(AzMenuPopupPosition position) const {
    return Menu(AzMenu_withPopupPosition(inner_, position));
}

inline void Menu::delete_() {
    AzMenu_delete(&inner_);
}

inline Menu Menu::clone() const {
    return Menu(AzMenu_clone(&inner_));
}

inline bool Menu::partialEq(const Menu& b) const {
    return AzMenu_partialEq(&inner_, b.ptr());
}

inline uint64_t Menu::hash() const {
    return AzMenu_hash(&inner_);
}

inline uint8_t Menu::partialCmp(const Menu& b) const {
    return AzMenu_partialCmp(&inner_, b.ptr());
}

inline uint8_t Menu::cmp(const Menu& b) const {
    return AzMenu_cmp(&inner_, b.ptr());
}

inline String Menu::toDbgString() const {
    return String(AzMenu_toDbgString(&inner_));
}

inline Css Css::empty() {
    return Css(AzCss_empty());
}

inline Css Css::from_string(String s) {
    return Css(AzCss_fromString(s.release()));
}

inline Css Css::default_() {
    return Css(AzCss_default());
}

inline bool Css::is_empty() const {
    return AzCss_isEmpty(&inner_);
}

inline void Css::sort_by_specificity() {
    AzCss_sortBySpecificity(&inner_);
}

inline void Css::delete_() {
    AzCss_delete(&inner_);
}

inline Css Css::clone() const {
    return Css(AzCss_clone(&inner_));
}

inline bool Css::partialEq(const Css& b) const {
    return AzCss_partialEq(&inner_, b.ptr());
}

inline uint8_t Css::partialCmp(const Css& b) const {
    return AzCss_partialCmp(&inner_, b.ptr());
}

inline uint8_t Css::cmp(const Css& b) const {
    return AzCss_cmp(&inner_, b.ptr());
}

inline String Css::toDbgString() const {
    return String(AzCss_toDbgString(&inner_));
}

inline StyleBoxShadow StyleBoxShadow::default_() {
    return StyleBoxShadow(AzStyleBoxShadow_default());
}

inline bool StyleBoxShadow::partialEq(const StyleBoxShadow& b) const {
    return AzStyleBoxShadow_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBoxShadow::hash() const {
    return AzStyleBoxShadow_hash(&inner_);
}

inline uint8_t StyleBoxShadow::partialCmp(const StyleBoxShadow& b) const {
    return AzStyleBoxShadow_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBoxShadow::cmp(const StyleBoxShadow& b) const {
    return AzStyleBoxShadow_cmp(&inner_, b.ptr());
}

inline String StyleBoxShadow::toDbgString() const {
    return String(AzStyleBoxShadow_toDbgString(&inner_));
}

inline LinearGradient LinearGradient::default_() {
    return LinearGradient(AzLinearGradient_default());
}

inline void LinearGradient::delete_() {
    AzLinearGradient_delete(&inner_);
}

inline LinearGradient LinearGradient::clone() const {
    return LinearGradient(AzLinearGradient_clone(&inner_));
}

inline bool LinearGradient::partialEq(const LinearGradient& b) const {
    return AzLinearGradient_partialEq(&inner_, b.ptr());
}

inline uint64_t LinearGradient::hash() const {
    return AzLinearGradient_hash(&inner_);
}

inline uint8_t LinearGradient::partialCmp(const LinearGradient& b) const {
    return AzLinearGradient_partialCmp(&inner_, b.ptr());
}

inline uint8_t LinearGradient::cmp(const LinearGradient& b) const {
    return AzLinearGradient_cmp(&inner_, b.ptr());
}

inline String LinearGradient::toDbgString() const {
    return String(AzLinearGradient_toDbgString(&inner_));
}

inline StyleBackgroundPosition StyleBackgroundPosition::default_() {
    return StyleBackgroundPosition(AzStyleBackgroundPosition_default());
}

inline bool StyleBackgroundPosition::partialEq(const StyleBackgroundPosition& b) const {
    return AzStyleBackgroundPosition_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleBackgroundPosition::hash() const {
    return AzStyleBackgroundPosition_hash(&inner_);
}

inline uint8_t StyleBackgroundPosition::partialCmp(const StyleBackgroundPosition& b) const {
    return AzStyleBackgroundPosition_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleBackgroundPosition::cmp(const StyleBackgroundPosition& b) const {
    return AzStyleBackgroundPosition_cmp(&inner_, b.ptr());
}

inline String StyleBackgroundPosition::toDbgString() const {
    return String(AzStyleBackgroundPosition_toDbgString(&inner_));
}

inline GridTemplate GridTemplate::default_() {
    return GridTemplate(AzGridTemplate_default());
}

inline void GridTemplate::delete_() {
    AzGridTemplate_delete(&inner_);
}

inline GridTemplate GridTemplate::clone() const {
    return GridTemplate(AzGridTemplate_clone(&inner_));
}

inline bool GridTemplate::partialEq(const GridTemplate& b) const {
    return AzGridTemplate_partialEq(&inner_, b.ptr());
}

inline uint64_t GridTemplate::hash() const {
    return AzGridTemplate_hash(&inner_);
}

inline uint8_t GridTemplate::partialCmp(const GridTemplate& b) const {
    return AzGridTemplate_partialCmp(&inner_, b.ptr());
}

inline uint8_t GridTemplate::cmp(const GridTemplate& b) const {
    return AzGridTemplate_cmp(&inner_, b.ptr());
}

inline String GridTemplate::toDbgString() const {
    return String(AzGridTemplate_toDbgString(&inner_));
}

inline GridAutoTracks GridAutoTracks::default_() {
    return GridAutoTracks(AzGridAutoTracks_default());
}

inline void GridAutoTracks::delete_() {
    AzGridAutoTracks_delete(&inner_);
}

inline GridAutoTracks GridAutoTracks::clone() const {
    return GridAutoTracks(AzGridAutoTracks_clone(&inner_));
}

inline bool GridAutoTracks::partialEq(const GridAutoTracks& b) const {
    return AzGridAutoTracks_partialEq(&inner_, b.ptr());
}

inline uint64_t GridAutoTracks::hash() const {
    return AzGridAutoTracks_hash(&inner_);
}

inline uint8_t GridAutoTracks::partialCmp(const GridAutoTracks& b) const {
    return AzGridAutoTracks_partialCmp(&inner_, b.ptr());
}

inline uint8_t GridAutoTracks::cmp(const GridAutoTracks& b) const {
    return AzGridAutoTracks_cmp(&inner_, b.ptr());
}

inline String GridAutoTracks::toDbgString() const {
    return String(AzGridAutoTracks_toDbgString(&inner_));
}

inline StyledDom StyledDom::default_() {
    return StyledDom(AzStyledDom_default());
}

inline void StyledDom::append_child(StyledDom other) {
    AzStyledDom_appendChild(&inner_, other.release());
}

inline StyledDom StyledDom::with_child(StyledDom other) const {
    return StyledDom(AzStyledDom_withChild(inner_, other.release()));
}

inline size_t StyledDom::node_count() const {
    return AzStyledDom_nodeCount(&inner_);
}

inline void StyledDom::set_menu_bar(Menu menu_bar) {
    AzStyledDom_setMenuBar(&inner_, menu_bar.release());
}

inline StyledDom StyledDom::with_menu_bar(Menu menu_bar) const {
    return StyledDom(AzStyledDom_withMenuBar(inner_, menu_bar.release()));
}

inline void StyledDom::set_context_menu(Menu context_menu) {
    AzStyledDom_setContextMenu(&inner_, context_menu.release());
}

inline StyledDom StyledDom::with_context_menu(Menu context_menu) const {
    return StyledDom(AzStyledDom_withContextMenu(inner_, context_menu.release()));
}

inline ContentGroup StyledDom::get_rects_in_rendering_order() const {
    return ContentGroup(AzStyledDom_getRectsInRenderingOrder(&inner_));
}

inline StyledDom StyledDom::swap_with_default() {
    return StyledDom(AzStyledDom_swapWithDefault(&inner_));
}

inline void StyledDom::delete_() {
    AzStyledDom_delete(&inner_);
}

inline StyledDom StyledDom::clone() const {
    return StyledDom(AzStyledDom_clone(&inner_));
}

inline bool StyledDom::partialEq(const StyledDom& b) const {
    return AzStyledDom_partialEq(&inner_, b.ptr());
}

inline String StyledDom::toDbgString() const {
    return String(AzStyledDom_toDbgString(&inner_));
}

inline void VertexLayout::delete_() {
    AzVertexLayout_delete(&inner_);
}

inline VertexLayout VertexLayout::clone() const {
    return VertexLayout(AzVertexLayout_clone(&inner_));
}

inline bool VertexLayout::partialEq(const VertexLayout& b) const {
    return AzVertexLayout_partialEq(&inner_, b.ptr());
}

inline uint64_t VertexLayout::hash() const {
    return AzVertexLayout_hash(&inner_);
}

inline uint8_t VertexLayout::partialCmp(const VertexLayout& b) const {
    return AzVertexLayout_partialCmp(&inner_, b.ptr());
}

inline uint8_t VertexLayout::cmp(const VertexLayout& b) const {
    return AzVertexLayout_cmp(&inner_, b.ptr());
}

inline String VertexLayout::toDbgString() const {
    return String(AzVertexLayout_toDbgString(&inner_));
}

inline void ContentGroup::delete_() {
    AzContentGroup_delete(&inner_);
}

inline ContentGroup ContentGroup::clone() const {
    return ContentGroup(AzContentGroup_clone(&inner_));
}

inline bool ContentGroup::partialEq(const ContentGroup& b) const {
    return AzContentGroup_partialEq(&inner_, b.ptr());
}

inline uint8_t ContentGroup::partialCmp(const ContentGroup& b) const {
    return AzContentGroup_partialCmp(&inner_, b.ptr());
}

inline String ContentGroup::toDbgString() const {
    return String(AzContentGroup_toDbgString(&inner_));
}

inline SafeAreaInsets SafeAreaInsets::default_() {
    return SafeAreaInsets(AzSafeAreaInsets_default());
}

inline bool SafeAreaInsets::partialEq(const SafeAreaInsets& b) const {
    return AzSafeAreaInsets_partialEq(&inner_, b.ptr());
}

inline String SafeAreaInsets::toDbgString() const {
    return String(AzSafeAreaInsets_toDbgString(&inner_));
}

inline GridTemplateAreas GridTemplateAreas::default_() {
    return GridTemplateAreas(AzGridTemplateAreas_default());
}

inline void GridTemplateAreas::delete_() {
    AzGridTemplateAreas_delete(&inner_);
}

inline GridTemplateAreas GridTemplateAreas::clone() const {
    return GridTemplateAreas(AzGridTemplateAreas_clone(&inner_));
}

inline bool GridTemplateAreas::partialEq(const GridTemplateAreas& b) const {
    return AzGridTemplateAreas_partialEq(&inner_, b.ptr());
}

inline uint64_t GridTemplateAreas::hash() const {
    return AzGridTemplateAreas_hash(&inner_);
}

inline uint8_t GridTemplateAreas::partialCmp(const GridTemplateAreas& b) const {
    return AzGridTemplateAreas_partialCmp(&inner_, b.ptr());
}

inline uint8_t GridTemplateAreas::cmp(const GridTemplateAreas& b) const {
    return AzGridTemplateAreas_cmp(&inner_, b.ptr());
}

inline String GridTemplateAreas::toDbgString() const {
    return String(AzGridTemplateAreas_toDbgString(&inner_));
}

inline StyleObjectPosition StyleObjectPosition::default_() {
    return StyleObjectPosition(AzStyleObjectPosition_default());
}

inline bool StyleObjectPosition::partialEq(const StyleObjectPosition& b) const {
    return AzStyleObjectPosition_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleObjectPosition::hash() const {
    return AzStyleObjectPosition_hash(&inner_);
}

inline uint8_t StyleObjectPosition::partialCmp(const StyleObjectPosition& b) const {
    return AzStyleObjectPosition_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleObjectPosition::cmp(const StyleObjectPosition& b) const {
    return AzStyleObjectPosition_cmp(&inner_, b.ptr());
}

inline String StyleObjectPosition::toDbgString() const {
    return String(AzStyleObjectPosition_toDbgString(&inner_));
}

inline void FileInputOnPathChangeCallback::delete_() {
    AzFileInputOnPathChangeCallback_delete(&inner_);
}

inline FileInputOnPathChangeCallback FileInputOnPathChangeCallback::clone() const {
    return FileInputOnPathChangeCallback(AzFileInputOnPathChangeCallback_clone(&inner_));
}

inline bool FileInputOnPathChangeCallback::partialEq(const FileInputOnPathChangeCallback& b) const {
    return AzFileInputOnPathChangeCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t FileInputOnPathChangeCallback::hash() const {
    return AzFileInputOnPathChangeCallback_hash(&inner_);
}

inline uint8_t FileInputOnPathChangeCallback::partialCmp(const FileInputOnPathChangeCallback& b) const {
    return AzFileInputOnPathChangeCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t FileInputOnPathChangeCallback::cmp(const FileInputOnPathChangeCallback& b) const {
    return AzFileInputOnPathChangeCallback_cmp(&inner_, b.ptr());
}

inline String FileInputOnPathChangeCallback::toDbgString() const {
    return String(AzFileInputOnPathChangeCallback_toDbgString(&inner_));
}

inline void ColorInputOnValueChangeCallback::delete_() {
    AzColorInputOnValueChangeCallback_delete(&inner_);
}

inline ColorInputOnValueChangeCallback ColorInputOnValueChangeCallback::clone() const {
    return ColorInputOnValueChangeCallback(AzColorInputOnValueChangeCallback_clone(&inner_));
}

inline bool ColorInputOnValueChangeCallback::partialEq(const ColorInputOnValueChangeCallback& b) const {
    return AzColorInputOnValueChangeCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t ColorInputOnValueChangeCallback::hash() const {
    return AzColorInputOnValueChangeCallback_hash(&inner_);
}

inline uint8_t ColorInputOnValueChangeCallback::partialCmp(const ColorInputOnValueChangeCallback& b) const {
    return AzColorInputOnValueChangeCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t ColorInputOnValueChangeCallback::cmp(const ColorInputOnValueChangeCallback& b) const {
    return AzColorInputOnValueChangeCallback_cmp(&inner_, b.ptr());
}

inline String ColorInputOnValueChangeCallback::toDbgString() const {
    return String(AzColorInputOnValueChangeCallback_toDbgString(&inner_));
}

inline void TextInputOnTextInputCallback::delete_() {
    AzTextInputOnTextInputCallback_delete(&inner_);
}

inline TextInputOnTextInputCallback TextInputOnTextInputCallback::clone() const {
    return TextInputOnTextInputCallback(AzTextInputOnTextInputCallback_clone(&inner_));
}

inline bool TextInputOnTextInputCallback::partialEq(const TextInputOnTextInputCallback& b) const {
    return AzTextInputOnTextInputCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t TextInputOnTextInputCallback::hash() const {
    return AzTextInputOnTextInputCallback_hash(&inner_);
}

inline uint8_t TextInputOnTextInputCallback::partialCmp(const TextInputOnTextInputCallback& b) const {
    return AzTextInputOnTextInputCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t TextInputOnTextInputCallback::cmp(const TextInputOnTextInputCallback& b) const {
    return AzTextInputOnTextInputCallback_cmp(&inner_, b.ptr());
}

inline String TextInputOnTextInputCallback::toDbgString() const {
    return String(AzTextInputOnTextInputCallback_toDbgString(&inner_));
}

inline void TextInputOnFocusLostCallback::delete_() {
    AzTextInputOnFocusLostCallback_delete(&inner_);
}

inline TextInputOnFocusLostCallback TextInputOnFocusLostCallback::clone() const {
    return TextInputOnFocusLostCallback(AzTextInputOnFocusLostCallback_clone(&inner_));
}

inline bool TextInputOnFocusLostCallback::partialEq(const TextInputOnFocusLostCallback& b) const {
    return AzTextInputOnFocusLostCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t TextInputOnFocusLostCallback::hash() const {
    return AzTextInputOnFocusLostCallback_hash(&inner_);
}

inline uint8_t TextInputOnFocusLostCallback::partialCmp(const TextInputOnFocusLostCallback& b) const {
    return AzTextInputOnFocusLostCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t TextInputOnFocusLostCallback::cmp(const TextInputOnFocusLostCallback& b) const {
    return AzTextInputOnFocusLostCallback_cmp(&inner_, b.ptr());
}

inline String TextInputOnFocusLostCallback::toDbgString() const {
    return String(AzTextInputOnFocusLostCallback_toDbgString(&inner_));
}

inline void NumberInputOnValueChangeCallback::delete_() {
    AzNumberInputOnValueChangeCallback_delete(&inner_);
}

inline NumberInputOnValueChangeCallback NumberInputOnValueChangeCallback::clone() const {
    return NumberInputOnValueChangeCallback(AzNumberInputOnValueChangeCallback_clone(&inner_));
}

inline bool NumberInputOnValueChangeCallback::partialEq(const NumberInputOnValueChangeCallback& b) const {
    return AzNumberInputOnValueChangeCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t NumberInputOnValueChangeCallback::hash() const {
    return AzNumberInputOnValueChangeCallback_hash(&inner_);
}

inline uint8_t NumberInputOnValueChangeCallback::partialCmp(const NumberInputOnValueChangeCallback& b) const {
    return AzNumberInputOnValueChangeCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t NumberInputOnValueChangeCallback::cmp(const NumberInputOnValueChangeCallback& b) const {
    return AzNumberInputOnValueChangeCallback_cmp(&inner_, b.ptr());
}

inline String NumberInputOnValueChangeCallback::toDbgString() const {
    return String(AzNumberInputOnValueChangeCallback_toDbgString(&inner_));
}

inline void NumberInputOnFocusLostCallback::delete_() {
    AzNumberInputOnFocusLostCallback_delete(&inner_);
}

inline NumberInputOnFocusLostCallback NumberInputOnFocusLostCallback::clone() const {
    return NumberInputOnFocusLostCallback(AzNumberInputOnFocusLostCallback_clone(&inner_));
}

inline bool NumberInputOnFocusLostCallback::partialEq(const NumberInputOnFocusLostCallback& b) const {
    return AzNumberInputOnFocusLostCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t NumberInputOnFocusLostCallback::hash() const {
    return AzNumberInputOnFocusLostCallback_hash(&inner_);
}

inline uint8_t NumberInputOnFocusLostCallback::partialCmp(const NumberInputOnFocusLostCallback& b) const {
    return AzNumberInputOnFocusLostCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t NumberInputOnFocusLostCallback::cmp(const NumberInputOnFocusLostCallback& b) const {
    return AzNumberInputOnFocusLostCallback_cmp(&inner_, b.ptr());
}

inline String NumberInputOnFocusLostCallback::toDbgString() const {
    return String(AzNumberInputOnFocusLostCallback_toDbgString(&inner_));
}

inline ProgressBar ProgressBar::create(float percent_done) {
    return ProgressBar(AzProgressBar_create(percent_done));
}

inline void ProgressBar::set_height(PixelValue height) {
    AzProgressBar_setHeight(&inner_, height.release());
}

inline ProgressBar ProgressBar::with_height(PixelValue height) const {
    return ProgressBar(AzProgressBar_withHeight(inner_, height.release()));
}

inline void ProgressBar::set_container_background(StyleBackgroundContentVec background) {
    AzProgressBar_setContainerBackground(&inner_, background.release());
}

inline ProgressBar ProgressBar::with_container_style(StyleBackgroundContentVec background) const {
    return ProgressBar(AzProgressBar_withContainerStyle(inner_, background.release()));
}

inline void ProgressBar::set_bar_background(StyleBackgroundContentVec background) {
    AzProgressBar_setBarBackground(&inner_, background.release());
}

inline ProgressBar ProgressBar::with_bar_background(StyleBackgroundContentVec background) const {
    return ProgressBar(AzProgressBar_withBarBackground(inner_, background.release()));
}

inline Dom ProgressBar::dom() const {
    return Dom(AzProgressBar_dom(inner_));
}

inline void ProgressBar::delete_() {
    AzProgressBar_delete(&inner_);
}

inline ProgressBar ProgressBar::clone() const {
    return ProgressBar(AzProgressBar_clone(&inner_));
}

inline String ProgressBar::toDbgString() const {
    return String(AzProgressBar_toDbgString(&inner_));
}

inline void ListViewState::delete_() {
    AzListViewState_delete(&inner_);
}

inline ListViewState ListViewState::clone() const {
    return ListViewState(AzListViewState_clone(&inner_));
}

inline String ListViewState::toDbgString() const {
    return String(AzListViewState_toDbgString(&inner_));
}

inline void VideoFrame::delete_() {
    AzVideoFrame_delete(&inner_);
}

inline VideoFrame VideoFrame::clone() const {
    return VideoFrame(AzVideoFrame_clone(&inner_));
}

inline bool VideoFrame::partialEq(const VideoFrame& b) const {
    return AzVideoFrame_partialEq(&inner_, b.ptr());
}

inline String VideoFrame::toDbgString() const {
    return String(AzVideoFrame_toDbgString(&inner_));
}

inline void MapViewportChangedCallback::delete_() {
    AzMapViewportChangedCallback_delete(&inner_);
}

inline MapViewportChangedCallback MapViewportChangedCallback::clone() const {
    return MapViewportChangedCallback(AzMapViewportChangedCallback_clone(&inner_));
}

inline bool MapViewportChangedCallback::partialEq(const MapViewportChangedCallback& b) const {
    return AzMapViewportChangedCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t MapViewportChangedCallback::hash() const {
    return AzMapViewportChangedCallback_hash(&inner_);
}

inline uint8_t MapViewportChangedCallback::partialCmp(const MapViewportChangedCallback& b) const {
    return AzMapViewportChangedCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t MapViewportChangedCallback::cmp(const MapViewportChangedCallback& b) const {
    return AzMapViewportChangedCallback_cmp(&inner_, b.ptr());
}

inline String MapViewportChangedCallback::toDbgString() const {
    return String(AzMapViewportChangedCallback_toDbgString(&inner_));
}

inline size_t AudioFrame::frame_count() const {
    return AzAudioFrame_frameCount(&inner_);
}

inline void AudioFrame::delete_() {
    AzAudioFrame_delete(&inner_);
}

inline AudioFrame AudioFrame::clone() const {
    return AudioFrame(AzAudioFrame_clone(&inner_));
}

inline bool AudioFrame::partialEq(const AudioFrame& b) const {
    return AzAudioFrame_partialEq(&inner_, b.ptr());
}

inline String AudioFrame::toDbgString() const {
    return String(AzAudioFrame_toDbgString(&inner_));
}

inline void GetProgramBinaryReturn::delete_() {
    AzGetProgramBinaryReturn_delete(&inner_);
}

inline GetProgramBinaryReturn GetProgramBinaryReturn::clone() const {
    return GetProgramBinaryReturn(AzGetProgramBinaryReturn_clone(&inner_));
}

inline bool GetProgramBinaryReturn::partialEq(const GetProgramBinaryReturn& b) const {
    return AzGetProgramBinaryReturn_partialEq(&inner_, b.ptr());
}

inline uint64_t GetProgramBinaryReturn::hash() const {
    return AzGetProgramBinaryReturn_hash(&inner_);
}

inline uint8_t GetProgramBinaryReturn::partialCmp(const GetProgramBinaryReturn& b) const {
    return AzGetProgramBinaryReturn_partialCmp(&inner_, b.ptr());
}

inline uint8_t GetProgramBinaryReturn::cmp(const GetProgramBinaryReturn& b) const {
    return AzGetProgramBinaryReturn_cmp(&inner_, b.ptr());
}

inline String GetProgramBinaryReturn::toDbgString() const {
    return String(AzGetProgramBinaryReturn_toDbgString(&inner_));
}

inline void LoadedFontSource::delete_() {
    AzLoadedFontSource_delete(&inner_);
}

inline LoadedFontSource LoadedFontSource::clone() const {
    return LoadedFontSource(AzLoadedFontSource_clone(&inner_));
}

inline bool LoadedFontSource::partialEq(const LoadedFontSource& b) const {
    return AzLoadedFontSource_partialEq(&inner_, b.ptr());
}

inline uint64_t LoadedFontSource::hash() const {
    return AzLoadedFontSource_hash(&inner_);
}

inline String LoadedFontSource::toDbgString() const {
    return String(AzLoadedFontSource_toDbgString(&inner_));
}

inline TessellatedSvgNode TessellatedSvgNode::empty() {
    return TessellatedSvgNode(AzTessellatedSvgNode_empty());
}

inline TessellatedSvgNode TessellatedSvgNode::from_nodes(TessellatedSvgNodeVecRef nodes) {
    return TessellatedSvgNode(AzTessellatedSvgNode_fromNodes(nodes.release()));
}

inline TessellatedSvgNode TessellatedSvgNode::default_() {
    return TessellatedSvgNode(AzTessellatedSvgNode_default());
}

inline void TessellatedSvgNode::delete_() {
    AzTessellatedSvgNode_delete(&inner_);
}

inline TessellatedSvgNode TessellatedSvgNode::clone() const {
    return TessellatedSvgNode(AzTessellatedSvgNode_clone(&inner_));
}

inline bool TessellatedSvgNode::partialEq(const TessellatedSvgNode& b) const {
    return AzTessellatedSvgNode_partialEq(&inner_, b.ptr());
}

inline uint8_t TessellatedSvgNode::partialCmp(const TessellatedSvgNode& b) const {
    return AzTessellatedSvgNode_partialCmp(&inner_, b.ptr());
}

inline String TessellatedSvgNode::toDbgString() const {
    return String(AzTessellatedSvgNode_toDbgString(&inner_));
}

inline CssPath CssPath::default_() {
    return CssPath(AzCssPath_default());
}

inline void CssPath::delete_() {
    AzCssPath_delete(&inner_);
}

inline CssPath CssPath::clone() const {
    return CssPath(AzCssPath_clone(&inner_));
}

inline bool CssPath::partialEq(const CssPath& b) const {
    return AzCssPath_partialEq(&inner_, b.ptr());
}

inline uint64_t CssPath::hash() const {
    return AzCssPath_hash(&inner_);
}

inline uint8_t CssPath::partialCmp(const CssPath& b) const {
    return AzCssPath_partialCmp(&inner_, b.ptr());
}

inline uint8_t CssPath::cmp(const CssPath& b) const {
    return AzCssPath_cmp(&inner_, b.ptr());
}

inline String CssPath::toDbgString() const {
    return String(AzCssPath_toDbgString(&inner_));
}

inline void ShapePolygon::delete_() {
    AzShapePolygon_delete(&inner_);
}

inline ShapePolygon ShapePolygon::clone() const {
    return ShapePolygon(AzShapePolygon_clone(&inner_));
}

inline bool ShapePolygon::partialEq(const ShapePolygon& b) const {
    return AzShapePolygon_partialEq(&inner_, b.ptr());
}

inline uint64_t ShapePolygon::hash() const {
    return AzShapePolygon_hash(&inner_);
}

inline uint8_t ShapePolygon::partialCmp(const ShapePolygon& b) const {
    return AzShapePolygon_partialCmp(&inner_, b.ptr());
}

inline uint8_t ShapePolygon::cmp(const ShapePolygon& b) const {
    return AzShapePolygon_cmp(&inner_, b.ptr());
}

inline String ShapePolygon::toDbgString() const {
    return String(AzShapePolygon_toDbgString(&inner_));
}

inline SvgPath SvgPath::create(SvgPathElementVec items) {
    return SvgPath(AzSvgPath_create(items.release()));
}

inline OptionSvgPoint SvgPath::get_start() const {
    return OptionSvgPoint(AzSvgPath_getStart(&inner_));
}

inline OptionSvgPoint SvgPath::get_end() const {
    return OptionSvgPoint(AzSvgPath_getEnd(&inner_));
}

inline void SvgPath::close() {
    AzSvgPath_close(&inner_);
}

inline bool SvgPath::is_closed() const {
    return AzSvgPath_isClosed(&inner_);
}

inline void SvgPath::reverse() {
    AzSvgPath_reverse(&inner_);
}

inline bool SvgPath::join_with(SvgPath path) {
    return AzSvgPath_joinWith(&inner_, path.release());
}

inline SvgRect SvgPath::get_bounds() const {
    return SvgRect(AzSvgPath_getBounds(&inner_));
}

inline void SvgPath::delete_() {
    AzSvgPath_delete(&inner_);
}

inline SvgPath SvgPath::clone() const {
    return SvgPath(AzSvgPath_clone(&inner_));
}

inline bool SvgPath::partialEq(const SvgPath& b) const {
    return AzSvgPath_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgPath::partialCmp(const SvgPath& b) const {
    return AzSvgPath_partialCmp(&inner_, b.ptr());
}

inline String SvgPath::toDbgString() const {
    return String(AzSvgPath_toDbgString(&inner_));
}

inline SvgMultiPolygon SvgMultiPolygon::create(SvgPathVec rings) {
    return SvgMultiPolygon(AzSvgMultiPolygon_create(rings.release()));
}

inline SvgRect SvgMultiPolygon::get_bounds() const {
    return SvgRect(AzSvgMultiPolygon_getBounds(&inner_));
}

inline TessellatedSvgNode SvgMultiPolygon::tessellate_fill(SvgFillStyle fill_style) const {
    return TessellatedSvgNode(AzSvgMultiPolygon_tessellateFill(&inner_, fill_style.release()));
}

inline TessellatedSvgNode SvgMultiPolygon::tessellate_stroke(SvgStrokeStyle stroke_style) const {
    return TessellatedSvgNode(AzSvgMultiPolygon_tessellateStroke(&inner_, stroke_style.release()));
}

inline void SvgMultiPolygon::delete_() {
    AzSvgMultiPolygon_delete(&inner_);
}

inline SvgMultiPolygon SvgMultiPolygon::clone() const {
    return SvgMultiPolygon(AzSvgMultiPolygon_clone(&inner_));
}

inline bool SvgMultiPolygon::partialEq(const SvgMultiPolygon& b) const {
    return AzSvgMultiPolygon_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgMultiPolygon::partialCmp(const SvgMultiPolygon& b) const {
    return AzSvgMultiPolygon_partialCmp(&inner_, b.ptr());
}

inline String SvgMultiPolygon::toDbgString() const {
    return String(AzSvgMultiPolygon_toDbgString(&inner_));
}

inline ResultParsedSvgSvgParseError ParsedSvg::from_string(String svg_string, SvgParseOptions parse_options) {
    return ResultParsedSvgSvgParseError(AzParsedSvg_fromString(svg_string.release(), parse_options.release()));
}

inline ResultParsedSvgSvgParseError ParsedSvg::from_bytes(U8VecRef svg_bytes, SvgParseOptions parse_options) {
    return ResultParsedSvgSvgParseError(AzParsedSvg_fromBytes(svg_bytes.release(), parse_options.release()));
}

inline OptionRawImage ParsedSvg::render(SvgRenderOptions options) const {
    return OptionRawImage(AzParsedSvg_render(&inner_, options.release()));
}

inline void ParsedSvg::delete_() {
    AzParsedSvg_delete(&inner_);
}

inline ParsedSvg ParsedSvg::clone() const {
    return ParsedSvg(AzParsedSvg_clone(&inner_));
}

inline String ParsedSvg::toDbgString() const {
    return String(AzParsedSvg_toDbgString(&inner_));
}

inline String String::copy_from_bytes(const uint8_t* ptr, size_t start, size_t len) {
    return String(AzString_copyFromBytes(ptr, start, len));
}

inline String String::from_c_str(const int8_t* ptr) {
    return String(AzString_fromCStr(ptr));
}

inline String String::default_() {
    return String(AzString_default());
}

inline U8Vec String::to_c_str() const {
    return U8Vec(AzString_toCStr(&inner_));
}

inline String String::from_utf16_le(const uint8_t* ptr, size_t len) {
    return String(AzString_fromUtf16Le(ptr, len));
}

inline String String::from_utf16_be(const uint8_t* ptr, size_t len) {
    return String(AzString_fromUtf16Be(ptr, len));
}

inline String String::from_utf8_lossy(const uint8_t* ptr, size_t len) {
    return String(AzString_fromUtf8Lossy(ptr, len));
}

inline String String::from_utf8(const uint8_t* ptr, size_t len) {
    return String(AzString_fromUtf8(ptr, len));
}

inline void String::delete_() {
    AzString_delete(&inner_);
}

inline String String::clone() const {
    return String(AzString_clone(&inner_));
}

inline bool String::partialEq(const String& b) const {
    return AzString_partialEq(&inner_, b.ptr());
}

inline uint64_t String::hash() const {
    return AzString_hash(&inner_);
}

inline uint8_t String::partialCmp(const String& b) const {
    return AzString_partialCmp(&inner_, b.ptr());
}

inline uint8_t String::cmp(const String& b) const {
    return AzString_cmp(&inner_, b.ptr());
}

inline String String::toDbgString() const {
    return String(AzString_toDbgString(&inner_));
}

inline void InvalidCharMultipleError::delete_() {
    AzInvalidCharMultipleError_delete(&inner_);
}

inline InvalidCharMultipleError InvalidCharMultipleError::clone() const {
    return InvalidCharMultipleError(AzInvalidCharMultipleError_clone(&inner_));
}

inline bool InvalidCharMultipleError::partialEq(const InvalidCharMultipleError& b) const {
    return AzInvalidCharMultipleError_partialEq(&inner_, b.ptr());
}

inline uint8_t InvalidCharMultipleError::partialCmp(const InvalidCharMultipleError& b) const {
    return AzInvalidCharMultipleError_partialCmp(&inner_, b.ptr());
}

inline String InvalidCharMultipleError::toDbgString() const {
    return String(AzInvalidCharMultipleError_toDbgString(&inner_));
}

inline void FluentZipLoadResult::delete_() {
    AzFluentZipLoadResult_delete(&inner_);
}

inline FluentZipLoadResult FluentZipLoadResult::clone() const {
    return FluentZipLoadResult(AzFluentZipLoadResult_clone(&inner_));
}

inline String FluentZipLoadResult::toDbgString() const {
    return String(AzFluentZipLoadResult_toDbgString(&inner_));
}

inline bool ThreadSender::send(AzThreadReceiveMsg msg) {
    return AzThreadSender_send(&inner_, msg);
}

inline void ThreadSender::delete_() {
    AzThreadSender_delete(&inner_);
}

inline ThreadSender ThreadSender::clone() const {
    return ThreadSender(AzThreadSender_clone(&inner_));
}

inline String ThreadSender::toDbgString() const {
    return String(AzThreadSender_toDbgString(&inner_));
}

inline OptionThreadSendMsg ThreadReceiver::recv() {
    return OptionThreadSendMsg(AzThreadReceiver_recv(&inner_));
}

inline void ThreadReceiver::delete_() {
    AzThreadReceiver_delete(&inner_);
}

inline ThreadReceiver ThreadReceiver::clone() const {
    return ThreadReceiver(AzThreadReceiver_clone(&inner_));
}

inline String ThreadReceiver::toDbgString() const {
    return String(AzThreadReceiver_toDbgString(&inner_));
}

inline void DbRows::delete_() {
    AzDbRows_delete(&inner_);
}

inline DbRows DbRows::clone() const {
    return DbRows(AzDbRows_clone(&inner_));
}

inline bool DbRows::partialEq(const DbRows& b) const {
    return AzDbRows_partialEq(&inner_, b.ptr());
}

inline String DbRows::toDbgString() const {
    return String(AzDbRows_toDbgString(&inner_));
}

inline ComponentMap ComponentMap::create() {
    return ComponentMap(AzComponentMap_create());
}

inline ComponentMap ComponentMap::default_() {
    return ComponentMap(AzComponentMap_default());
}

inline void ComponentMap::delete_() {
    AzComponentMap_delete(&inner_);
}

inline ComponentMap ComponentMap::clone() const {
    return ComponentMap(AzComponentMap_clone(&inner_));
}

inline String ComponentMap::toDbgString() const {
    return String(AzComponentMap_toDbgString(&inner_));
}

inline void WaylandTheme::delete_() {
    AzWaylandTheme_delete(&inner_);
}

inline WaylandTheme WaylandTheme::clone() const {
    return WaylandTheme(AzWaylandTheme_clone(&inner_));
}

inline bool WaylandTheme::partialEq(const WaylandTheme& b) const {
    return AzWaylandTheme_partialEq(&inner_, b.ptr());
}

inline uint8_t WaylandTheme::partialCmp(const WaylandTheme& b) const {
    return AzWaylandTheme_partialCmp(&inner_, b.ptr());
}

inline String WaylandTheme::toDbgString() const {
    return String(AzWaylandTheme_toDbgString(&inner_));
}

inline void MimeTypeHint::delete_() {
    AzMimeTypeHint_delete(&inner_);
}

inline MimeTypeHint MimeTypeHint::clone() const {
    return MimeTypeHint(AzMimeTypeHint_clone(&inner_));
}

inline bool MimeTypeHint::partialEq(const MimeTypeHint& b) const {
    return AzMimeTypeHint_partialEq(&inner_, b.ptr());
}

inline uint64_t MimeTypeHint::hash() const {
    return AzMimeTypeHint_hash(&inner_);
}

inline uint8_t MimeTypeHint::partialCmp(const MimeTypeHint& b) const {
    return AzMimeTypeHint_partialCmp(&inner_, b.ptr());
}

inline uint8_t MimeTypeHint::cmp(const MimeTypeHint& b) const {
    return AzMimeTypeHint_cmp(&inner_, b.ptr());
}

inline String MimeTypeHint::toDbgString() const {
    return String(AzMimeTypeHint_toDbgString(&inner_));
}

inline MimeTypeData MimeTypeData::default_() {
    return MimeTypeData(AzMimeTypeData_default());
}

inline void MimeTypeData::delete_() {
    AzMimeTypeData_delete(&inner_);
}

inline MimeTypeData MimeTypeData::clone() const {
    return MimeTypeData(AzMimeTypeData_clone(&inner_));
}

inline bool MimeTypeData::partialEq(const MimeTypeData& b) const {
    return AzMimeTypeData_partialEq(&inner_, b.ptr());
}

inline uint64_t MimeTypeData::hash() const {
    return AzMimeTypeData_hash(&inner_);
}

inline uint8_t MimeTypeData::partialCmp(const MimeTypeData& b) const {
    return AzMimeTypeData_partialCmp(&inner_, b.ptr());
}

inline uint8_t MimeTypeData::cmp(const MimeTypeData& b) const {
    return AzMimeTypeData_cmp(&inner_, b.ptr());
}

inline String MimeTypeData::toDbgString() const {
    return String(AzMimeTypeData_toDbgString(&inner_));
}

inline void HttpHeader::delete_() {
    AzHttpHeader_delete(&inner_);
}

inline HttpHeader HttpHeader::clone() const {
    return HttpHeader(AzHttpHeader_clone(&inner_));
}

inline bool HttpHeader::partialEq(const HttpHeader& b) const {
    return AzHttpHeader_partialEq(&inner_, b.ptr());
}

inline String HttpHeader::toDbgString() const {
    return String(AzHttpHeader_toDbgString(&inner_));
}

inline bool HttpResponse::is_success() const {
    return AzHttpResponse_isSuccess(&inner_);
}

inline bool HttpResponse::is_redirect() const {
    return AzHttpResponse_isRedirect(&inner_);
}

inline bool HttpResponse::is_client_error() const {
    return AzHttpResponse_isClientError(&inner_);
}

inline bool HttpResponse::is_server_error() const {
    return AzHttpResponse_isServerError(&inner_);
}

inline OptionString HttpResponse::body_as_string() const {
    return OptionString(AzHttpResponse_bodyAsString(&inner_));
}

inline void HttpResponse::delete_() {
    AzHttpResponse_delete(&inner_);
}

inline HttpResponse HttpResponse::clone() const {
    return HttpResponse(AzHttpResponse_clone(&inner_));
}

inline bool HttpResponse::partialEq(const HttpResponse& b) const {
    return AzHttpResponse_partialEq(&inner_, b.ptr());
}

inline String HttpResponse::toDbgString() const {
    return String(AzHttpResponse_toDbgString(&inner_));
}

inline HttpRequestConfig HttpRequestConfig::create() {
    return HttpRequestConfig(AzHttpRequestConfig_create());
}

inline HttpRequestConfig HttpRequestConfig::default_() {
    return HttpRequestConfig(AzHttpRequestConfig_default());
}

inline HttpRequestConfig HttpRequestConfig::with_timeout(uint64_t secs) const {
    return HttpRequestConfig(AzHttpRequestConfig_withTimeout(inner_, secs));
}

inline HttpRequestConfig HttpRequestConfig::with_max_size(uint64_t max_bytes) const {
    return HttpRequestConfig(AzHttpRequestConfig_withMaxSize(inner_, max_bytes));
}

inline HttpRequestConfig HttpRequestConfig::with_user_agent(String ua) const {
    return HttpRequestConfig(AzHttpRequestConfig_withUserAgent(inner_, ua.release()));
}

inline HttpRequestConfig HttpRequestConfig::with_header(String name, String value) const {
    return HttpRequestConfig(AzHttpRequestConfig_withHeader(inner_, name.release(), value.release()));
}

inline ResultHttpResponseHttpError HttpRequestConfig::http_get_default(String url) {
    return ResultHttpResponseHttpError(AzHttpRequestConfig_httpGetDefault(url.release()));
}

inline ResultHttpResponseHttpError HttpRequestConfig::http_get(String url) const {
    return ResultHttpResponseHttpError(AzHttpRequestConfig_httpGet(&inner_, url.release()));
}

inline ResultU8VecHttpError HttpRequestConfig::download_bytes_default(String url) {
    return ResultU8VecHttpError(AzHttpRequestConfig_downloadBytesDefault(url.release()));
}

inline ResultU8VecHttpError HttpRequestConfig::download_bytes(String url) const {
    return ResultU8VecHttpError(AzHttpRequestConfig_downloadBytes(&inner_, url.release()));
}

inline bool HttpRequestConfig::is_url_reachable(String url) {
    return AzHttpRequestConfig_isUrlReachable(url.release());
}

inline void HttpRequestConfig::delete_() {
    AzHttpRequestConfig_delete(&inner_);
}

inline HttpRequestConfig HttpRequestConfig::clone() const {
    return HttpRequestConfig(AzHttpRequestConfig_clone(&inner_));
}

inline String HttpRequestConfig::toDbgString() const {
    return String(AzHttpRequestConfig_toDbgString(&inner_));
}

inline TimerCallbackInfo TimerCallbackInfo::create(CallbackInfo callback_info, OptionDomNodeId node_id, AzInstant frame_start, size_t call_count, bool is_about_to_finish) {
    return TimerCallbackInfo(AzTimerCallbackInfo_create(callback_info.release(), node_id.release(), frame_start, call_count, is_about_to_finish));
}

inline OptionLogicalSize TimerCallbackInfo::get_attached_node_size() const {
    return OptionLogicalSize(AzTimerCallbackInfo_getAttachedNodeSize(&inner_));
}

inline OptionLogicalPosition TimerCallbackInfo::get_attached_node_position() const {
    return OptionLogicalPosition(AzTimerCallbackInfo_getAttachedNodePosition(&inner_));
}

inline void TimerCallbackInfo::update_all_image_callbacks() {
    AzTimerCallbackInfo_updateAllImageCallbacks(&inner_);
}

inline void TimerCallbackInfo::trigger_virtual_view_rerender(DomId dom_id, NodeId node_id) {
    AzTimerCallbackInfo_triggerVirtualViewRerender(&inner_, dom_id.release(), node_id.release());
}

inline void TimerCallbackInfo::delete_() {
    AzTimerCallbackInfo_delete(&inner_);
}

inline TimerCallbackInfo TimerCallbackInfo::clone() const {
    return TimerCallbackInfo(AzTimerCallbackInfo_clone(&inner_));
}

inline void CoreCallbackData::delete_() {
    AzCoreCallbackData_delete(&inner_);
}

inline CoreCallbackData CoreCallbackData::clone() const {
    return CoreCallbackData(AzCoreCallbackData_clone(&inner_));
}

inline bool CoreCallbackData::partialEq(const CoreCallbackData& b) const {
    return AzCoreCallbackData_partialEq(&inner_, b.ptr());
}

inline uint64_t CoreCallbackData::hash() const {
    return AzCoreCallbackData_hash(&inner_);
}

inline uint8_t CoreCallbackData::partialCmp(const CoreCallbackData& b) const {
    return AzCoreCallbackData_partialCmp(&inner_, b.ptr());
}

inline uint8_t CoreCallbackData::cmp(const CoreCallbackData& b) const {
    return AzCoreCallbackData_cmp(&inner_, b.ptr());
}

inline String CoreCallbackData::toDbgString() const {
    return String(AzCoreCallbackData_toDbgString(&inner_));
}

inline void CoreMenuCallback::delete_() {
    AzCoreMenuCallback_delete(&inner_);
}

inline CoreMenuCallback CoreMenuCallback::clone() const {
    return CoreMenuCallback(AzCoreMenuCallback_clone(&inner_));
}

inline bool CoreMenuCallback::partialEq(const CoreMenuCallback& b) const {
    return AzCoreMenuCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t CoreMenuCallback::hash() const {
    return AzCoreMenuCallback_hash(&inner_);
}

inline uint8_t CoreMenuCallback::partialCmp(const CoreMenuCallback& b) const {
    return AzCoreMenuCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t CoreMenuCallback::cmp(const CoreMenuCallback& b) const {
    return AzCoreMenuCallback_cmp(&inner_, b.ptr());
}

inline String CoreMenuCallback::toDbgString() const {
    return String(AzCoreMenuCallback_toDbgString(&inner_));
}

inline void AttributeNameValue::delete_() {
    AzAttributeNameValue_delete(&inner_);
}

inline AttributeNameValue AttributeNameValue::clone() const {
    return AttributeNameValue(AzAttributeNameValue_clone(&inner_));
}

inline bool AttributeNameValue::partialEq(const AttributeNameValue& b) const {
    return AzAttributeNameValue_partialEq(&inner_, b.ptr());
}

inline uint64_t AttributeNameValue::hash() const {
    return AzAttributeNameValue_hash(&inner_);
}

inline uint8_t AttributeNameValue::partialCmp(const AttributeNameValue& b) const {
    return AzAttributeNameValue_partialCmp(&inner_, b.ptr());
}

inline uint8_t AttributeNameValue::cmp(const AttributeNameValue& b) const {
    return AzAttributeNameValue_cmp(&inner_, b.ptr());
}

inline String AttributeNameValue::toDbgString() const {
    return String(AzAttributeNameValue_toDbgString(&inner_));
}

inline XmlTagName XmlTagName::default_() {
    return XmlTagName(AzXmlTagName_default());
}

inline void XmlTagName::delete_() {
    AzXmlTagName_delete(&inner_);
}

inline XmlTagName XmlTagName::clone() const {
    return XmlTagName(AzXmlTagName_clone(&inner_));
}

inline bool XmlTagName::partialEq(const XmlTagName& b) const {
    return AzXmlTagName_partialEq(&inner_, b.ptr());
}

inline uint64_t XmlTagName::hash() const {
    return AzXmlTagName_hash(&inner_);
}

inline uint8_t XmlTagName::partialCmp(const XmlTagName& b) const {
    return AzXmlTagName_partialCmp(&inner_, b.ptr());
}

inline uint8_t XmlTagName::cmp(const XmlTagName& b) const {
    return AzXmlTagName_cmp(&inner_, b.ptr());
}

inline String XmlTagName::toDbgString() const {
    return String(AzXmlTagName_toDbgString(&inner_));
}

inline void VertexAttribute::delete_() {
    AzVertexAttribute_delete(&inner_);
}

inline VertexAttribute VertexAttribute::clone() const {
    return VertexAttribute(AzVertexAttribute_clone(&inner_));
}

inline bool VertexAttribute::partialEq(const VertexAttribute& b) const {
    return AzVertexAttribute_partialEq(&inner_, b.ptr());
}

inline uint64_t VertexAttribute::hash() const {
    return AzVertexAttribute_hash(&inner_);
}

inline uint8_t VertexAttribute::partialCmp(const VertexAttribute& b) const {
    return AzVertexAttribute_partialCmp(&inner_, b.ptr());
}

inline uint8_t VertexAttribute::cmp(const VertexAttribute& b) const {
    return AzVertexAttribute_cmp(&inner_, b.ptr());
}

inline String VertexAttribute::toDbgString() const {
    return String(AzVertexAttribute_toDbgString(&inner_));
}

inline void CoreImageCallback::delete_() {
    AzCoreImageCallback_delete(&inner_);
}

inline CoreImageCallback CoreImageCallback::clone() const {
    return CoreImageCallback(AzCoreImageCallback_clone(&inner_));
}

inline bool CoreImageCallback::partialEq(const CoreImageCallback& b) const {
    return AzCoreImageCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t CoreImageCallback::hash() const {
    return AzCoreImageCallback_hash(&inner_);
}

inline uint8_t CoreImageCallback::partialCmp(const CoreImageCallback& b) const {
    return AzCoreImageCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t CoreImageCallback::cmp(const CoreImageCallback& b) const {
    return AzCoreImageCallback_cmp(&inner_, b.ptr());
}

inline String CoreImageCallback::toDbgString() const {
    return String(AzCoreImageCallback_toDbgString(&inner_));
}

inline void ClipboardContent::delete_() {
    AzClipboardContent_delete(&inner_);
}

inline ClipboardContent ClipboardContent::clone() const {
    return ClipboardContent(AzClipboardContent_clone(&inner_));
}

inline bool ClipboardContent::partialEq(const ClipboardContent& b) const {
    return AzClipboardContent_partialEq(&inner_, b.ptr());
}

inline String ClipboardContent::toDbgString() const {
    return String(AzClipboardContent_toDbgString(&inner_));
}

inline void TextInputOnVirtualKeyDown::delete_() {
    AzTextInputOnVirtualKeyDown_delete(&inner_);
}

inline TextInputOnVirtualKeyDown TextInputOnVirtualKeyDown::clone() const {
    return TextInputOnVirtualKeyDown(AzTextInputOnVirtualKeyDown_clone(&inner_));
}

inline bool TextInputOnVirtualKeyDown::partialEq(const TextInputOnVirtualKeyDown& b) const {
    return AzTextInputOnVirtualKeyDown_partialEq(&inner_, b.ptr());
}

inline uint64_t TextInputOnVirtualKeyDown::hash() const {
    return AzTextInputOnVirtualKeyDown_hash(&inner_);
}

inline uint8_t TextInputOnVirtualKeyDown::partialCmp(const TextInputOnVirtualKeyDown& b) const {
    return AzTextInputOnVirtualKeyDown_partialCmp(&inner_, b.ptr());
}

inline uint8_t TextInputOnVirtualKeyDown::cmp(const TextInputOnVirtualKeyDown& b) const {
    return AzTextInputOnVirtualKeyDown_cmp(&inner_, b.ptr());
}

inline String TextInputOnVirtualKeyDown::toDbgString() const {
    return String(AzTextInputOnVirtualKeyDown_toDbgString(&inner_));
}

inline void TextOpSetSelection::delete_() {
    AzTextOpSetSelection_delete(&inner_);
}

inline TextOpSetSelection TextOpSetSelection::clone() const {
    return TextOpSetSelection(AzTextOpSetSelection_clone(&inner_));
}

inline String TextOpSetSelection::toDbgString() const {
    return String(AzTextOpSetSelection_toDbgString(&inner_));
}

inline void NodeStateSnapshot::delete_() {
    AzNodeStateSnapshot_delete(&inner_);
}

inline NodeStateSnapshot NodeStateSnapshot::clone() const {
    return NodeStateSnapshot(AzNodeStateSnapshot_clone(&inner_));
}

inline String NodeStateSnapshot::toDbgString() const {
    return String(AzNodeStateSnapshot_toDbgString(&inner_));
}

inline void ParseIntErrorWithInput::delete_() {
    AzParseIntErrorWithInput_delete(&inner_);
}

inline ParseIntErrorWithInput ParseIntErrorWithInput::clone() const {
    return ParseIntErrorWithInput(AzParseIntErrorWithInput_clone(&inner_));
}

inline bool ParseIntErrorWithInput::partialEq(const ParseIntErrorWithInput& b) const {
    return AzParseIntErrorWithInput_partialEq(&inner_, b.ptr());
}

inline String ParseIntErrorWithInput::toDbgString() const {
    return String(AzParseIntErrorWithInput_toDbgString(&inner_));
}

inline void ParseFloatErrorWithInput::delete_() {
    AzParseFloatErrorWithInput_delete(&inner_);
}

inline ParseFloatErrorWithInput ParseFloatErrorWithInput::clone() const {
    return ParseFloatErrorWithInput(AzParseFloatErrorWithInput_clone(&inner_));
}

inline bool ParseFloatErrorWithInput::partialEq(const ParseFloatErrorWithInput& b) const {
    return AzParseFloatErrorWithInput_partialEq(&inner_, b.ptr());
}

inline String ParseFloatErrorWithInput::toDbgString() const {
    return String(AzParseFloatErrorWithInput_toDbgString(&inner_));
}

inline CssRuleBlock CssRuleBlock::default_() {
    return CssRuleBlock(AzCssRuleBlock_default());
}

inline void CssRuleBlock::delete_() {
    AzCssRuleBlock_delete(&inner_);
}

inline CssRuleBlock CssRuleBlock::clone() const {
    return CssRuleBlock(AzCssRuleBlock_clone(&inner_));
}

inline bool CssRuleBlock::partialEq(const CssRuleBlock& b) const {
    return AzCssRuleBlock_partialEq(&inner_, b.ptr());
}

inline uint8_t CssRuleBlock::partialCmp(const CssRuleBlock& b) const {
    return AzCssRuleBlock_partialCmp(&inner_, b.ptr());
}

inline uint8_t CssRuleBlock::cmp(const CssRuleBlock& b) const {
    return AzCssRuleBlock_cmp(&inner_, b.ptr());
}

inline String CssRuleBlock::toDbgString() const {
    return String(AzCssRuleBlock_toDbgString(&inner_));
}

inline RadialGradient RadialGradient::default_() {
    return RadialGradient(AzRadialGradient_default());
}

inline void RadialGradient::delete_() {
    AzRadialGradient_delete(&inner_);
}

inline RadialGradient RadialGradient::clone() const {
    return RadialGradient(AzRadialGradient_clone(&inner_));
}

inline bool RadialGradient::partialEq(const RadialGradient& b) const {
    return AzRadialGradient_partialEq(&inner_, b.ptr());
}

inline uint64_t RadialGradient::hash() const {
    return AzRadialGradient_hash(&inner_);
}

inline uint8_t RadialGradient::partialCmp(const RadialGradient& b) const {
    return AzRadialGradient_partialCmp(&inner_, b.ptr());
}

inline uint8_t RadialGradient::cmp(const RadialGradient& b) const {
    return AzRadialGradient_cmp(&inner_, b.ptr());
}

inline String RadialGradient::toDbgString() const {
    return String(AzRadialGradient_toDbgString(&inner_));
}

inline ConicGradient ConicGradient::default_() {
    return ConicGradient(AzConicGradient_default());
}

inline void ConicGradient::delete_() {
    AzConicGradient_delete(&inner_);
}

inline ConicGradient ConicGradient::clone() const {
    return ConicGradient(AzConicGradient_clone(&inner_));
}

inline bool ConicGradient::partialEq(const ConicGradient& b) const {
    return AzConicGradient_partialEq(&inner_, b.ptr());
}

inline uint64_t ConicGradient::hash() const {
    return AzConicGradient_hash(&inner_);
}

inline uint8_t ConicGradient::partialCmp(const ConicGradient& b) const {
    return AzConicGradient_partialCmp(&inner_, b.ptr());
}

inline uint8_t ConicGradient::cmp(const ConicGradient& b) const {
    return AzConicGradient_cmp(&inner_, b.ptr());
}

inline String ConicGradient::toDbgString() const {
    return String(AzConicGradient_toDbgString(&inner_));
}

inline CounterReset CounterReset::default_() {
    return CounterReset(AzCounterReset_default());
}

inline void CounterReset::delete_() {
    AzCounterReset_delete(&inner_);
}

inline CounterReset CounterReset::clone() const {
    return CounterReset(AzCounterReset_clone(&inner_));
}

inline bool CounterReset::partialEq(const CounterReset& b) const {
    return AzCounterReset_partialEq(&inner_, b.ptr());
}

inline uint64_t CounterReset::hash() const {
    return AzCounterReset_hash(&inner_);
}

inline uint8_t CounterReset::partialCmp(const CounterReset& b) const {
    return AzCounterReset_partialCmp(&inner_, b.ptr());
}

inline uint8_t CounterReset::cmp(const CounterReset& b) const {
    return AzCounterReset_cmp(&inner_, b.ptr());
}

inline String CounterReset::toDbgString() const {
    return String(AzCounterReset_toDbgString(&inner_));
}

inline Content Content::default_() {
    return Content(AzContent_default());
}

inline void Content::delete_() {
    AzContent_delete(&inner_);
}

inline Content Content::clone() const {
    return Content(AzContent_clone(&inner_));
}

inline bool Content::partialEq(const Content& b) const {
    return AzContent_partialEq(&inner_, b.ptr());
}

inline uint64_t Content::hash() const {
    return AzContent_hash(&inner_);
}

inline uint8_t Content::partialCmp(const Content& b) const {
    return AzContent_partialCmp(&inner_, b.ptr());
}

inline uint8_t Content::cmp(const Content& b) const {
    return AzContent_cmp(&inner_, b.ptr());
}

inline String Content::toDbgString() const {
    return String(AzContent_toDbgString(&inner_));
}

inline CounterIncrement CounterIncrement::default_() {
    return CounterIncrement(AzCounterIncrement_default());
}

inline void CounterIncrement::delete_() {
    AzCounterIncrement_delete(&inner_);
}

inline CounterIncrement CounterIncrement::clone() const {
    return CounterIncrement(AzCounterIncrement_clone(&inner_));
}

inline bool CounterIncrement::partialEq(const CounterIncrement& b) const {
    return AzCounterIncrement_partialEq(&inner_, b.ptr());
}

inline uint64_t CounterIncrement::hash() const {
    return AzCounterIncrement_hash(&inner_);
}

inline uint8_t CounterIncrement::partialCmp(const CounterIncrement& b) const {
    return AzCounterIncrement_partialCmp(&inner_, b.ptr());
}

inline uint8_t CounterIncrement::cmp(const CounterIncrement& b) const {
    return AzCounterIncrement_cmp(&inner_, b.ptr());
}

inline String CounterIncrement::toDbgString() const {
    return String(AzCounterIncrement_toDbgString(&inner_));
}

inline StyleHyphenationLanguage StyleHyphenationLanguage::default_() {
    return StyleHyphenationLanguage(AzStyleHyphenationLanguage_default());
}

inline void StyleHyphenationLanguage::delete_() {
    AzStyleHyphenationLanguage_delete(&inner_);
}

inline StyleHyphenationLanguage StyleHyphenationLanguage::clone() const {
    return StyleHyphenationLanguage(AzStyleHyphenationLanguage_clone(&inner_));
}

inline bool StyleHyphenationLanguage::partialEq(const StyleHyphenationLanguage& b) const {
    return AzStyleHyphenationLanguage_partialEq(&inner_, b.ptr());
}

inline uint64_t StyleHyphenationLanguage::hash() const {
    return AzStyleHyphenationLanguage_hash(&inner_);
}

inline uint8_t StyleHyphenationLanguage::partialCmp(const StyleHyphenationLanguage& b) const {
    return AzStyleHyphenationLanguage_partialCmp(&inner_, b.ptr());
}

inline uint8_t StyleHyphenationLanguage::cmp(const StyleHyphenationLanguage& b) const {
    return AzStyleHyphenationLanguage_cmp(&inner_, b.ptr());
}

inline String StyleHyphenationLanguage::toDbgString() const {
    return String(AzStyleHyphenationLanguage_toDbgString(&inner_));
}

inline NamedGridLine NamedGridLine::create(String name, OptionI32 span) {
    return NamedGridLine(AzNamedGridLine_create(name.release(), span.release()));
}

inline OptionI32 NamedGridLine::span() const {
    return OptionI32(AzNamedGridLine_span(&inner_));
}

inline void NamedGridLine::delete_() {
    AzNamedGridLine_delete(&inner_);
}

inline NamedGridLine NamedGridLine::clone() const {
    return NamedGridLine(AzNamedGridLine_clone(&inner_));
}

inline bool NamedGridLine::partialEq(const NamedGridLine& b) const {
    return AzNamedGridLine_partialEq(&inner_, b.ptr());
}

inline uint64_t NamedGridLine::hash() const {
    return AzNamedGridLine_hash(&inner_);
}

inline uint8_t NamedGridLine::partialCmp(const NamedGridLine& b) const {
    return AzNamedGridLine_partialCmp(&inner_, b.ptr());
}

inline uint8_t NamedGridLine::cmp(const NamedGridLine& b) const {
    return AzNamedGridLine_cmp(&inner_, b.ptr());
}

inline String NamedGridLine::toDbgString() const {
    return String(AzNamedGridLine_toDbgString(&inner_));
}

inline void ShapePath::delete_() {
    AzShapePath_delete(&inner_);
}

inline ShapePath ShapePath::clone() const {
    return ShapePath(AzShapePath_clone(&inner_));
}

inline bool ShapePath::partialEq(const ShapePath& b) const {
    return AzShapePath_partialEq(&inner_, b.ptr());
}

inline uint64_t ShapePath::hash() const {
    return AzShapePath_hash(&inner_);
}

inline uint8_t ShapePath::partialCmp(const ShapePath& b) const {
    return AzShapePath_partialCmp(&inner_, b.ptr());
}

inline uint8_t ShapePath::cmp(const ShapePath& b) const {
    return AzShapePath_cmp(&inner_, b.ptr());
}

inline String ShapePath::toDbgString() const {
    return String(AzShapePath_toDbgString(&inner_));
}

inline void TextOpReplaceText::delete_() {
    AzTextOpReplaceText_delete(&inner_);
}

inline TextOpReplaceText TextOpReplaceText::clone() const {
    return TextOpReplaceText(AzTextOpReplaceText_clone(&inner_));
}

inline String TextOpReplaceText::toDbgString() const {
    return String(AzTextOpReplaceText_toDbgString(&inner_));
}

inline void TextOpDeleteText::delete_() {
    AzTextOpDeleteText_delete(&inner_);
}

inline TextOpDeleteText TextOpDeleteText::clone() const {
    return TextOpDeleteText(AzTextOpDeleteText_clone(&inner_));
}

inline String TextOpDeleteText::toDbgString() const {
    return String(AzTextOpDeleteText_toDbgString(&inner_));
}

inline void TextOpSelectAll::delete_() {
    AzTextOpSelectAll_delete(&inner_);
}

inline TextOpSelectAll TextOpSelectAll::clone() const {
    return TextOpSelectAll(AzTextOpSelectAll_clone(&inner_));
}

inline String TextOpSelectAll::toDbgString() const {
    return String(AzTextOpSelectAll_toDbgString(&inner_));
}

inline void TextOpInsertText::delete_() {
    AzTextOpInsertText_delete(&inner_);
}

inline TextOpInsertText TextOpInsertText::clone() const {
    return TextOpInsertText(AzTextOpInsertText_clone(&inner_));
}

inline String TextOpInsertText::toDbgString() const {
    return String(AzTextOpInsertText_toDbgString(&inner_));
}

inline void PendingTextEdit::delete_() {
    AzPendingTextEdit_delete(&inner_);
}

inline PendingTextEdit PendingTextEdit::clone() const {
    return PendingTextEdit(AzPendingTextEdit_clone(&inner_));
}

inline String PendingTextEdit::toDbgString() const {
    return String(AzPendingTextEdit_toDbgString(&inner_));
}

inline NamedFont NamedFont::create(String name, U8Vec bytes) {
    return NamedFont(AzNamedFont_create(name.release(), bytes.release()));
}

inline void NamedFont::delete_() {
    AzNamedFont_delete(&inner_);
}

inline NamedFont NamedFont::clone() const {
    return NamedFont(AzNamedFont_clone(&inner_));
}

inline bool NamedFont::partialEq(const NamedFont& b) const {
    return AzNamedFont_partialEq(&inner_, b.ptr());
}

inline uint64_t NamedFont::hash() const {
    return AzNamedFont_hash(&inner_);
}

inline uint8_t NamedFont::partialCmp(const NamedFont& b) const {
    return AzNamedFont_partialCmp(&inner_, b.ptr());
}

inline uint8_t NamedFont::cmp(const NamedFont& b) const {
    return AzNamedFont_cmp(&inner_, b.ptr());
}

inline String NamedFont::toDbgString() const {
    return String(AzNamedFont_toDbgString(&inner_));
}

inline void GridAreaDefinition::delete_() {
    AzGridAreaDefinition_delete(&inner_);
}

inline GridAreaDefinition GridAreaDefinition::clone() const {
    return GridAreaDefinition(AzGridAreaDefinition_clone(&inner_));
}

inline bool GridAreaDefinition::partialEq(const GridAreaDefinition& b) const {
    return AzGridAreaDefinition_partialEq(&inner_, b.ptr());
}

inline uint64_t GridAreaDefinition::hash() const {
    return AzGridAreaDefinition_hash(&inner_);
}

inline uint8_t GridAreaDefinition::partialCmp(const GridAreaDefinition& b) const {
    return AzGridAreaDefinition_partialCmp(&inner_, b.ptr());
}

inline uint8_t GridAreaDefinition::cmp(const GridAreaDefinition& b) const {
    return AzGridAreaDefinition_cmp(&inner_, b.ptr());
}

inline String GridAreaDefinition::toDbgString() const {
    return String(AzGridAreaDefinition_toDbgString(&inner_));
}

inline void InvalidValueErrOwned::delete_() {
    AzInvalidValueErrOwned_delete(&inner_);
}

inline InvalidValueErrOwned InvalidValueErrOwned::clone() const {
    return InvalidValueErrOwned(AzInvalidValueErrOwned_clone(&inner_));
}

inline bool InvalidValueErrOwned::partialEq(const InvalidValueErrOwned& b) const {
    return AzInvalidValueErrOwned_partialEq(&inner_, b.ptr());
}

inline String InvalidValueErrOwned::toDbgString() const {
    return String(AzInvalidValueErrOwned_toDbgString(&inner_));
}

inline void FileTypeList::delete_() {
    AzFileTypeList_delete(&inner_);
}

inline FileTypeList FileTypeList::clone() const {
    return FileTypeList(AzFileTypeList_clone(&inner_));
}

inline bool FileTypeList::partialEq(const FileTypeList& b) const {
    return AzFileTypeList_partialEq(&inner_, b.ptr());
}

inline uint8_t FileTypeList::partialCmp(const FileTypeList& b) const {
    return AzFileTypeList_partialCmp(&inner_, b.ptr());
}

inline String FileTypeList::toDbgString() const {
    return String(AzFileTypeList_toDbgString(&inner_));
}

inline MapTileLayer MapTileLayer::default_() {
    return MapTileLayer(AzMapTileLayer_default());
}

inline void MapTileLayer::delete_() {
    AzMapTileLayer_delete(&inner_);
}

inline MapTileLayer MapTileLayer::clone() const {
    return MapTileLayer(AzMapTileLayer_clone(&inner_));
}

inline bool MapTileLayer::partialEq(const MapTileLayer& b) const {
    return AzMapTileLayer_partialEq(&inner_, b.ptr());
}

inline String MapTileLayer::toDbgString() const {
    return String(AzMapTileLayer_toDbgString(&inner_));
}

inline void ButtonOnClick::delete_() {
    AzButtonOnClick_delete(&inner_);
}

inline ButtonOnClick ButtonOnClick::clone() const {
    return ButtonOnClick(AzButtonOnClick_clone(&inner_));
}

inline bool ButtonOnClick::partialEq(const ButtonOnClick& b) const {
    return AzButtonOnClick_partialEq(&inner_, b.ptr());
}

inline uint64_t ButtonOnClick::hash() const {
    return AzButtonOnClick_hash(&inner_);
}

inline uint8_t ButtonOnClick::partialCmp(const ButtonOnClick& b) const {
    return AzButtonOnClick_partialCmp(&inner_, b.ptr());
}

inline uint8_t ButtonOnClick::cmp(const ButtonOnClick& b) const {
    return AzButtonOnClick_cmp(&inner_, b.ptr());
}

inline String ButtonOnClick::toDbgString() const {
    return String(AzButtonOnClick_toDbgString(&inner_));
}

inline void FileInputOnPathChange::delete_() {
    AzFileInputOnPathChange_delete(&inner_);
}

inline FileInputOnPathChange FileInputOnPathChange::clone() const {
    return FileInputOnPathChange(AzFileInputOnPathChange_clone(&inner_));
}

inline bool FileInputOnPathChange::partialEq(const FileInputOnPathChange& b) const {
    return AzFileInputOnPathChange_partialEq(&inner_, b.ptr());
}

inline uint64_t FileInputOnPathChange::hash() const {
    return AzFileInputOnPathChange_hash(&inner_);
}

inline uint8_t FileInputOnPathChange::partialCmp(const FileInputOnPathChange& b) const {
    return AzFileInputOnPathChange_partialCmp(&inner_, b.ptr());
}

inline uint8_t FileInputOnPathChange::cmp(const FileInputOnPathChange& b) const {
    return AzFileInputOnPathChange_cmp(&inner_, b.ptr());
}

inline String FileInputOnPathChange::toDbgString() const {
    return String(AzFileInputOnPathChange_toDbgString(&inner_));
}

inline void CheckBoxOnToggle::delete_() {
    AzCheckBoxOnToggle_delete(&inner_);
}

inline CheckBoxOnToggle CheckBoxOnToggle::clone() const {
    return CheckBoxOnToggle(AzCheckBoxOnToggle_clone(&inner_));
}

inline bool CheckBoxOnToggle::partialEq(const CheckBoxOnToggle& b) const {
    return AzCheckBoxOnToggle_partialEq(&inner_, b.ptr());
}

inline uint64_t CheckBoxOnToggle::hash() const {
    return AzCheckBoxOnToggle_hash(&inner_);
}

inline uint8_t CheckBoxOnToggle::partialCmp(const CheckBoxOnToggle& b) const {
    return AzCheckBoxOnToggle_partialCmp(&inner_, b.ptr());
}

inline uint8_t CheckBoxOnToggle::cmp(const CheckBoxOnToggle& b) const {
    return AzCheckBoxOnToggle_cmp(&inner_, b.ptr());
}

inline String CheckBoxOnToggle::toDbgString() const {
    return String(AzCheckBoxOnToggle_toDbgString(&inner_));
}

inline void DropDownOnChoiceChange::delete_() {
    AzDropDownOnChoiceChange_delete(&inner_);
}

inline DropDownOnChoiceChange DropDownOnChoiceChange::clone() const {
    return DropDownOnChoiceChange(AzDropDownOnChoiceChange_clone(&inner_));
}

inline bool DropDownOnChoiceChange::partialEq(const DropDownOnChoiceChange& b) const {
    return AzDropDownOnChoiceChange_partialEq(&inner_, b.ptr());
}

inline uint64_t DropDownOnChoiceChange::hash() const {
    return AzDropDownOnChoiceChange_hash(&inner_);
}

inline uint8_t DropDownOnChoiceChange::partialCmp(const DropDownOnChoiceChange& b) const {
    return AzDropDownOnChoiceChange_partialCmp(&inner_, b.ptr());
}

inline uint8_t DropDownOnChoiceChange::cmp(const DropDownOnChoiceChange& b) const {
    return AzDropDownOnChoiceChange_cmp(&inner_, b.ptr());
}

inline String DropDownOnChoiceChange::toDbgString() const {
    return String(AzDropDownOnChoiceChange_toDbgString(&inner_));
}

inline void ColorInputOnValueChange::delete_() {
    AzColorInputOnValueChange_delete(&inner_);
}

inline ColorInputOnValueChange ColorInputOnValueChange::clone() const {
    return ColorInputOnValueChange(AzColorInputOnValueChange_clone(&inner_));
}

inline bool ColorInputOnValueChange::partialEq(const ColorInputOnValueChange& b) const {
    return AzColorInputOnValueChange_partialEq(&inner_, b.ptr());
}

inline uint64_t ColorInputOnValueChange::hash() const {
    return AzColorInputOnValueChange_hash(&inner_);
}

inline uint8_t ColorInputOnValueChange::partialCmp(const ColorInputOnValueChange& b) const {
    return AzColorInputOnValueChange_partialCmp(&inner_, b.ptr());
}

inline uint8_t ColorInputOnValueChange::cmp(const ColorInputOnValueChange& b) const {
    return AzColorInputOnValueChange_cmp(&inner_, b.ptr());
}

inline String ColorInputOnValueChange::toDbgString() const {
    return String(AzColorInputOnValueChange_toDbgString(&inner_));
}

inline void TextInputOnTextInput::delete_() {
    AzTextInputOnTextInput_delete(&inner_);
}

inline TextInputOnTextInput TextInputOnTextInput::clone() const {
    return TextInputOnTextInput(AzTextInputOnTextInput_clone(&inner_));
}

inline bool TextInputOnTextInput::partialEq(const TextInputOnTextInput& b) const {
    return AzTextInputOnTextInput_partialEq(&inner_, b.ptr());
}

inline uint64_t TextInputOnTextInput::hash() const {
    return AzTextInputOnTextInput_hash(&inner_);
}

inline uint8_t TextInputOnTextInput::partialCmp(const TextInputOnTextInput& b) const {
    return AzTextInputOnTextInput_partialCmp(&inner_, b.ptr());
}

inline uint8_t TextInputOnTextInput::cmp(const TextInputOnTextInput& b) const {
    return AzTextInputOnTextInput_cmp(&inner_, b.ptr());
}

inline String TextInputOnTextInput::toDbgString() const {
    return String(AzTextInputOnTextInput_toDbgString(&inner_));
}

inline void TextInputOnFocusLost::delete_() {
    AzTextInputOnFocusLost_delete(&inner_);
}

inline TextInputOnFocusLost TextInputOnFocusLost::clone() const {
    return TextInputOnFocusLost(AzTextInputOnFocusLost_clone(&inner_));
}

inline bool TextInputOnFocusLost::partialEq(const TextInputOnFocusLost& b) const {
    return AzTextInputOnFocusLost_partialEq(&inner_, b.ptr());
}

inline uint64_t TextInputOnFocusLost::hash() const {
    return AzTextInputOnFocusLost_hash(&inner_);
}

inline uint8_t TextInputOnFocusLost::partialCmp(const TextInputOnFocusLost& b) const {
    return AzTextInputOnFocusLost_partialCmp(&inner_, b.ptr());
}

inline uint8_t TextInputOnFocusLost::cmp(const TextInputOnFocusLost& b) const {
    return AzTextInputOnFocusLost_cmp(&inner_, b.ptr());
}

inline String TextInputOnFocusLost::toDbgString() const {
    return String(AzTextInputOnFocusLost_toDbgString(&inner_));
}

inline void NumberInputOnValueChange::delete_() {
    AzNumberInputOnValueChange_delete(&inner_);
}

inline NumberInputOnValueChange NumberInputOnValueChange::clone() const {
    return NumberInputOnValueChange(AzNumberInputOnValueChange_clone(&inner_));
}

inline bool NumberInputOnValueChange::partialEq(const NumberInputOnValueChange& b) const {
    return AzNumberInputOnValueChange_partialEq(&inner_, b.ptr());
}

inline uint64_t NumberInputOnValueChange::hash() const {
    return AzNumberInputOnValueChange_hash(&inner_);
}

inline uint8_t NumberInputOnValueChange::partialCmp(const NumberInputOnValueChange& b) const {
    return AzNumberInputOnValueChange_partialCmp(&inner_, b.ptr());
}

inline uint8_t NumberInputOnValueChange::cmp(const NumberInputOnValueChange& b) const {
    return AzNumberInputOnValueChange_cmp(&inner_, b.ptr());
}

inline String NumberInputOnValueChange::toDbgString() const {
    return String(AzNumberInputOnValueChange_toDbgString(&inner_));
}

inline void NumberInputOnFocusLost::delete_() {
    AzNumberInputOnFocusLost_delete(&inner_);
}

inline NumberInputOnFocusLost NumberInputOnFocusLost::clone() const {
    return NumberInputOnFocusLost(AzNumberInputOnFocusLost_clone(&inner_));
}

inline bool NumberInputOnFocusLost::partialEq(const NumberInputOnFocusLost& b) const {
    return AzNumberInputOnFocusLost_partialEq(&inner_, b.ptr());
}

inline uint64_t NumberInputOnFocusLost::hash() const {
    return AzNumberInputOnFocusLost_hash(&inner_);
}

inline uint8_t NumberInputOnFocusLost::partialCmp(const NumberInputOnFocusLost& b) const {
    return AzNumberInputOnFocusLost_partialCmp(&inner_, b.ptr());
}

inline uint8_t NumberInputOnFocusLost::cmp(const NumberInputOnFocusLost& b) const {
    return AzNumberInputOnFocusLost_cmp(&inner_, b.ptr());
}

inline String NumberInputOnFocusLost::toDbgString() const {
    return String(AzNumberInputOnFocusLost_toDbgString(&inner_));
}

inline void TabOnClick::delete_() {
    AzTabOnClick_delete(&inner_);
}

inline TabOnClick TabOnClick::clone() const {
    return TabOnClick(AzTabOnClick_clone(&inner_));
}

inline bool TabOnClick::partialEq(const TabOnClick& b) const {
    return AzTabOnClick_partialEq(&inner_, b.ptr());
}

inline uint64_t TabOnClick::hash() const {
    return AzTabOnClick_hash(&inner_);
}

inline uint8_t TabOnClick::partialCmp(const TabOnClick& b) const {
    return AzTabOnClick_partialCmp(&inner_, b.ptr());
}

inline uint8_t TabOnClick::cmp(const TabOnClick& b) const {
    return AzTabOnClick_cmp(&inner_, b.ptr());
}

inline String TabOnClick::toDbgString() const {
    return String(AzTabOnClick_toDbgString(&inner_));
}

inline void ListViewRow::delete_() {
    AzListViewRow_delete(&inner_);
}

inline ListViewRow ListViewRow::clone() const {
    return ListViewRow(AzListViewRow_clone(&inner_));
}

inline String ListViewRow::toDbgString() const {
    return String(AzListViewRow_toDbgString(&inner_));
}

inline void ListViewOnLazyLoadScroll::delete_() {
    AzListViewOnLazyLoadScroll_delete(&inner_);
}

inline ListViewOnLazyLoadScroll ListViewOnLazyLoadScroll::clone() const {
    return ListViewOnLazyLoadScroll(AzListViewOnLazyLoadScroll_clone(&inner_));
}

inline bool ListViewOnLazyLoadScroll::partialEq(const ListViewOnLazyLoadScroll& b) const {
    return AzListViewOnLazyLoadScroll_partialEq(&inner_, b.ptr());
}

inline uint64_t ListViewOnLazyLoadScroll::hash() const {
    return AzListViewOnLazyLoadScroll_hash(&inner_);
}

inline uint8_t ListViewOnLazyLoadScroll::partialCmp(const ListViewOnLazyLoadScroll& b) const {
    return AzListViewOnLazyLoadScroll_partialCmp(&inner_, b.ptr());
}

inline uint8_t ListViewOnLazyLoadScroll::cmp(const ListViewOnLazyLoadScroll& b) const {
    return AzListViewOnLazyLoadScroll_cmp(&inner_, b.ptr());
}

inline String ListViewOnLazyLoadScroll::toDbgString() const {
    return String(AzListViewOnLazyLoadScroll_toDbgString(&inner_));
}

inline void ListViewOnColumnClick::delete_() {
    AzListViewOnColumnClick_delete(&inner_);
}

inline ListViewOnColumnClick ListViewOnColumnClick::clone() const {
    return ListViewOnColumnClick(AzListViewOnColumnClick_clone(&inner_));
}

inline bool ListViewOnColumnClick::partialEq(const ListViewOnColumnClick& b) const {
    return AzListViewOnColumnClick_partialEq(&inner_, b.ptr());
}

inline uint64_t ListViewOnColumnClick::hash() const {
    return AzListViewOnColumnClick_hash(&inner_);
}

inline uint8_t ListViewOnColumnClick::partialCmp(const ListViewOnColumnClick& b) const {
    return AzListViewOnColumnClick_partialCmp(&inner_, b.ptr());
}

inline uint8_t ListViewOnColumnClick::cmp(const ListViewOnColumnClick& b) const {
    return AzListViewOnColumnClick_cmp(&inner_, b.ptr());
}

inline String ListViewOnColumnClick::toDbgString() const {
    return String(AzListViewOnColumnClick_toDbgString(&inner_));
}

inline void ListViewOnRowClick::delete_() {
    AzListViewOnRowClick_delete(&inner_);
}

inline ListViewOnRowClick ListViewOnRowClick::clone() const {
    return ListViewOnRowClick(AzListViewOnRowClick_clone(&inner_));
}

inline bool ListViewOnRowClick::partialEq(const ListViewOnRowClick& b) const {
    return AzListViewOnRowClick_partialEq(&inner_, b.ptr());
}

inline uint64_t ListViewOnRowClick::hash() const {
    return AzListViewOnRowClick_hash(&inner_);
}

inline uint8_t ListViewOnRowClick::partialCmp(const ListViewOnRowClick& b) const {
    return AzListViewOnRowClick_partialCmp(&inner_, b.ptr());
}

inline uint8_t ListViewOnRowClick::cmp(const ListViewOnRowClick& b) const {
    return AzListViewOnRowClick_cmp(&inner_, b.ptr());
}

inline String ListViewOnRowClick::toDbgString() const {
    return String(AzListViewOnRowClick_toDbgString(&inner_));
}

inline RibbonTab RibbonTab::new_(String label) {
    return RibbonTab(AzRibbonTab_new(label.release()));
}

inline void RibbonTab::add_section(RibbonSection section) {
    AzRibbonTab_addSection(&inner_, section.release());
}

inline RibbonTab RibbonTab::with_section(RibbonSection section) const {
    return RibbonTab(AzRibbonTab_withSection(inner_, section.release()));
}

inline void RibbonTab::delete_() {
    AzRibbonTab_delete(&inner_);
}

inline RibbonTab RibbonTab::clone() const {
    return RibbonTab(AzRibbonTab_clone(&inner_));
}

inline String RibbonTab::toDbgString() const {
    return String(AzRibbonTab_toDbgString(&inner_));
}

inline void RibbonOnTabClick::delete_() {
    AzRibbonOnTabClick_delete(&inner_);
}

inline RibbonOnTabClick RibbonOnTabClick::clone() const {
    return RibbonOnTabClick(AzRibbonOnTabClick_clone(&inner_));
}

inline bool RibbonOnTabClick::partialEq(const RibbonOnTabClick& b) const {
    return AzRibbonOnTabClick_partialEq(&inner_, b.ptr());
}

inline uint64_t RibbonOnTabClick::hash() const {
    return AzRibbonOnTabClick_hash(&inner_);
}

inline uint8_t RibbonOnTabClick::partialCmp(const RibbonOnTabClick& b) const {
    return AzRibbonOnTabClick_partialCmp(&inner_, b.ptr());
}

inline uint8_t RibbonOnTabClick::cmp(const RibbonOnTabClick& b) const {
    return AzRibbonOnTabClick_cmp(&inner_, b.ptr());
}

inline String RibbonOnTabClick::toDbgString() const {
    return String(AzRibbonOnTabClick_toDbgString(&inner_));
}

inline TreeViewNode TreeViewNode::new_(String label) {
    return TreeViewNode(AzTreeViewNode_new(label.release()));
}

inline void TreeViewNode::add_child(TreeViewNode child) {
    AzTreeViewNode_addChild(&inner_, child.release());
}

inline TreeViewNode TreeViewNode::with_child(TreeViewNode child) const {
    return TreeViewNode(AzTreeViewNode_withChild(inner_, child.release()));
}

inline TreeViewNode TreeViewNode::with_expanded(bool expanded) const {
    return TreeViewNode(AzTreeViewNode_withExpanded(inner_, expanded));
}

inline TreeViewNode TreeViewNode::with_selected(bool selected) const {
    return TreeViewNode(AzTreeViewNode_withSelected(inner_, selected));
}

inline void TreeViewNode::delete_() {
    AzTreeViewNode_delete(&inner_);
}

inline TreeViewNode TreeViewNode::clone() const {
    return TreeViewNode(AzTreeViewNode_clone(&inner_));
}

inline bool TreeViewNode::partialEq(const TreeViewNode& b) const {
    return AzTreeViewNode_partialEq(&inner_, b.ptr());
}

inline String TreeViewNode::toDbgString() const {
    return String(AzTreeViewNode_toDbgString(&inner_));
}

inline void TreeViewOnNodeClick::delete_() {
    AzTreeViewOnNodeClick_delete(&inner_);
}

inline TreeViewOnNodeClick TreeViewOnNodeClick::clone() const {
    return TreeViewOnNodeClick(AzTreeViewOnNodeClick_clone(&inner_));
}

inline bool TreeViewOnNodeClick::partialEq(const TreeViewOnNodeClick& b) const {
    return AzTreeViewOnNodeClick_partialEq(&inner_, b.ptr());
}

inline uint64_t TreeViewOnNodeClick::hash() const {
    return AzTreeViewOnNodeClick_hash(&inner_);
}

inline uint8_t TreeViewOnNodeClick::partialCmp(const TreeViewOnNodeClick& b) const {
    return AzTreeViewOnNodeClick_partialCmp(&inner_, b.ptr());
}

inline uint8_t TreeViewOnNodeClick::cmp(const TreeViewOnNodeClick& b) const {
    return AzTreeViewOnNodeClick_cmp(&inner_, b.ptr());
}

inline String TreeViewOnNodeClick::toDbgString() const {
    return String(AzTreeViewOnNodeClick_toDbgString(&inner_));
}

inline Titlebar Titlebar::new_(String title) {
    return Titlebar(AzTitlebar_new(title.release()));
}

inline Titlebar Titlebar::default_() {
    return Titlebar(AzTitlebar_default());
}

inline Dom Titlebar::dom() const {
    return Dom(AzTitlebar_dom(inner_));
}

inline Dom Titlebar::domWithButtons(TitlebarButtons buttons, AzTitlebarButtonSide button_side) const {
    return Dom(AzTitlebar_domWithButtons(inner_, buttons.release(), button_side));
}

inline void Titlebar::delete_() {
    AzTitlebar_delete(&inner_);
}

inline Titlebar Titlebar::clone() const {
    return Titlebar(AzTitlebar_clone(&inner_));
}

inline bool Titlebar::partialEq(const Titlebar& b) const {
    return AzTitlebar_partialEq(&inner_, b.ptr());
}

inline uint8_t Titlebar::partialCmp(const Titlebar& b) const {
    return AzTitlebar_partialCmp(&inner_, b.ptr());
}

inline String Titlebar::toDbgString() const {
    return String(AzTitlebar_toDbgString(&inner_));
}

inline void OnVideoFrame::delete_() {
    AzOnVideoFrame_delete(&inner_);
}

inline OnVideoFrame OnVideoFrame::clone() const {
    return OnVideoFrame(AzOnVideoFrame_clone(&inner_));
}

inline bool OnVideoFrame::partialEq(const OnVideoFrame& b) const {
    return AzOnVideoFrame_partialEq(&inner_, b.ptr());
}

inline uint64_t OnVideoFrame::hash() const {
    return AzOnVideoFrame_hash(&inner_);
}

inline uint8_t OnVideoFrame::partialCmp(const OnVideoFrame& b) const {
    return AzOnVideoFrame_partialCmp(&inner_, b.ptr());
}

inline uint8_t OnVideoFrame::cmp(const OnVideoFrame& b) const {
    return AzOnVideoFrame_cmp(&inner_, b.ptr());
}

inline String OnVideoFrame::toDbgString() const {
    return String(AzOnVideoFrame_toDbgString(&inner_));
}

inline void MapViewportChanged::delete_() {
    AzMapViewportChanged_delete(&inner_);
}

inline MapViewportChanged MapViewportChanged::clone() const {
    return MapViewportChanged(AzMapViewportChanged_clone(&inner_));
}

inline bool MapViewportChanged::partialEq(const MapViewportChanged& b) const {
    return AzMapViewportChanged_partialEq(&inner_, b.ptr());
}

inline uint64_t MapViewportChanged::hash() const {
    return AzMapViewportChanged_hash(&inner_);
}

inline uint8_t MapViewportChanged::partialCmp(const MapViewportChanged& b) const {
    return AzMapViewportChanged_partialCmp(&inner_, b.ptr());
}

inline uint8_t MapViewportChanged::cmp(const MapViewportChanged& b) const {
    return AzMapViewportChanged_cmp(&inner_, b.ptr());
}

inline String MapViewportChanged::toDbgString() const {
    return String(AzMapViewportChanged_toDbgString(&inner_));
}

inline void OnAudioFrame::delete_() {
    AzOnAudioFrame_delete(&inner_);
}

inline OnAudioFrame OnAudioFrame::clone() const {
    return OnAudioFrame(AzOnAudioFrame_clone(&inner_));
}

inline bool OnAudioFrame::partialEq(const OnAudioFrame& b) const {
    return AzOnAudioFrame_partialEq(&inner_, b.ptr());
}

inline uint64_t OnAudioFrame::hash() const {
    return AzOnAudioFrame_hash(&inner_);
}

inline uint8_t OnAudioFrame::partialCmp(const OnAudioFrame& b) const {
    return AzOnAudioFrame_partialCmp(&inner_, b.ptr());
}

inline uint8_t OnAudioFrame::cmp(const OnAudioFrame& b) const {
    return AzOnAudioFrame_cmp(&inner_, b.ptr());
}

inline String OnAudioFrame::toDbgString() const {
    return String(AzOnAudioFrame_toDbgString(&inner_));
}

inline void GetActiveAttribReturn::delete_() {
    AzGetActiveAttribReturn_delete(&inner_);
}

inline GetActiveAttribReturn GetActiveAttribReturn::clone() const {
    return GetActiveAttribReturn(AzGetActiveAttribReturn_clone(&inner_));
}

inline bool GetActiveAttribReturn::partialEq(const GetActiveAttribReturn& b) const {
    return AzGetActiveAttribReturn_partialEq(&inner_, b.ptr());
}

inline uint64_t GetActiveAttribReturn::hash() const {
    return AzGetActiveAttribReturn_hash(&inner_);
}

inline uint8_t GetActiveAttribReturn::partialCmp(const GetActiveAttribReturn& b) const {
    return AzGetActiveAttribReturn_partialCmp(&inner_, b.ptr());
}

inline uint8_t GetActiveAttribReturn::cmp(const GetActiveAttribReturn& b) const {
    return AzGetActiveAttribReturn_cmp(&inner_, b.ptr());
}

inline String GetActiveAttribReturn::toDbgString() const {
    return String(AzGetActiveAttribReturn_toDbgString(&inner_));
}

inline void GetActiveUniformReturn::delete_() {
    AzGetActiveUniformReturn_delete(&inner_);
}

inline GetActiveUniformReturn GetActiveUniformReturn::clone() const {
    return GetActiveUniformReturn(AzGetActiveUniformReturn_clone(&inner_));
}

inline bool GetActiveUniformReturn::partialEq(const GetActiveUniformReturn& b) const {
    return AzGetActiveUniformReturn_partialEq(&inner_, b.ptr());
}

inline uint64_t GetActiveUniformReturn::hash() const {
    return AzGetActiveUniformReturn_hash(&inner_);
}

inline uint8_t GetActiveUniformReturn::partialCmp(const GetActiveUniformReturn& b) const {
    return AzGetActiveUniformReturn_partialCmp(&inner_, b.ptr());
}

inline uint8_t GetActiveUniformReturn::cmp(const GetActiveUniformReturn& b) const {
    return AzGetActiveUniformReturn_cmp(&inner_, b.ptr());
}

inline String GetActiveUniformReturn::toDbgString() const {
    return String(AzGetActiveUniformReturn_toDbgString(&inner_));
}

inline void VertexArrayObject::delete_() {
    AzVertexArrayObject_delete(&inner_);
}

inline VertexArrayObject VertexArrayObject::clone() const {
    return VertexArrayObject(AzVertexArrayObject_clone(&inner_));
}

inline bool VertexArrayObject::partialEq(const VertexArrayObject& b) const {
    return AzVertexArrayObject_partialEq(&inner_, b.ptr());
}

inline uint8_t VertexArrayObject::partialCmp(const VertexArrayObject& b) const {
    return AzVertexArrayObject_partialCmp(&inner_, b.ptr());
}

inline String VertexArrayObject::toDbgString() const {
    return String(AzVertexArrayObject_toDbgString(&inner_));
}

inline void DebugMessage::delete_() {
    AzDebugMessage_delete(&inner_);
}

inline DebugMessage DebugMessage::clone() const {
    return DebugMessage(AzDebugMessage_clone(&inner_));
}

inline bool DebugMessage::partialEq(const DebugMessage& b) const {
    return AzDebugMessage_partialEq(&inner_, b.ptr());
}

inline uint64_t DebugMessage::hash() const {
    return AzDebugMessage_hash(&inner_);
}

inline uint8_t DebugMessage::partialCmp(const DebugMessage& b) const {
    return AzDebugMessage_partialCmp(&inner_, b.ptr());
}

inline uint8_t DebugMessage::cmp(const DebugMessage& b) const {
    return AzDebugMessage_cmp(&inner_, b.ptr());
}

inline String DebugMessage::toDbgString() const {
    return String(AzDebugMessage_toDbgString(&inner_));
}

inline RawImage RawImage::empty() {
    return RawImage(AzRawImage_empty());
}

inline RawImage RawImage::allocate_clip_mask(LayoutSize size) {
    return RawImage(AzRawImage_allocateClipMask(size.release()));
}

inline ResultRawImageDecodeImageError RawImage::decode_image_bytes_any(U8VecRef bytes) {
    return ResultRawImageDecodeImageError(AzRawImage_decodeImageBytesAny(bytes.release()));
}

inline ResultU8VecEncodeImageError RawImage::encode_bmp() const {
    return ResultU8VecEncodeImageError(AzRawImage_encodeBmp(&inner_));
}

inline ResultU8VecEncodeImageError RawImage::encode_png() const {
    return ResultU8VecEncodeImageError(AzRawImage_encodePng(&inner_));
}

inline ResultU8VecEncodeImageError RawImage::encode_jpeg(uint8_t quality) const {
    return ResultU8VecEncodeImageError(AzRawImage_encodeJpeg(&inner_, quality));
}

inline ResultU8VecEncodeImageError RawImage::encode_tga() const {
    return ResultU8VecEncodeImageError(AzRawImage_encodeTga(&inner_));
}

inline ResultU8VecEncodeImageError RawImage::encode_pnm() const {
    return ResultU8VecEncodeImageError(AzRawImage_encodePnm(&inner_));
}

inline ResultU8VecEncodeImageError RawImage::encode_gif() const {
    return ResultU8VecEncodeImageError(AzRawImage_encodeGif(&inner_));
}

inline ResultU8VecEncodeImageError RawImage::encode_tiff() const {
    return ResultU8VecEncodeImageError(AzRawImage_encodeTiff(&inner_));
}

inline void RawImage::delete_() {
    AzRawImage_delete(&inner_);
}

inline RawImage RawImage::clone() const {
    return RawImage(AzRawImage_clone(&inner_));
}

inline bool RawImage::partialEq(const RawImage& b) const {
    return AzRawImage_partialEq(&inner_, b.ptr());
}

inline uint8_t RawImage::partialCmp(const RawImage& b) const {
    return AzRawImage_partialCmp(&inner_, b.ptr());
}

inline String RawImage::toDbgString() const {
    return String(AzRawImage_toDbgString(&inner_));
}

inline void Route::delete_() {
    AzRoute_delete(&inner_);
}

inline Route Route::clone() const {
    return Route(AzRoute_clone(&inner_));
}

inline bool Route::partialEq(const Route& b) const {
    return AzRoute_partialEq(&inner_, b.ptr());
}

inline uint64_t Route::hash() const {
    return AzRoute_hash(&inner_);
}

inline uint8_t Route::partialCmp(const Route& b) const {
    return AzRoute_partialCmp(&inner_, b.ptr());
}

inline uint8_t Route::cmp(const Route& b) const {
    return AzRoute_cmp(&inner_, b.ptr());
}

inline String Route::toDbgString() const {
    return String(AzRoute_toDbgString(&inner_));
}

inline void RouteMatch::delete_() {
    AzRouteMatch_delete(&inner_);
}

inline RouteMatch RouteMatch::clone() const {
    return RouteMatch(AzRouteMatch_clone(&inner_));
}

inline bool RouteMatch::partialEq(const RouteMatch& b) const {
    return AzRouteMatch_partialEq(&inner_, b.ptr());
}

inline uint64_t RouteMatch::hash() const {
    return AzRouteMatch_hash(&inner_);
}

inline uint8_t RouteMatch::partialCmp(const RouteMatch& b) const {
    return AzRouteMatch_partialCmp(&inner_, b.ptr());
}

inline uint8_t RouteMatch::cmp(const RouteMatch& b) const {
    return AzRouteMatch_cmp(&inner_, b.ptr());
}

inline String RouteMatch::toDbgString() const {
    return String(AzRouteMatch_toDbgString(&inner_));
}

inline LoadedFont LoadedFont::new_(uint64_t font_hash, String family_name, uint32_t num_glyphs, bool has_bytes) {
    return LoadedFont(AzLoadedFont_new(font_hash, family_name.release(), num_glyphs, has_bytes));
}

inline void LoadedFont::delete_() {
    AzLoadedFont_delete(&inner_);
}

inline LoadedFont LoadedFont::clone() const {
    return LoadedFont(AzLoadedFont_clone(&inner_));
}

inline bool LoadedFont::partialEq(const LoadedFont& b) const {
    return AzLoadedFont_partialEq(&inner_, b.ptr());
}

inline uint64_t LoadedFont::hash() const {
    return AzLoadedFont_hash(&inner_);
}

inline uint8_t LoadedFont::partialCmp(const LoadedFont& b) const {
    return AzLoadedFont_partialCmp(&inner_, b.ptr());
}

inline uint8_t LoadedFont::cmp(const LoadedFont& b) const {
    return AzLoadedFont_cmp(&inner_, b.ptr());
}

inline String LoadedFont::toDbgString() const {
    return String(AzLoadedFont_toDbgString(&inner_));
}

inline FilePath FilePath::create(String path) {
    return FilePath(AzFilePath_create(path.release()));
}

inline FilePath FilePath::empty() {
    return FilePath(AzFilePath_empty());
}

inline FilePath FilePath::from_str(String s) {
    return FilePath(AzFilePath_fromStr(s.release()));
}

inline FilePath FilePath::get_temp_dir() {
    return FilePath(AzFilePath_getTempDir());
}

inline FilePath FilePath::from(String s) {
    return FilePath(AzFilePath_from(s.release()));
}

inline FilePath FilePath::default_() {
    return FilePath(AzFilePath_default());
}

inline ResultFilePathFileError FilePath::get_current_dir() {
    return ResultFilePathFileError(AzFilePath_getCurrentDir());
}

inline OptionFilePath FilePath::get_home_dir() {
    return OptionFilePath(AzFilePath_getHomeDir());
}

inline OptionFilePath FilePath::get_cache_dir() {
    return OptionFilePath(AzFilePath_getCacheDir());
}

inline OptionFilePath FilePath::get_config_dir() {
    return OptionFilePath(AzFilePath_getConfigDir());
}

inline OptionFilePath FilePath::get_config_local_dir() {
    return OptionFilePath(AzFilePath_getConfigLocalDir());
}

inline OptionFilePath FilePath::get_data_dir() {
    return OptionFilePath(AzFilePath_getDataDir());
}

inline OptionFilePath FilePath::get_data_local_dir() {
    return OptionFilePath(AzFilePath_getDataLocalDir());
}

inline OptionFilePath FilePath::get_desktop_dir() {
    return OptionFilePath(AzFilePath_getDesktopDir());
}

inline OptionFilePath FilePath::get_document_dir() {
    return OptionFilePath(AzFilePath_getDocumentDir());
}

inline OptionFilePath FilePath::get_download_dir() {
    return OptionFilePath(AzFilePath_getDownloadDir());
}

inline OptionFilePath FilePath::get_executable_dir() {
    return OptionFilePath(AzFilePath_getExecutableDir());
}

inline OptionFilePath FilePath::get_font_dir() {
    return OptionFilePath(AzFilePath_getFontDir());
}

inline OptionFilePath FilePath::get_picture_dir() {
    return OptionFilePath(AzFilePath_getPictureDir());
}

inline OptionFilePath FilePath::get_preference_dir() {
    return OptionFilePath(AzFilePath_getPreferenceDir());
}

inline OptionFilePath FilePath::get_public_dir() {
    return OptionFilePath(AzFilePath_getPublicDir());
}

inline OptionFilePath FilePath::get_runtime_dir() {
    return OptionFilePath(AzFilePath_getRuntimeDir());
}

inline OptionFilePath FilePath::get_state_dir() {
    return OptionFilePath(AzFilePath_getStateDir());
}

inline OptionFilePath FilePath::get_audio_dir() {
    return OptionFilePath(AzFilePath_getAudioDir());
}

inline OptionFilePath FilePath::get_video_dir() {
    return OptionFilePath(AzFilePath_getVideoDir());
}

inline OptionFilePath FilePath::get_template_dir() {
    return OptionFilePath(AzFilePath_getTemplateDir());
}

inline FilePath FilePath::join(FilePath other) const {
    return FilePath(AzFilePath_join(&inner_, other.release()));
}

inline FilePath FilePath::join_str(String component) const {
    return FilePath(AzFilePath_joinStr(&inner_, component.release()));
}

inline OptionFilePath FilePath::parent() const {
    return OptionFilePath(AzFilePath_parent(&inner_));
}

inline OptionString FilePath::file_name() const {
    return OptionString(AzFilePath_fileName(&inner_));
}

inline OptionString FilePath::extension() const {
    return OptionString(AzFilePath_extension(&inner_));
}

inline bool FilePath::exists() const {
    return AzFilePath_exists(&inner_);
}

inline bool FilePath::is_file() const {
    return AzFilePath_isFile(&inner_);
}

inline bool FilePath::is_dir() const {
    return AzFilePath_isDir(&inner_);
}

inline bool FilePath::is_absolute() const {
    return AzFilePath_isAbsolute(&inner_);
}

inline ResultEmptyStructFileError FilePath::create_dir_all() const {
    return ResultEmptyStructFileError(AzFilePath_createDirAll(&inner_));
}

inline ResultEmptyStructFileError FilePath::create_dir() const {
    return ResultEmptyStructFileError(AzFilePath_createDir(&inner_));
}

inline ResultEmptyStructFileError FilePath::remove_file() const {
    return ResultEmptyStructFileError(AzFilePath_removeFile(&inner_));
}

inline ResultEmptyStructFileError FilePath::remove_dir() const {
    return ResultEmptyStructFileError(AzFilePath_removeDir(&inner_));
}

inline ResultEmptyStructFileError FilePath::remove_dir_all() const {
    return ResultEmptyStructFileError(AzFilePath_removeDirAll(&inner_));
}

inline ResultU8VecFileError FilePath::read_bytes() const {
    return ResultU8VecFileError(AzFilePath_readBytes(&inner_));
}

inline ResultStringFileError FilePath::read_string() const {
    return ResultStringFileError(AzFilePath_readString(&inner_));
}

inline ResultEmptyStructFileError FilePath::write_bytes(U8Vec data) const {
    return ResultEmptyStructFileError(AzFilePath_writeBytes(&inner_, data.release()));
}

inline ResultEmptyStructFileError FilePath::write_string(String data) const {
    return ResultEmptyStructFileError(AzFilePath_writeString(&inner_, data.release()));
}

inline Resultu64FileError FilePath::copy_to(FilePath dest) const {
    return Resultu64FileError(AzFilePath_copyTo(&inner_, dest.release()));
}

inline ResultEmptyStructFileError FilePath::rename_to(FilePath dest) const {
    return ResultEmptyStructFileError(AzFilePath_renameTo(&inner_, dest.release()));
}

inline String FilePath::as_string() const {
    return String(AzFilePath_asString(&inner_));
}

inline ResultDirEntryVecFileError FilePath::read_dir() const {
    return ResultDirEntryVecFileError(AzFilePath_readDir(&inner_));
}

inline ResultFileMetadataFileError FilePath::metadata() const {
    return ResultFileMetadataFileError(AzFilePath_metadata(&inner_));
}

inline ResultFilePathFileError FilePath::canonicalize() const {
    return ResultFilePathFileError(AzFilePath_canonicalize(&inner_));
}

inline void FilePath::delete_() {
    AzFilePath_delete(&inner_);
}

inline FilePath FilePath::clone() const {
    return FilePath(AzFilePath_clone(&inner_));
}

inline bool FilePath::partialEq(const FilePath& b) const {
    return AzFilePath_partialEq(&inner_, b.ptr());
}

inline uint64_t FilePath::hash() const {
    return AzFilePath_hash(&inner_);
}

inline String FilePath::toDbgString() const {
    return String(AzFilePath_toDbgString(&inner_));
}

inline StringPair StringPair::default_() {
    return StringPair(AzStringPair_default());
}

inline void StringPair::delete_() {
    AzStringPair_delete(&inner_);
}

inline StringPair StringPair::clone() const {
    return StringPair(AzStringPair_clone(&inner_));
}

inline bool StringPair::partialEq(const StringPair& b) const {
    return AzStringPair_partialEq(&inner_, b.ptr());
}

inline uint64_t StringPair::hash() const {
    return AzStringPair_hash(&inner_);
}

inline uint8_t StringPair::partialCmp(const StringPair& b) const {
    return AzStringPair_partialCmp(&inner_, b.ptr());
}

inline uint8_t StringPair::cmp(const StringPair& b) const {
    return AzStringPair_cmp(&inner_, b.ptr());
}

inline String StringPair::toDbgString() const {
    return String(AzStringPair_toDbgString(&inner_));
}

inline StringSet StringSet::default_() {
    return StringSet(AzStringSet_default());
}

inline void StringSet::delete_() {
    AzStringSet_delete(&inner_);
}

inline StringSet StringSet::clone() const {
    return StringSet(AzStringSet_clone(&inner_));
}

inline bool StringSet::partialEq(const StringSet& b) const {
    return AzStringSet_partialEq(&inner_, b.ptr());
}

inline uint64_t StringSet::hash() const {
    return AzStringSet_hash(&inner_);
}

inline uint8_t StringSet::partialCmp(const StringSet& b) const {
    return AzStringSet_partialCmp(&inner_, b.ptr());
}

inline uint8_t StringSet::cmp(const StringSet& b) const {
    return AzStringSet_cmp(&inner_, b.ptr());
}

inline String StringSet::toDbgString() const {
    return String(AzStringSet_toDbgString(&inner_));
}

inline void DuplicatedNamespaceError::delete_() {
    AzDuplicatedNamespaceError_delete(&inner_);
}

inline DuplicatedNamespaceError DuplicatedNamespaceError::clone() const {
    return DuplicatedNamespaceError(AzDuplicatedNamespaceError_clone(&inner_));
}

inline bool DuplicatedNamespaceError::partialEq(const DuplicatedNamespaceError& b) const {
    return AzDuplicatedNamespaceError_partialEq(&inner_, b.ptr());
}

inline uint8_t DuplicatedNamespaceError::partialCmp(const DuplicatedNamespaceError& b) const {
    return AzDuplicatedNamespaceError_partialCmp(&inner_, b.ptr());
}

inline String DuplicatedNamespaceError::toDbgString() const {
    return String(AzDuplicatedNamespaceError_toDbgString(&inner_));
}

inline void UnknownNamespaceError::delete_() {
    AzUnknownNamespaceError_delete(&inner_);
}

inline UnknownNamespaceError UnknownNamespaceError::clone() const {
    return UnknownNamespaceError(AzUnknownNamespaceError_clone(&inner_));
}

inline bool UnknownNamespaceError::partialEq(const UnknownNamespaceError& b) const {
    return AzUnknownNamespaceError_partialEq(&inner_, b.ptr());
}

inline uint8_t UnknownNamespaceError::partialCmp(const UnknownNamespaceError& b) const {
    return AzUnknownNamespaceError_partialCmp(&inner_, b.ptr());
}

inline String UnknownNamespaceError::toDbgString() const {
    return String(AzUnknownNamespaceError_toDbgString(&inner_));
}

inline void UnexpectedCloseTagError::delete_() {
    AzUnexpectedCloseTagError_delete(&inner_);
}

inline UnexpectedCloseTagError UnexpectedCloseTagError::clone() const {
    return UnexpectedCloseTagError(AzUnexpectedCloseTagError_clone(&inner_));
}

inline bool UnexpectedCloseTagError::partialEq(const UnexpectedCloseTagError& b) const {
    return AzUnexpectedCloseTagError_partialEq(&inner_, b.ptr());
}

inline uint8_t UnexpectedCloseTagError::partialCmp(const UnexpectedCloseTagError& b) const {
    return AzUnexpectedCloseTagError_partialCmp(&inner_, b.ptr());
}

inline String UnexpectedCloseTagError::toDbgString() const {
    return String(AzUnexpectedCloseTagError_toDbgString(&inner_));
}

inline void UnknownEntityReferenceError::delete_() {
    AzUnknownEntityReferenceError_delete(&inner_);
}

inline UnknownEntityReferenceError UnknownEntityReferenceError::clone() const {
    return UnknownEntityReferenceError(AzUnknownEntityReferenceError_clone(&inner_));
}

inline bool UnknownEntityReferenceError::partialEq(const UnknownEntityReferenceError& b) const {
    return AzUnknownEntityReferenceError_partialEq(&inner_, b.ptr());
}

inline uint8_t UnknownEntityReferenceError::partialCmp(const UnknownEntityReferenceError& b) const {
    return AzUnknownEntityReferenceError_partialCmp(&inner_, b.ptr());
}

inline String UnknownEntityReferenceError::toDbgString() const {
    return String(AzUnknownEntityReferenceError_toDbgString(&inner_));
}

inline void DuplicatedAttributeError::delete_() {
    AzDuplicatedAttributeError_delete(&inner_);
}

inline DuplicatedAttributeError DuplicatedAttributeError::clone() const {
    return DuplicatedAttributeError(AzDuplicatedAttributeError_clone(&inner_));
}

inline bool DuplicatedAttributeError::partialEq(const DuplicatedAttributeError& b) const {
    return AzDuplicatedAttributeError_partialEq(&inner_, b.ptr());
}

inline uint8_t DuplicatedAttributeError::partialCmp(const DuplicatedAttributeError& b) const {
    return AzDuplicatedAttributeError_partialCmp(&inner_, b.ptr());
}

inline String DuplicatedAttributeError::toDbgString() const {
    return String(AzDuplicatedAttributeError_toDbgString(&inner_));
}

inline void InvalidStringError::delete_() {
    AzInvalidStringError_delete(&inner_);
}

inline InvalidStringError InvalidStringError::clone() const {
    return InvalidStringError(AzInvalidStringError_clone(&inner_));
}

inline bool InvalidStringError::partialEq(const InvalidStringError& b) const {
    return AzInvalidStringError_partialEq(&inner_, b.ptr());
}

inline uint8_t InvalidStringError::partialCmp(const InvalidStringError& b) const {
    return AzInvalidStringError_partialCmp(&inner_, b.ptr());
}

inline String InvalidStringError::toDbgString() const {
    return String(AzInvalidStringError_toDbgString(&inner_));
}

inline void MalformedHierarchyError::delete_() {
    AzMalformedHierarchyError_delete(&inner_);
}

inline MalformedHierarchyError MalformedHierarchyError::clone() const {
    return MalformedHierarchyError(AzMalformedHierarchyError_clone(&inner_));
}

inline bool MalformedHierarchyError::partialEq(const MalformedHierarchyError& b) const {
    return AzMalformedHierarchyError_partialEq(&inner_, b.ptr());
}

inline uint8_t MalformedHierarchyError::partialCmp(const MalformedHierarchyError& b) const {
    return AzMalformedHierarchyError_partialCmp(&inner_, b.ptr());
}

inline String MalformedHierarchyError::toDbgString() const {
    return String(AzMalformedHierarchyError_toDbgString(&inner_));
}

inline void SelectAllResult::delete_() {
    AzSelectAllResult_delete(&inner_);
}

inline SelectAllResult SelectAllResult::clone() const {
    return SelectAllResult(AzSelectAllResult_clone(&inner_));
}

inline bool SelectAllResult::partialEq(const SelectAllResult& b) const {
    return AzSelectAllResult_partialEq(&inner_, b.ptr());
}

inline String SelectAllResult::toDbgString() const {
    return String(AzSelectAllResult_toDbgString(&inner_));
}

inline void DeleteResult::delete_() {
    AzDeleteResult_delete(&inner_);
}

inline DeleteResult DeleteResult::clone() const {
    return DeleteResult(AzDeleteResult_clone(&inner_));
}

inline bool DeleteResult::partialEq(const DeleteResult& b) const {
    return AzDeleteResult_partialEq(&inner_, b.ptr());
}

inline String DeleteResult::toDbgString() const {
    return String(AzDeleteResult_toDbgString(&inner_));
}

inline void IcuError::delete_() {
    AzIcuError_delete(&inner_);
}

inline IcuError IcuError::clone() const {
    return IcuError(AzIcuError_clone(&inner_));
}

inline bool IcuError::partialEq(const IcuError& b) const {
    return AzIcuError_partialEq(&inner_, b.ptr());
}

inline String IcuError::toDbgString() const {
    return String(AzIcuError_toDbgString(&inner_));
}

inline void HttpStatusError::delete_() {
    AzHttpStatusError_delete(&inner_);
}

inline HttpStatusError HttpStatusError::clone() const {
    return HttpStatusError(AzHttpStatusError_clone(&inner_));
}

inline bool HttpStatusError::partialEq(const HttpStatusError& b) const {
    return AzHttpStatusError_partialEq(&inner_, b.ptr());
}

inline String HttpStatusError::toDbgString() const {
    return String(AzHttpStatusError_toDbgString(&inner_));
}

inline void FileError::delete_() {
    AzFileError_delete(&inner_);
}

inline FileError FileError::clone() const {
    return FileError(AzFileError_clone(&inner_));
}

inline bool FileError::partialEq(const FileError& b) const {
    return AzFileError_partialEq(&inner_, b.ptr());
}

inline String FileError::toDbgString() const {
    return String(AzFileError_toDbgString(&inner_));
}

inline void JsonParseError::delete_() {
    AzJsonParseError_delete(&inner_);
}

inline JsonParseError JsonParseError::clone() const {
    return JsonParseError(AzJsonParseError_clone(&inner_));
}

inline bool JsonParseError::partialEq(const JsonParseError& b) const {
    return AzJsonParseError_partialEq(&inner_, b.ptr());
}

inline String JsonParseError::toDbgString() const {
    return String(AzJsonParseError_toDbgString(&inner_));
}

inline void UrlParseError::delete_() {
    AzUrlParseError_delete(&inner_);
}

inline UrlParseError UrlParseError::clone() const {
    return UrlParseError(AzUrlParseError_clone(&inner_));
}

inline bool UrlParseError::partialEq(const UrlParseError& b) const {
    return AzUrlParseError_partialEq(&inner_, b.ptr());
}

inline String UrlParseError::toDbgString() const {
    return String(AzUrlParseError_toDbgString(&inner_));
}

inline void PixelNoValueGivenError::delete_() {
    AzPixelNoValueGivenError_delete(&inner_);
}

inline PixelNoValueGivenError PixelNoValueGivenError::clone() const {
    return PixelNoValueGivenError(AzPixelNoValueGivenError_clone(&inner_));
}

inline bool PixelNoValueGivenError::partialEq(const PixelNoValueGivenError& b) const {
    return AzPixelNoValueGivenError_partialEq(&inner_, b.ptr());
}

inline String PixelNoValueGivenError::toDbgString() const {
    return String(AzPixelNoValueGivenError_toDbgString(&inner_));
}

inline void VarOnShorthandPropertyError::delete_() {
    AzVarOnShorthandPropertyError_delete(&inner_);
}

inline VarOnShorthandPropertyError VarOnShorthandPropertyError::clone() const {
    return VarOnShorthandPropertyError(AzVarOnShorthandPropertyError_clone(&inner_));
}

inline bool VarOnShorthandPropertyError::partialEq(const VarOnShorthandPropertyError& b) const {
    return AzVarOnShorthandPropertyError_partialEq(&inner_, b.ptr());
}

inline String VarOnShorthandPropertyError::toDbgString() const {
    return String(AzVarOnShorthandPropertyError_toDbgString(&inner_));
}

inline void WrongComponentCountError::delete_() {
    AzWrongComponentCountError_delete(&inner_);
}

inline WrongComponentCountError WrongComponentCountError::clone() const {
    return WrongComponentCountError(AzWrongComponentCountError_clone(&inner_));
}

inline bool WrongComponentCountError::partialEq(const WrongComponentCountError& b) const {
    return AzWrongComponentCountError_partialEq(&inner_, b.ptr());
}

inline String WrongComponentCountError::toDbgString() const {
    return String(AzWrongComponentCountError_toDbgString(&inner_));
}

inline void AngleNoValueGivenError::delete_() {
    AzAngleNoValueGivenError_delete(&inner_);
}

inline AngleNoValueGivenError AngleNoValueGivenError::clone() const {
    return AngleNoValueGivenError(AzAngleNoValueGivenError_clone(&inner_));
}

inline bool AngleNoValueGivenError::partialEq(const AngleNoValueGivenError& b) const {
    return AzAngleNoValueGivenError_partialEq(&inner_, b.ptr());
}

inline String AngleNoValueGivenError::toDbgString() const {
    return String(AzAngleNoValueGivenError_toDbgString(&inner_));
}

inline void WhiteSpaceInComponentNameError::delete_() {
    AzWhiteSpaceInComponentNameError_delete(&inner_);
}

inline WhiteSpaceInComponentNameError WhiteSpaceInComponentNameError::clone() const {
    return WhiteSpaceInComponentNameError(AzWhiteSpaceInComponentNameError_clone(&inner_));
}

inline bool WhiteSpaceInComponentNameError::partialEq(const WhiteSpaceInComponentNameError& b) const {
    return AzWhiteSpaceInComponentNameError_partialEq(&inner_, b.ptr());
}

inline String WhiteSpaceInComponentNameError::toDbgString() const {
    return String(AzWhiteSpaceInComponentNameError_toDbgString(&inner_));
}

inline void WhiteSpaceInComponentTypeError::delete_() {
    AzWhiteSpaceInComponentTypeError_delete(&inner_);
}

inline WhiteSpaceInComponentTypeError WhiteSpaceInComponentTypeError::clone() const {
    return WhiteSpaceInComponentTypeError(AzWhiteSpaceInComponentTypeError_clone(&inner_));
}

inline bool WhiteSpaceInComponentTypeError::partialEq(const WhiteSpaceInComponentTypeError& b) const {
    return AzWhiteSpaceInComponentTypeError_partialEq(&inner_, b.ptr());
}

inline String WhiteSpaceInComponentTypeError::toDbgString() const {
    return String(AzWhiteSpaceInComponentTypeError_toDbgString(&inner_));
}

inline void UnknownPropertyKeyError::delete_() {
    AzUnknownPropertyKeyError_delete(&inner_);
}

inline UnknownPropertyKeyError UnknownPropertyKeyError::clone() const {
    return UnknownPropertyKeyError(AzUnknownPropertyKeyError_clone(&inner_));
}

inline bool UnknownPropertyKeyError::partialEq(const UnknownPropertyKeyError& b) const {
    return AzUnknownPropertyKeyError_partialEq(&inner_, b.ptr());
}

inline String UnknownPropertyKeyError::toDbgString() const {
    return String(AzUnknownPropertyKeyError_toDbgString(&inner_));
}

inline void UselessFunctionArgumentError::delete_() {
    AzUselessFunctionArgumentError_delete(&inner_);
}

inline UselessFunctionArgumentError UselessFunctionArgumentError::clone() const {
    return UselessFunctionArgumentError(AzUselessFunctionArgumentError_clone(&inner_));
}

inline bool UselessFunctionArgumentError::partialEq(const UselessFunctionArgumentError& b) const {
    return AzUselessFunctionArgumentError_partialEq(&inner_, b.ptr());
}

inline uint64_t UselessFunctionArgumentError::hash() const {
    return AzUselessFunctionArgumentError_hash(&inner_);
}

inline uint8_t UselessFunctionArgumentError::partialCmp(const UselessFunctionArgumentError& b) const {
    return AzUselessFunctionArgumentError_partialCmp(&inner_, b.ptr());
}

inline uint8_t UselessFunctionArgumentError::cmp(const UselessFunctionArgumentError& b) const {
    return AzUselessFunctionArgumentError_cmp(&inner_, b.ptr());
}

inline String UselessFunctionArgumentError::toDbgString() const {
    return String(AzUselessFunctionArgumentError_toDbgString(&inner_));
}

inline void MissingTypeError::delete_() {
    AzMissingTypeError_delete(&inner_);
}

inline MissingTypeError MissingTypeError::clone() const {
    return MissingTypeError(AzMissingTypeError_clone(&inner_));
}

inline bool MissingTypeError::partialEq(const MissingTypeError& b) const {
    return AzMissingTypeError_partialEq(&inner_, b.ptr());
}

inline String MissingTypeError::toDbgString() const {
    return String(AzMissingTypeError_toDbgString(&inner_));
}

inline void MapPinTap::delete_() {
    AzMapPinTap_delete(&inner_);
}

inline MapPinTap MapPinTap::clone() const {
    return MapPinTap(AzMapPinTap_clone(&inner_));
}

inline bool MapPinTap::partialEq(const MapPinTap& b) const {
    return AzMapPinTap_partialEq(&inner_, b.ptr());
}

inline uint64_t MapPinTap::hash() const {
    return AzMapPinTap_hash(&inner_);
}

inline uint8_t MapPinTap::partialCmp(const MapPinTap& b) const {
    return AzMapPinTap_partialCmp(&inner_, b.ptr());
}

inline uint8_t MapPinTap::cmp(const MapPinTap& b) const {
    return AzMapPinTap_cmp(&inner_, b.ptr());
}

inline String MapPinTap::toDbgString() const {
    return String(AzMapPinTap_toDbgString(&inner_));
}

inline ThreadWriteBackMsg ThreadWriteBackMsg::create(AzWriteBackCallbackType callback, RefAny data) {
    return ThreadWriteBackMsg(AzThreadWriteBackMsg_create(az_detail_wrap_cb<AzWriteBackCallback>(callback), data.release()));
}

inline void ThreadWriteBackMsg::delete_() {
    AzThreadWriteBackMsg_delete(&inner_);
}

inline ThreadWriteBackMsg ThreadWriteBackMsg::clone() const {
    return ThreadWriteBackMsg(AzThreadWriteBackMsg_clone(&inner_));
}

inline bool ThreadWriteBackMsg::partialEq(const ThreadWriteBackMsg& b) const {
    return AzThreadWriteBackMsg_partialEq(&inner_, b.ptr());
}

inline uint64_t ThreadWriteBackMsg::hash() const {
    return AzThreadWriteBackMsg_hash(&inner_);
}

inline uint8_t ThreadWriteBackMsg::partialCmp(const ThreadWriteBackMsg& b) const {
    return AzThreadWriteBackMsg_partialCmp(&inner_, b.ptr());
}

inline uint8_t ThreadWriteBackMsg::cmp(const ThreadWriteBackMsg& b) const {
    return AzThreadWriteBackMsg_cmp(&inner_, b.ptr());
}

inline String ThreadWriteBackMsg::toDbgString() const {
    return String(AzThreadWriteBackMsg_toDbgString(&inner_));
}

inline Url Url::from_parts(String scheme, String host, uint16_t port, String path) {
    return Url(AzUrl_fromParts(scheme.release(), host.release(), port, path.release()));
}

inline ResultUrlUrlParseError Url::parse(String s) {
    return ResultUrlUrlParseError(AzUrl_parse(s.release()));
}

inline String Url::to_string() const {
    return String(AzUrl_toString(&inner_));
}

inline bool Url::is_https() const {
    return AzUrl_isHttps(&inner_);
}

inline bool Url::is_http() const {
    return AzUrl_isHttp(&inner_);
}

inline uint16_t Url::effective_port() const {
    return AzUrl_effectivePort(&inner_);
}

inline ResultUrlUrlParseError Url::join(String path) const {
    return ResultUrlUrlParseError(AzUrl_join(&inner_, path.release()));
}

inline void Url::delete_() {
    AzUrl_delete(&inner_);
}

inline Url Url::clone() const {
    return Url(AzUrl_clone(&inner_));
}

inline bool Url::partialEq(const Url& b) const {
    return AzUrl_partialEq(&inner_, b.ptr());
}

inline uint64_t Url::hash() const {
    return AzUrl_hash(&inner_);
}

inline String Url::toDbgString() const {
    return String(AzUrl_toDbgString(&inner_));
}

inline JsonInternal JsonInternal::default_() {
    return JsonInternal(AzJsonInternal_default());
}

inline void JsonInternal::delete_() {
    AzJsonInternal_delete(&inner_);
}

inline JsonInternal JsonInternal::clone() const {
    return JsonInternal(AzJsonInternal_clone(&inner_));
}

inline bool JsonInternal::partialEq(const JsonInternal& b) const {
    return AzJsonInternal_partialEq(&inner_, b.ptr());
}

inline String JsonInternal::toDbgString() const {
    return String(AzJsonInternal_toDbgString(&inner_));
}

inline void DirEntry::delete_() {
    AzDirEntry_delete(&inner_);
}

inline DirEntry DirEntry::clone() const {
    return DirEntry(AzDirEntry_clone(&inner_));
}

inline String DirEntry::toDbgString() const {
    return String(AzDirEntry_toDbgString(&inner_));
}

inline BiometricPrompt BiometricPrompt::default_() {
    return BiometricPrompt(AzBiometricPrompt_default());
}

inline void BiometricPrompt::delete_() {
    AzBiometricPrompt_delete(&inner_);
}

inline BiometricPrompt BiometricPrompt::clone() const {
    return BiometricPrompt(AzBiometricPrompt_clone(&inner_));
}

inline bool BiometricPrompt::partialEq(const BiometricPrompt& b) const {
    return AzBiometricPrompt_partialEq(&inner_, b.ptr());
}

inline String BiometricPrompt::toDbgString() const {
    return String(AzBiometricPrompt_toDbgString(&inner_));
}

inline VideoConfig VideoConfig::default_() {
    return VideoConfig(AzVideoConfig_default());
}

inline void VideoConfig::delete_() {
    AzVideoConfig_delete(&inner_);
}

inline VideoConfig VideoConfig::clone() const {
    return VideoConfig(AzVideoConfig_clone(&inner_));
}

inline bool VideoConfig::partialEq(const VideoConfig& b) const {
    return AzVideoConfig_partialEq(&inner_, b.ptr());
}

inline String VideoConfig::toDbgString() const {
    return String(AzVideoConfig_toDbgString(&inner_));
}

inline ComponentId ComponentId::builtin(String name) {
    return ComponentId(AzComponentId_builtin(name.release()));
}

inline ComponentId ComponentId::new_(String collection, String name) {
    return ComponentId(AzComponentId_new(collection.release(), name.release()));
}

inline String ComponentId::qualified_name() const {
    return String(AzComponentId_qualifiedName(&inner_));
}

inline void ComponentId::delete_() {
    AzComponentId_delete(&inner_);
}

inline ComponentId ComponentId::clone() const {
    return ComponentId(AzComponentId_clone(&inner_));
}

inline bool ComponentId::partialEq(const ComponentId& b) const {
    return AzComponentId_partialEq(&inner_, b.ptr());
}

inline uint64_t ComponentId::hash() const {
    return AzComponentId_hash(&inner_);
}

inline uint8_t ComponentId::partialCmp(const ComponentId& b) const {
    return AzComponentId_partialCmp(&inner_, b.ptr());
}

inline uint8_t ComponentId::cmp(const ComponentId& b) const {
    return AzComponentId_cmp(&inner_, b.ptr());
}

inline String ComponentId::toDbgString() const {
    return String(AzComponentId_toDbgString(&inner_));
}

inline void ComponentLibrary::delete_() {
    AzComponentLibrary_delete(&inner_);
}

inline ComponentLibrary ComponentLibrary::clone() const {
    return ComponentLibrary(AzComponentLibrary_clone(&inner_));
}

inline String ComponentLibrary::toDbgString() const {
    return String(AzComponentLibrary_toDbgString(&inner_));
}

inline void ComponentDataModel::delete_() {
    AzComponentDataModel_delete(&inner_);
}

inline ComponentDataModel ComponentDataModel::clone() const {
    return ComponentDataModel(AzComponentDataModel_clone(&inner_));
}

inline String ComponentDataModel::toDbgString() const {
    return String(AzComponentDataModel_toDbgString(&inner_));
}

inline void ComponentEnumVariant::delete_() {
    AzComponentEnumVariant_delete(&inner_);
}

inline ComponentEnumVariant ComponentEnumVariant::clone() const {
    return ComponentEnumVariant(AzComponentEnumVariant_clone(&inner_));
}

inline bool ComponentEnumVariant::partialEq(const ComponentEnumVariant& b) const {
    return AzComponentEnumVariant_partialEq(&inner_, b.ptr());
}

inline String ComponentEnumVariant::toDbgString() const {
    return String(AzComponentEnumVariant_toDbgString(&inner_));
}

inline void ComponentEnumModel::delete_() {
    AzComponentEnumModel_delete(&inner_);
}

inline ComponentEnumModel ComponentEnumModel::clone() const {
    return ComponentEnumModel(AzComponentEnumModel_clone(&inner_));
}

inline bool ComponentEnumModel::partialEq(const ComponentEnumModel& b) const {
    return AzComponentEnumModel_partialEq(&inner_, b.ptr());
}

inline String ComponentEnumModel::toDbgString() const {
    return String(AzComponentEnumModel_toDbgString(&inner_));
}

inline void ComponentInstanceDefault::delete_() {
    AzComponentInstanceDefault_delete(&inner_);
}

inline ComponentInstanceDefault ComponentInstanceDefault::clone() const {
    return ComponentInstanceDefault(AzComponentInstanceDefault_clone(&inner_));
}

inline bool ComponentInstanceDefault::partialEq(const ComponentInstanceDefault& b) const {
    return AzComponentInstanceDefault_partialEq(&inner_, b.ptr());
}

inline String ComponentInstanceDefault::toDbgString() const {
    return String(AzComponentInstanceDefault_toDbgString(&inner_));
}

inline void ComponentCallbackSignature::delete_() {
    AzComponentCallbackSignature_delete(&inner_);
}

inline ComponentCallbackSignature ComponentCallbackSignature::clone() const {
    return ComponentCallbackSignature(AzComponentCallbackSignature_clone(&inner_));
}

inline bool ComponentCallbackSignature::partialEq(const ComponentCallbackSignature& b) const {
    return AzComponentCallbackSignature_partialEq(&inner_, b.ptr());
}

inline uint64_t ComponentCallbackSignature::hash() const {
    return AzComponentCallbackSignature_hash(&inner_);
}

inline uint8_t ComponentCallbackSignature::partialCmp(const ComponentCallbackSignature& b) const {
    return AzComponentCallbackSignature_partialCmp(&inner_, b.ptr());
}

inline uint8_t ComponentCallbackSignature::cmp(const ComponentCallbackSignature& b) const {
    return AzComponentCallbackSignature_cmp(&inner_, b.ptr());
}

inline String ComponentCallbackSignature::toDbgString() const {
    return String(AzComponentCallbackSignature_toDbgString(&inner_));
}

inline Monitor Monitor::default_() {
    return Monitor(AzMonitor_default());
}

inline void Monitor::delete_() {
    AzMonitor_delete(&inner_);
}

inline Monitor Monitor::clone() const {
    return Monitor(AzMonitor_clone(&inner_));
}

inline bool Monitor::partialEq(const Monitor& b) const {
    return AzMonitor_partialEq(&inner_, b.ptr());
}

inline uint64_t Monitor::hash() const {
    return AzMonitor_hash(&inner_);
}

inline uint8_t Monitor::partialCmp(const Monitor& b) const {
    return AzMonitor_partialCmp(&inner_, b.ptr());
}

inline String Monitor::toDbgString() const {
    return String(AzMonitor_toDbgString(&inner_));
}

inline DialogAriaInfo DialogAriaInfo::create(String label) {
    return DialogAriaInfo(AzDialogAriaInfo_create(label.release()));
}

inline DialogAriaInfo DialogAriaInfo::with_modal(bool modal) const {
    return DialogAriaInfo(AzDialogAriaInfo_withModal(inner_, modal));
}

inline DialogAriaInfo DialogAriaInfo::with_described_by(String described_by) const {
    return DialogAriaInfo(AzDialogAriaInfo_withDescribedBy(inner_, described_by.release()));
}

inline DialogAriaInfo DialogAriaInfo::with_role(AzAccessibilityRole role) const {
    return DialogAriaInfo(AzDialogAriaInfo_withRole(inner_, role));
}

inline DialogAriaInfo DialogAriaInfo::with_description(String desc) const {
    return DialogAriaInfo(AzDialogAriaInfo_withDescription(inner_, desc.release()));
}

inline void DialogAriaInfo::delete_() {
    AzDialogAriaInfo_delete(&inner_);
}

inline DialogAriaInfo DialogAriaInfo::clone() const {
    return DialogAriaInfo(AzDialogAriaInfo_clone(&inner_));
}

inline bool DialogAriaInfo::partialEq(const DialogAriaInfo& b) const {
    return AzDialogAriaInfo_partialEq(&inner_, b.ptr());
}

inline String DialogAriaInfo::toDbgString() const {
    return String(AzDialogAriaInfo_toDbgString(&inner_));
}

inline void AccessibilityInfo::delete_() {
    AzAccessibilityInfo_delete(&inner_);
}

inline AccessibilityInfo AccessibilityInfo::clone() const {
    return AccessibilityInfo(AzAccessibilityInfo_clone(&inner_));
}

inline bool AccessibilityInfo::partialEq(const AccessibilityInfo& b) const {
    return AzAccessibilityInfo_partialEq(&inner_, b.ptr());
}

inline uint64_t AccessibilityInfo::hash() const {
    return AzAccessibilityInfo_hash(&inner_);
}

inline uint8_t AccessibilityInfo::partialCmp(const AccessibilityInfo& b) const {
    return AzAccessibilityInfo_partialCmp(&inner_, b.ptr());
}

inline uint8_t AccessibilityInfo::cmp(const AccessibilityInfo& b) const {
    return AzAccessibilityInfo_cmp(&inner_, b.ptr());
}

inline String AccessibilityInfo::toDbgString() const {
    return String(AzAccessibilityInfo_toDbgString(&inner_));
}

inline void DragState::delete_() {
    AzDragState_delete(&inner_);
}

inline DragState DragState::clone() const {
    return DragState(AzDragState_clone(&inner_));
}

inline bool DragState::partialEq(const DragState& b) const {
    return AzDragState_partialEq(&inner_, b.ptr());
}

inline String DragState::toDbgString() const {
    return String(AzDragState_toDbgString(&inner_));
}

inline SmallAriaInfo SmallAriaInfo::label(String text) {
    return SmallAriaInfo(AzSmallAriaInfo_label(text.release()));
}

inline SmallAriaInfo SmallAriaInfo::with_role(AzAccessibilityRole role) const {
    return SmallAriaInfo(AzSmallAriaInfo_withRole(inner_, role));
}

inline SmallAriaInfo SmallAriaInfo::with_description(String desc) const {
    return SmallAriaInfo(AzSmallAriaInfo_withDescription(inner_, desc.release()));
}

inline void SmallAriaInfo::delete_() {
    AzSmallAriaInfo_delete(&inner_);
}

inline SmallAriaInfo SmallAriaInfo::clone() const {
    return SmallAriaInfo(AzSmallAriaInfo_clone(&inner_));
}

inline bool SmallAriaInfo::partialEq(const SmallAriaInfo& b) const {
    return AzSmallAriaInfo_partialEq(&inner_, b.ptr());
}

inline uint64_t SmallAriaInfo::hash() const {
    return AzSmallAriaInfo_hash(&inner_);
}

inline String SmallAriaInfo::toDbgString() const {
    return String(AzSmallAriaInfo_toDbgString(&inner_));
}

inline ProgressAriaInfo ProgressAriaInfo::create(String label) {
    return ProgressAriaInfo(AzProgressAriaInfo_create(label.release()));
}

inline ProgressAriaInfo ProgressAriaInfo::with_current_value(float value) const {
    return ProgressAriaInfo(AzProgressAriaInfo_withCurrentValue(inner_, value));
}

inline ProgressAriaInfo ProgressAriaInfo::with_max(float max) const {
    return ProgressAriaInfo(AzProgressAriaInfo_withMax(inner_, max));
}

inline ProgressAriaInfo ProgressAriaInfo::with_indeterminate(bool indeterminate) const {
    return ProgressAriaInfo(AzProgressAriaInfo_withIndeterminate(inner_, indeterminate));
}

inline ProgressAriaInfo ProgressAriaInfo::with_description(String desc) const {
    return ProgressAriaInfo(AzProgressAriaInfo_withDescription(inner_, desc.release()));
}

inline void ProgressAriaInfo::delete_() {
    AzProgressAriaInfo_delete(&inner_);
}

inline ProgressAriaInfo ProgressAriaInfo::clone() const {
    return ProgressAriaInfo(AzProgressAriaInfo_clone(&inner_));
}

inline bool ProgressAriaInfo::partialEq(const ProgressAriaInfo& b) const {
    return AzProgressAriaInfo_partialEq(&inner_, b.ptr());
}

inline String ProgressAriaInfo::toDbgString() const {
    return String(AzProgressAriaInfo_toDbgString(&inner_));
}

inline MeterAriaInfo MeterAriaInfo::create(String label, float current_value, float min, float max) {
    return MeterAriaInfo(AzMeterAriaInfo_create(label.release(), current_value, min, max));
}

inline MeterAriaInfo MeterAriaInfo::with_low(float low) const {
    return MeterAriaInfo(AzMeterAriaInfo_withLow(inner_, low));
}

inline MeterAriaInfo MeterAriaInfo::with_high(float high) const {
    return MeterAriaInfo(AzMeterAriaInfo_withHigh(inner_, high));
}

inline MeterAriaInfo MeterAriaInfo::with_optimum(float optimum) const {
    return MeterAriaInfo(AzMeterAriaInfo_withOptimum(inner_, optimum));
}

inline MeterAriaInfo MeterAriaInfo::with_description(String desc) const {
    return MeterAriaInfo(AzMeterAriaInfo_withDescription(inner_, desc.release()));
}

inline void MeterAriaInfo::delete_() {
    AzMeterAriaInfo_delete(&inner_);
}

inline MeterAriaInfo MeterAriaInfo::clone() const {
    return MeterAriaInfo(AzMeterAriaInfo_clone(&inner_));
}

inline bool MeterAriaInfo::partialEq(const MeterAriaInfo& b) const {
    return AzMeterAriaInfo_partialEq(&inner_, b.ptr());
}

inline String MeterAriaInfo::toDbgString() const {
    return String(AzMeterAriaInfo_toDbgString(&inner_));
}

inline CssAttributeSelector CssAttributeSelector::default_() {
    return CssAttributeSelector(AzCssAttributeSelector_default());
}

inline void CssAttributeSelector::delete_() {
    AzCssAttributeSelector_delete(&inner_);
}

inline CssAttributeSelector CssAttributeSelector::clone() const {
    return CssAttributeSelector(AzCssAttributeSelector_clone(&inner_));
}

inline bool CssAttributeSelector::partialEq(const CssAttributeSelector& b) const {
    return AzCssAttributeSelector_partialEq(&inner_, b.ptr());
}

inline uint64_t CssAttributeSelector::hash() const {
    return AzCssAttributeSelector_hash(&inner_);
}

inline uint8_t CssAttributeSelector::partialCmp(const CssAttributeSelector& b) const {
    return AzCssAttributeSelector_partialCmp(&inner_, b.ptr());
}

inline uint8_t CssAttributeSelector::cmp(const CssAttributeSelector& b) const {
    return AzCssAttributeSelector_cmp(&inner_, b.ptr());
}

inline String CssAttributeSelector::toDbgString() const {
    return String(AzCssAttributeSelector_toDbgString(&inner_));
}

inline void StyledTextRun::delete_() {
    AzStyledTextRun_delete(&inner_);
}

inline StyledTextRun StyledTextRun::clone() const {
    return StyledTextRun(AzStyledTextRun_clone(&inner_));
}

inline bool StyledTextRun::partialEq(const StyledTextRun& b) const {
    return AzStyledTextRun_partialEq(&inner_, b.ptr());
}

inline String StyledTextRun::toDbgString() const {
    return String(AzStyledTextRun_toDbgString(&inner_));
}

inline void TextOpCopy::delete_() {
    AzTextOpCopy_delete(&inner_);
}

inline TextOpCopy TextOpCopy::clone() const {
    return TextOpCopy(AzTextOpCopy_clone(&inner_));
}

inline String TextOpCopy::toDbgString() const {
    return String(AzTextOpCopy_toDbgString(&inner_));
}

inline void TextOpPaste::delete_() {
    AzTextOpPaste_delete(&inner_);
}

inline TextOpPaste TextOpPaste::clone() const {
    return TextOpPaste(AzTextOpPaste_clone(&inner_));
}

inline String TextOpPaste::toDbgString() const {
    return String(AzTextOpPaste_toDbgString(&inner_));
}

inline void TextOpCut::delete_() {
    AzTextOpCut_delete(&inner_);
}

inline TextOpCut TextOpCut::clone() const {
    return TextOpCut(AzTextOpCut_clone(&inner_));
}

inline String TextOpCut::toDbgString() const {
    return String(AzTextOpCut_toDbgString(&inner_));
}

inline SystemFonts SystemFonts::default_() {
    return SystemFonts(AzSystemFonts_default());
}

inline void SystemFonts::delete_() {
    AzSystemFonts_delete(&inner_);
}

inline SystemFonts SystemFonts::clone() const {
    return SystemFonts(AzSystemFonts_clone(&inner_));
}

inline bool SystemFonts::partialEq(const SystemFonts& b) const {
    return AzSystemFonts_partialEq(&inner_, b.ptr());
}

inline String SystemFonts::toDbgString() const {
    return String(AzSystemFonts_toDbgString(&inner_));
}

inline void PercentageParseErrorWithInput::delete_() {
    AzPercentageParseErrorWithInput_delete(&inner_);
}

inline PercentageParseErrorWithInput PercentageParseErrorWithInput::clone() const {
    return PercentageParseErrorWithInput(AzPercentageParseErrorWithInput_clone(&inner_));
}

inline bool PercentageParseErrorWithInput::partialEq(const PercentageParseErrorWithInput& b) const {
    return AzPercentageParseErrorWithInput_partialEq(&inner_, b.ptr());
}

inline String PercentageParseErrorWithInput::toDbgString() const {
    return String(AzPercentageParseErrorWithInput_toDbgString(&inner_));
}

inline TitlebarMetrics TitlebarMetrics::windows() {
    return TitlebarMetrics(AzTitlebarMetrics_windows());
}

inline TitlebarMetrics TitlebarMetrics::macos() {
    return TitlebarMetrics(AzTitlebarMetrics_macos());
}

inline TitlebarMetrics TitlebarMetrics::linux_gnome() {
    return TitlebarMetrics(AzTitlebarMetrics_linuxGnome());
}

inline TitlebarMetrics TitlebarMetrics::ios() {
    return TitlebarMetrics(AzTitlebarMetrics_ios());
}

inline TitlebarMetrics TitlebarMetrics::android() {
    return TitlebarMetrics(AzTitlebarMetrics_android());
}

inline TitlebarMetrics TitlebarMetrics::default_() {
    return TitlebarMetrics(AzTitlebarMetrics_default());
}

inline void TitlebarMetrics::delete_() {
    AzTitlebarMetrics_delete(&inner_);
}

inline TitlebarMetrics TitlebarMetrics::clone() const {
    return TitlebarMetrics(AzTitlebarMetrics_clone(&inner_));
}

inline bool TitlebarMetrics::partialEq(const TitlebarMetrics& b) const {
    return AzTitlebarMetrics_partialEq(&inner_, b.ptr());
}

inline String TitlebarMetrics::toDbgString() const {
    return String(AzTitlebarMetrics_toDbgString(&inner_));
}

inline LinuxCustomization LinuxCustomization::default_() {
    return LinuxCustomization(AzLinuxCustomization_default());
}

inline void LinuxCustomization::delete_() {
    AzLinuxCustomization_delete(&inner_);
}

inline LinuxCustomization LinuxCustomization::clone() const {
    return LinuxCustomization(AzLinuxCustomization_clone(&inner_));
}

inline bool LinuxCustomization::partialEq(const LinuxCustomization& b) const {
    return AzLinuxCustomization_partialEq(&inner_, b.ptr());
}

inline String LinuxCustomization::toDbgString() const {
    return String(AzLinuxCustomization_toDbgString(&inner_));
}

inline FileInputState FileInputState::default_() {
    return FileInputState(AzFileInputState_default());
}

inline void FileInputState::delete_() {
    AzFileInputState_delete(&inner_);
}

inline FileInputState FileInputState::clone() const {
    return FileInputState(AzFileInputState_clone(&inner_));
}

inline bool FileInputState::partialEq(const FileInputState& b) const {
    return AzFileInputState_partialEq(&inner_, b.ptr());
}

inline String FileInputState::toDbgString() const {
    return String(AzFileInputState_toDbgString(&inner_));
}

inline TextInputState TextInputState::default_() {
    return TextInputState(AzTextInputState_default());
}

inline String TextInputState::get_text() const {
    return String(AzTextInputState_getText(&inner_));
}

inline void TextInputState::delete_() {
    AzTextInputState_delete(&inner_);
}

inline TextInputState TextInputState::clone() const {
    return TextInputState(AzTextInputState_clone(&inner_));
}

inline bool TextInputState::partialEq(const TextInputState& b) const {
    return AzTextInputState_partialEq(&inner_, b.ptr());
}

inline String TextInputState::toDbgString() const {
    return String(AzTextInputState_toDbgString(&inner_));
}

inline void VertexBuffer::delete_() {
    AzVertexBuffer_delete(&inner_);
}

inline VertexBuffer VertexBuffer::clone() const {
    return VertexBuffer(AzVertexBuffer_clone(&inner_));
}

inline SvgParseOptions SvgParseOptions::default_() {
    return SvgParseOptions(AzSvgParseOptions_default());
}

inline void SvgParseOptions::delete_() {
    AzSvgParseOptions_delete(&inner_);
}

inline SvgParseOptions SvgParseOptions::clone() const {
    return SvgParseOptions(AzSvgParseOptions_clone(&inner_));
}

inline bool SvgParseOptions::partialEq(const SvgParseOptions& b) const {
    return AzSvgParseOptions_partialEq(&inner_, b.ptr());
}

inline uint8_t SvgParseOptions::partialCmp(const SvgParseOptions& b) const {
    return AzSvgParseOptions_partialCmp(&inner_, b.ptr());
}

inline String SvgParseOptions::toDbgString() const {
    return String(AzSvgParseOptions_toDbgString(&inner_));
}

inline void UnknownSelectorError::delete_() {
    AzUnknownSelectorError_delete(&inner_);
}

inline UnknownSelectorError UnknownSelectorError::clone() const {
    return UnknownSelectorError(AzUnknownSelectorError_clone(&inner_));
}

inline bool UnknownSelectorError::partialEq(const UnknownSelectorError& b) const {
    return AzUnknownSelectorError_partialEq(&inner_, b.ptr());
}

inline String UnknownSelectorError::toDbgString() const {
    return String(AzUnknownSelectorError_toDbgString(&inner_));
}

inline Timer Timer::create(RefAny refany, AzTimerCallbackType callback, GetSystemTimeCallback get_system_time_fn) {
    return Timer(AzTimer_create(refany.release(), az_detail_wrap_cb<AzTimerCallback>(callback), get_system_time_fn.release()));
}

inline Timer Timer::default_() {
    return Timer(AzTimer_default());
}

inline uint64_t Timer::tick_millis() const {
    return AzTimer_tickMillis(&inner_);
}

inline AzInstant Timer::instant_of_next_run() const {
    return AzTimer_instantOfNextRun(&inner_);
}

inline Timer Timer::with_delay(AzDuration delay) const {
    return Timer(AzTimer_withDelay(inner_, delay));
}

inline Timer Timer::with_interval(AzDuration interval) const {
    return Timer(AzTimer_withInterval(inner_, interval));
}

inline Timer Timer::with_timeout(AzDuration timeout) const {
    return Timer(AzTimer_withTimeout(inner_, timeout));
}

inline bool Timer::is_about_to_finish(AzInstant instant_now) const {
    return AzTimer_isAboutToFinish(&inner_, instant_now);
}

inline TimerCallbackReturn Timer::invoke(CallbackInfo callback_info, GetSystemTimeCallback get_system_time_fn) {
    return TimerCallbackReturn(AzTimer_invoke(&inner_, callback_info.release(), get_system_time_fn.release()));
}

inline void Timer::delete_() {
    AzTimer_delete(&inner_);
}

inline Timer Timer::clone() const {
    return Timer(AzTimer_clone(&inner_));
}

inline bool Timer::partialEq(const Timer& b) const {
    return AzTimer_partialEq(&inner_, b.ptr());
}

inline uint64_t Timer::hash() const {
    return AzTimer_hash(&inner_);
}

inline String Timer::toDbgString() const {
    return String(AzTimer_toDbgString(&inner_));
}

inline void FmtArg::delete_() {
    AzFmtArg_delete(&inner_);
}

inline FmtArg FmtArg::clone() const {
    return FmtArg(AzFmtArg_clone(&inner_));
}

inline bool FmtArg::partialEq(const FmtArg& b) const {
    return AzFmtArg_partialEq(&inner_, b.ptr());
}

inline uint8_t FmtArg::partialCmp(const FmtArg& b) const {
    return AzFmtArg_partialCmp(&inner_, b.ptr());
}

inline String FmtArg::toDbgString() const {
    return String(AzFmtArg_toDbgString(&inner_));
}

inline Json Json::null() {
    return Json(AzJson_null());
}

inline Json Json::bool_(bool value) {
    return Json(AzJson_bool(value));
}

inline Json Json::float_(double value) {
    return Json(AzJson_float(value));
}

inline Json Json::int_(int64_t value) {
    return Json(AzJson_int(value));
}

inline Json Json::string(String value) {
    return Json(AzJson_string(value.release()));
}

inline Json Json::array(JsonVec values) {
    return Json(AzJson_array(values.release()));
}

inline Json Json::object(JsonKeyValueVec entries) {
    return Json(AzJson_object(entries.release()));
}

inline ResultJsonJsonParseError Json::parse(String s) {
    return ResultJsonJsonParseError(AzJson_parse(s.release()));
}

inline ResultJsonJsonParseError Json::parse_bytes(U8VecRef bytes) {
    return ResultJsonJsonParseError(AzJson_parseBytes(bytes.release()));
}

inline bool Json::is_null() const {
    return AzJson_isNull(&inner_);
}

inline bool Json::is_bool() const {
    return AzJson_isBool(&inner_);
}

inline bool Json::is_float() const {
    return AzJson_isFloat(&inner_);
}

inline bool Json::is_string() const {
    return AzJson_isString(&inner_);
}

inline bool Json::is_array() const {
    return AzJson_isArray(&inner_);
}

inline bool Json::is_object() const {
    return AzJson_isObject(&inner_);
}

inline OptionBool Json::as_bool() const {
    return OptionBool(AzJson_asBool(&inner_));
}

inline OptionF64 Json::as_float() const {
    return OptionF64(AzJson_asFloat(&inner_));
}

inline OptionI64 Json::as_int() const {
    return OptionI64(AzJson_asInt(&inner_));
}

inline OptionString Json::as_string() const {
    return OptionString(AzJson_asString(&inner_));
}

inline size_t Json::len() const {
    return AzJson_len(&inner_);
}

inline bool Json::is_empty() const {
    return AzJson_isEmpty(&inner_);
}

inline OptionJson Json::get_index(size_t index) const {
    return OptionJson(AzJson_getIndex(&inner_, index));
}

inline OptionJson Json::get_key(String key) const {
    return OptionJson(AzJson_getKey(&inner_, key.release()));
}

inline StringVec Json::keys() const {
    return StringVec(AzJson_keys(&inner_));
}

inline OptionJsonVec Json::to_array() const {
    return OptionJsonVec(AzJson_toArray(&inner_));
}

inline OptionJsonKeyValueVec Json::to_object() const {
    return OptionJsonKeyValueVec(AzJson_toObject(&inner_));
}

inline String Json::to_string() const {
    return String(AzJson_toString(&inner_));
}

inline String Json::to_string_pretty() const {
    return String(AzJson_toStringPretty(&inner_));
}

inline Json Json::jq(String path) const {
    return Json(AzJson_jq(&inner_, path.release()));
}

inline JsonVec Json::jq_all(String path) const {
    return JsonVec(AzJson_jqAll(&inner_, path.release()));
}

inline ResultRefAnyString Json::deserialize_to_refany(size_t deserialize_fn) const {
    return ResultRefAnyString(AzJson_deserializeToRefany(inner_, deserialize_fn));
}

inline void Json::delete_() {
    AzJson_delete(&inner_);
}

inline Json Json::clone() const {
    return Json(AzJson_clone(&inner_));
}

inline bool Json::partialEq(const Json& b) const {
    return AzJson_partialEq(&inner_, b.ptr());
}

inline String Json::toDbgString() const {
    return String(AzJson_toDbgString(&inner_));
}

inline void ComponentDef::delete_() {
    AzComponentDef_delete(&inner_);
}

inline ComponentDef ComponentDef::clone() const {
    return ComponentDef(AzComponentDef_clone(&inner_));
}

inline String ComponentDef::toDbgString() const {
    return String(AzComponentDef_toDbgString(&inner_));
}

inline void ComponentFieldOverride::delete_() {
    AzComponentFieldOverride_delete(&inner_);
}

inline ComponentFieldOverride ComponentFieldOverride::clone() const {
    return ComponentFieldOverride(AzComponentFieldOverride_clone(&inner_));
}

inline bool ComponentFieldOverride::partialEq(const ComponentFieldOverride& b) const {
    return AzComponentFieldOverride_partialEq(&inner_, b.ptr());
}

inline String ComponentFieldOverride::toDbgString() const {
    return String(AzComponentFieldOverride_toDbgString(&inner_));
}

inline LinuxWindowOptions LinuxWindowOptions::default_() {
    return LinuxWindowOptions(AzLinuxWindowOptions_default());
}

inline void LinuxWindowOptions::delete_() {
    AzLinuxWindowOptions_delete(&inner_);
}

inline LinuxWindowOptions LinuxWindowOptions::clone() const {
    return LinuxWindowOptions(AzLinuxWindowOptions_clone(&inner_));
}

inline bool LinuxWindowOptions::partialEq(const LinuxWindowOptions& b) const {
    return AzLinuxWindowOptions_partialEq(&inner_, b.ptr());
}

inline uint8_t LinuxWindowOptions::partialCmp(const LinuxWindowOptions& b) const {
    return AzLinuxWindowOptions_partialCmp(&inner_, b.ptr());
}

inline String LinuxWindowOptions::toDbgString() const {
    return String(AzLinuxWindowOptions_toDbgString(&inner_));
}

inline WindowsWindowOptions WindowsWindowOptions::default_() {
    return WindowsWindowOptions(AzWindowsWindowOptions_default());
}

inline void WindowsWindowOptions::delete_() {
    AzWindowsWindowOptions_delete(&inner_);
}

inline WindowsWindowOptions WindowsWindowOptions::clone() const {
    return WindowsWindowOptions(AzWindowsWindowOptions_clone(&inner_));
}

inline bool WindowsWindowOptions::partialEq(const WindowsWindowOptions& b) const {
    return AzWindowsWindowOptions_partialEq(&inner_, b.ptr());
}

inline uint8_t WindowsWindowOptions::partialCmp(const WindowsWindowOptions& b) const {
    return AzWindowsWindowOptions_partialCmp(&inner_, b.ptr());
}

inline String WindowsWindowOptions::toDbgString() const {
    return String(AzWindowsWindowOptions_toDbgString(&inner_));
}

inline NodeData NodeData::create(AzNodeType node_type) {
    return NodeData(AzNodeData_create(node_type));
}

inline NodeData NodeData::create_body() {
    return NodeData(AzNodeData_createBody());
}

inline NodeData NodeData::create_div() {
    return NodeData(AzNodeData_createDiv());
}

inline NodeData NodeData::create_br() {
    return NodeData(AzNodeData_createBr());
}

inline NodeData NodeData::create_text(String value) {
    return NodeData(AzNodeData_createText(value.release()));
}

inline NodeData NodeData::create_image(ImageRef image) {
    return NodeData(AzNodeData_createImage(image.release()));
}

inline NodeData NodeData::create_virtual_view(RefAny data, AzVirtualViewCallbackType callback) {
    return NodeData(AzNodeData_createVirtualView(data.release(), callback));
}

inline NodeData NodeData::create_node(AzNodeType node_type) {
    return NodeData(AzNodeData_createNode(node_type));
}

inline NodeData NodeData::create_button(SmallAriaInfo aria) {
    return NodeData(AzNodeData_createButton(aria.release()));
}

inline NodeData NodeData::create_button_no_a11y() {
    return NodeData(AzNodeData_createButtonNoA11y());
}

inline NodeData NodeData::create_a(String href, SmallAriaInfo aria) {
    return NodeData(AzNodeData_createA(href.release(), aria.release()));
}

inline NodeData NodeData::create_a_no_a11y(String href) {
    return NodeData(AzNodeData_createANoA11y(href.release()));
}

inline NodeData NodeData::create_input(String input_type, String name, String label, SmallAriaInfo aria) {
    return NodeData(AzNodeData_createInput(input_type.release(), name.release(), label.release(), aria.release()));
}

inline NodeData NodeData::create_input_no_a11y(String input_type, String name, String label) {
    return NodeData(AzNodeData_createInputNoA11y(input_type.release(), name.release(), label.release()));
}

inline NodeData NodeData::create_textarea(String name, String label, SmallAriaInfo aria) {
    return NodeData(AzNodeData_createTextarea(name.release(), label.release(), aria.release()));
}

inline NodeData NodeData::create_textarea_no_a11y(String name, String label) {
    return NodeData(AzNodeData_createTextareaNoA11y(name.release(), label.release()));
}

inline NodeData NodeData::create_select(String name, String label, SmallAriaInfo aria) {
    return NodeData(AzNodeData_createSelect(name.release(), label.release(), aria.release()));
}

inline NodeData NodeData::create_select_no_a11y(String name, String label) {
    return NodeData(AzNodeData_createSelectNoA11y(name.release(), label.release()));
}

inline NodeData NodeData::create_table(SmallAriaInfo aria) {
    return NodeData(AzNodeData_createTable(aria.release()));
}

inline NodeData NodeData::create_table_no_a11y() {
    return NodeData(AzNodeData_createTableNoA11y());
}

inline NodeData NodeData::create_label(String for_id, SmallAriaInfo aria) {
    return NodeData(AzNodeData_createLabel(for_id.release(), aria.release()));
}

inline NodeData NodeData::create_label_no_a11y(String for_id) {
    return NodeData(AzNodeData_createLabelNoA11y(for_id.release()));
}

inline NodeData NodeData::default_() {
    return NodeData(AzNodeData_default());
}

inline void NodeData::set_dataset(OptionRefAny data) {
    AzNodeData_setDataset(&inner_, data.release());
}

inline void NodeData::set_ids_and_classes(IdOrClassVec ids_and_classes) {
    AzNodeData_setIdsAndClasses(&inner_, ids_and_classes.release());
}

inline void NodeData::add_callback(AzEventFilter event, RefAny data, AzCallbackType callback) {
    AzNodeData_addCallback(&inner_, event, data.release(), callback);
}

inline void NodeData::set_callbacks(CoreCallbackDataVec callbacks) {
    AzNodeData_setCallbacks(&inner_, callbacks.release());
}

inline void NodeData::set_clip_mask(ImageMask clip_mask) {
    AzNodeData_setClipMask(&inner_, clip_mask.release());
}

inline void NodeData::set_tab_index(AzTabIndex tab_index) {
    AzNodeData_setTabIndex(&inner_, tab_index);
}

inline void NodeData::set_contenteditable(bool contenteditable) {
    AzNodeData_setContenteditable(&inner_, contenteditable);
}

inline bool NodeData::is_contenteditable() const {
    return AzNodeData_isContenteditable(&inner_);
}

inline NodeData NodeData::with_contenteditable(bool contenteditable) const {
    return NodeData(AzNodeData_withContenteditable(inner_, contenteditable));
}

inline void NodeData::set_accessibility_info(AccessibilityInfo accessibility_info) {
    AzNodeData_setAccessibilityInfo(&inner_, accessibility_info.release());
}

inline void NodeData::set_menu_bar(Menu menu_bar) {
    AzNodeData_setMenuBar(&inner_, menu_bar.release());
}

inline void NodeData::set_context_menu(Menu context_menu) {
    AzNodeData_setContextMenu(&inner_, context_menu.release());
}

inline bool NodeData::has_context_menu() const {
    return AzNodeData_hasContextMenu(&inner_);
}

inline bool NodeData::is_text_node() const {
    return AzNodeData_isTextNode(&inner_);
}

inline bool NodeData::is_virtual_view_node() const {
    return AzNodeData_isVirtualViewNode(&inner_);
}

inline bool NodeData::is_anonymous() const {
    return AzNodeData_isAnonymous(&inner_);
}

inline void NodeData::set_anonymous(bool is_anonymous) {
    AzNodeData_setAnonymous(&inner_, is_anonymous);
}

inline void NodeData::add_id(String s) {
    AzNodeData_addId(&inner_, s.release());
}

inline void NodeData::add_class(String s) {
    AzNodeData_addClass(&inner_, s.release());
}

inline void NodeData::add_css_property(CssPropertyWithConditions p) {
    AzNodeData_addCssProperty(&inner_, p.release());
}

inline bool NodeData::is_focusable() const {
    return AzNodeData_isFocusable(&inner_);
}

inline String NodeData::debug_print_end() const {
    return String(AzNodeData_debugPrintEnd(&inner_));
}

inline void NodeData::set_merge_callback(AzDatasetMergeCallbackType callback) {
    AzNodeData_setMergeCallback(&inner_, az_detail_wrap_cb<AzDatasetMergeCallback>(callback));
}

inline OptionDatasetMergeCallback NodeData::get_merge_callback() const {
    return OptionDatasetMergeCallback(AzNodeData_getMergeCallback(&inner_));
}

inline NodeData NodeData::with_merge_callback(AzDatasetMergeCallbackType callback) const {
    return NodeData(AzNodeData_withMergeCallback(inner_, az_detail_wrap_cb<AzDatasetMergeCallback>(callback)));
}

inline OptionTabIndex NodeData::get_tab_index() const {
    return OptionTabIndex(AzNodeData_getTabIndex(&inner_));
}

inline bool NodeData::has_id(String id) const {
    return AzNodeData_hasId(&inner_, id.release());
}

inline bool NodeData::has_class(String class_) const {
    return AzNodeData_hasClass(&inner_, class_.release());
}

inline IdOrClassVec NodeData::get_ids_and_classes() const {
    return IdOrClassVec(AzNodeData_getIdsAndClasses(&inner_));
}

inline void NodeData::delete_() {
    AzNodeData_delete(&inner_);
}

inline NodeData NodeData::clone() const {
    return NodeData(AzNodeData_clone(&inner_));
}

inline bool NodeData::partialEq(const NodeData& b) const {
    return AzNodeData_partialEq(&inner_, b.ptr());
}

inline uint64_t NodeData::hash() const {
    return AzNodeData_hash(&inner_);
}

inline uint8_t NodeData::partialCmp(const NodeData& b) const {
    return AzNodeData_partialCmp(&inner_, b.ptr());
}

inline uint8_t NodeData::cmp(const NodeData& b) const {
    return AzNodeData_cmp(&inner_, b.ptr());
}

inline String NodeData::toDbgString() const {
    return String(AzNodeData_toDbgString(&inner_));
}

inline StringMenuItem StringMenuItem::create(String label) {
    return StringMenuItem(AzStringMenuItem_create(label.release()));
}

inline void StringMenuItem::delete_() {
    AzStringMenuItem_delete(&inner_);
}

inline StringMenuItem StringMenuItem::clone() const {
    return StringMenuItem(AzStringMenuItem_clone(&inner_));
}

inline bool StringMenuItem::partialEq(const StringMenuItem& b) const {
    return AzStringMenuItem_partialEq(&inner_, b.ptr());
}

inline uint64_t StringMenuItem::hash() const {
    return AzStringMenuItem_hash(&inner_);
}

inline uint8_t StringMenuItem::partialCmp(const StringMenuItem& b) const {
    return AzStringMenuItem_partialCmp(&inner_, b.ptr());
}

inline uint8_t StringMenuItem::cmp(const StringMenuItem& b) const {
    return AzStringMenuItem_cmp(&inner_, b.ptr());
}

inline String StringMenuItem::toDbgString() const {
    return String(AzStringMenuItem_toDbgString(&inner_));
}

inline GridPlacement GridPlacement::default_() {
    return GridPlacement(AzGridPlacement_default());
}

inline void GridPlacement::delete_() {
    AzGridPlacement_delete(&inner_);
}

inline GridPlacement GridPlacement::clone() const {
    return GridPlacement(AzGridPlacement_clone(&inner_));
}

inline bool GridPlacement::partialEq(const GridPlacement& b) const {
    return AzGridPlacement_partialEq(&inner_, b.ptr());
}

inline uint64_t GridPlacement::hash() const {
    return AzGridPlacement_hash(&inner_);
}

inline uint8_t GridPlacement::partialCmp(const GridPlacement& b) const {
    return AzGridPlacement_partialCmp(&inner_, b.ptr());
}

inline uint8_t GridPlacement::cmp(const GridPlacement& b) const {
    return AzGridPlacement_cmp(&inner_, b.ptr());
}

inline String GridPlacement::toDbgString() const {
    return String(AzGridPlacement_toDbgString(&inner_));
}

inline CssMockEnvironment CssMockEnvironment::default_() {
    return CssMockEnvironment(AzCssMockEnvironment_default());
}

inline void CssMockEnvironment::delete_() {
    AzCssMockEnvironment_delete(&inner_);
}

inline CssMockEnvironment CssMockEnvironment::clone() const {
    return CssMockEnvironment(AzCssMockEnvironment_clone(&inner_));
}

inline String CssMockEnvironment::toDbgString() const {
    return String(AzCssMockEnvironment_toDbgString(&inner_));
}

inline SystemMetrics SystemMetrics::default_() {
    return SystemMetrics(AzSystemMetrics_default());
}

inline void SystemMetrics::delete_() {
    AzSystemMetrics_delete(&inner_);
}

inline SystemMetrics SystemMetrics::clone() const {
    return SystemMetrics(AzSystemMetrics_clone(&inner_));
}

inline bool SystemMetrics::partialEq(const SystemMetrics& b) const {
    return AzSystemMetrics_partialEq(&inner_, b.ptr());
}

inline String SystemMetrics::toDbgString() const {
    return String(AzSystemMetrics_toDbgString(&inner_));
}

inline Button Button::create(String label) {
    return Button(AzButton_create(label.release()));
}

inline Button Button::with_type(String label, AzButtonType button_type) {
    return Button(AzButton_withType(label.release(), button_type));
}

inline void Button::set_on_click(RefAny data, AzCallbackType callback) {
    AzButton_setOnClick(&inner_, data.release(), callback);
}

inline Button Button::with_on_click(RefAny data, AzCallbackType callback) const {
    return Button(AzButton_withOnClick(inner_, data.release(), callback));
}

inline void Button::set_button_type(AzButtonType button_type) {
    AzButton_setButtonType(&inner_, button_type);
}

inline Button Button::with_button_type(AzButtonType button_type) const {
    return Button(AzButton_withButtonType(inner_, button_type));
}

inline Dom Button::dom() const {
    return Dom(AzButton_dom(inner_));
}

inline void Button::delete_() {
    AzButton_delete(&inner_);
}

inline Button Button::clone() const {
    return Button(AzButton_clone(&inner_));
}

inline bool Button::partialEq(const Button& b) const {
    return AzButton_partialEq(&inner_, b.ptr());
}

inline uint8_t Button::partialCmp(const Button& b) const {
    return AzButton_partialCmp(&inner_, b.ptr());
}

inline String Button::toDbgString() const {
    return String(AzButton_toDbgString(&inner_));
}

inline MapWidget MapWidget::create(MapTileLayer layer) {
    return MapWidget(AzMapWidget_create(layer.release()));
}

inline MapWidget MapWidget::with_viewport(MapViewport viewport) const {
    return MapWidget(AzMapWidget_withViewport(inner_, viewport.release()));
}

inline void MapWidget::set_viewport(MapViewport viewport) {
    AzMapWidget_setViewport(&inner_, viewport.release());
}

inline MapWidget MapWidget::with_container_style(CssPropertyWithConditionsVec css) const {
    return MapWidget(AzMapWidget_withContainerStyle(inner_, css.release()));
}

inline Dom MapWidget::dom() const {
    return Dom(AzMapWidget_dom(inner_));
}

inline Dom MapWidget::dom_with_fetch(AzThreadCallbackType cb) const {
    return Dom(AzMapWidget_domWithFetch(inner_, cb));
}

inline MapWidget MapWidget::with_on_viewport_changed(RefAny data, AzMapViewportChangedCallbackType callback) const {
    return MapWidget(AzMapWidget_withOnViewportChanged(inner_, data.release(), az_detail_wrap_cb<AzMapViewportChangedCallback>(callback)));
}

inline void MapWidget::set_on_viewport_changed(RefAny data, AzMapViewportChangedCallbackType callback) {
    AzMapWidget_setOnViewportChanged(&inner_, data.release(), az_detail_wrap_cb<AzMapViewportChangedCallback>(callback));
}

inline MapLatLon MapWidget::latlon_at_px(MapViewport viewport, LogicalPosition px, LogicalSize container) {
    return MapLatLon(AzMapWidget_latlonAtPx(viewport.release(), px.release(), container.release()));
}

inline LogicalPosition MapWidget::px_at_latlon(MapViewport viewport, MapLatLon coord, LogicalSize container) {
    return LogicalPosition(AzMapWidget_pxAtLatlon(viewport.release(), coord.release(), container.release()));
}

inline void MapWidget::set_on_pin_tap(RefAny data, AzMapPinTapCallbackType callback) {
    AzMapWidget_setOnPinTap(&inner_, data.release(), az_detail_wrap_cb<AzMapPinTapCallback>(callback));
}

inline MapWidget MapWidget::with_on_pin_tap(RefAny data, AzMapPinTapCallbackType callback) const {
    return MapWidget(AzMapWidget_withOnPinTap(inner_, data.release(), az_detail_wrap_cb<AzMapPinTapCallback>(callback)));
}

inline void MapWidget::delete_() {
    AzMapWidget_delete(&inner_);
}

inline MapWidget MapWidget::clone() const {
    return MapWidget(AzMapWidget_clone(&inner_));
}

inline bool MapWidget::partialEq(const MapWidget& b) const {
    return AzMapWidget_partialEq(&inner_, b.ptr());
}

inline String MapWidget::toDbgString() const {
    return String(AzMapWidget_toDbgString(&inner_));
}

inline FileInputStateWrapper FileInputStateWrapper::default_() {
    return FileInputStateWrapper(AzFileInputStateWrapper_default());
}

inline void FileInputStateWrapper::delete_() {
    AzFileInputStateWrapper_delete(&inner_);
}

inline FileInputStateWrapper FileInputStateWrapper::clone() const {
    return FileInputStateWrapper(AzFileInputStateWrapper_clone(&inner_));
}

inline bool FileInputStateWrapper::partialEq(const FileInputStateWrapper& b) const {
    return AzFileInputStateWrapper_partialEq(&inner_, b.ptr());
}

inline String FileInputStateWrapper::toDbgString() const {
    return String(AzFileInputStateWrapper_toDbgString(&inner_));
}

inline CheckBoxStateWrapper CheckBoxStateWrapper::default_() {
    return CheckBoxStateWrapper(AzCheckBoxStateWrapper_default());
}

inline void CheckBoxStateWrapper::delete_() {
    AzCheckBoxStateWrapper_delete(&inner_);
}

inline CheckBoxStateWrapper CheckBoxStateWrapper::clone() const {
    return CheckBoxStateWrapper(AzCheckBoxStateWrapper_clone(&inner_));
}

inline bool CheckBoxStateWrapper::partialEq(const CheckBoxStateWrapper& b) const {
    return AzCheckBoxStateWrapper_partialEq(&inner_, b.ptr());
}

inline String CheckBoxStateWrapper::toDbgString() const {
    return String(AzCheckBoxStateWrapper_toDbgString(&inner_));
}

inline DropDown DropDown::create(StringVec choices) {
    return DropDown(AzDropDown_create(choices.release()));
}

inline DropDown DropDown::default_() {
    return DropDown(AzDropDown_default());
}

inline void DropDown::set_on_choice_change(RefAny data, AzDropDownOnChoiceChangeCallbackType callback) {
    AzDropDown_setOnChoiceChange(&inner_, data.release(), callback);
}

inline DropDown DropDown::with_on_choice_change(RefAny data, AzDropDownOnChoiceChangeCallbackType callback) const {
    return DropDown(AzDropDown_withOnChoiceChange(inner_, data.release(), callback));
}

inline Dom DropDown::dom() const {
    return Dom(AzDropDown_dom(inner_));
}

inline void DropDown::delete_() {
    AzDropDown_delete(&inner_);
}

inline DropDown DropDown::clone() const {
    return DropDown(AzDropDown_clone(&inner_));
}

inline bool DropDown::partialEq(const DropDown& b) const {
    return AzDropDown_partialEq(&inner_, b.ptr());
}

inline String DropDown::toDbgString() const {
    return String(AzDropDown_toDbgString(&inner_));
}

inline ColorInputStateWrapper ColorInputStateWrapper::default_() {
    return ColorInputStateWrapper(AzColorInputStateWrapper_default());
}

inline void ColorInputStateWrapper::delete_() {
    AzColorInputStateWrapper_delete(&inner_);
}

inline ColorInputStateWrapper ColorInputStateWrapper::clone() const {
    return ColorInputStateWrapper(AzColorInputStateWrapper_clone(&inner_));
}

inline bool ColorInputStateWrapper::partialEq(const ColorInputStateWrapper& b) const {
    return AzColorInputStateWrapper_partialEq(&inner_, b.ptr());
}

inline uint8_t ColorInputStateWrapper::partialCmp(const ColorInputStateWrapper& b) const {
    return AzColorInputStateWrapper_partialCmp(&inner_, b.ptr());
}

inline String ColorInputStateWrapper::toDbgString() const {
    return String(AzColorInputStateWrapper_toDbgString(&inner_));
}

inline TextInputStateWrapper TextInputStateWrapper::default_() {
    return TextInputStateWrapper(AzTextInputStateWrapper_default());
}

inline void TextInputStateWrapper::delete_() {
    AzTextInputStateWrapper_delete(&inner_);
}

inline TextInputStateWrapper TextInputStateWrapper::clone() const {
    return TextInputStateWrapper(AzTextInputStateWrapper_clone(&inner_));
}

inline bool TextInputStateWrapper::partialEq(const TextInputStateWrapper& b) const {
    return AzTextInputStateWrapper_partialEq(&inner_, b.ptr());
}

inline String TextInputStateWrapper::toDbgString() const {
    return String(AzTextInputStateWrapper_toDbgString(&inner_));
}

inline NumberInputStateWrapper NumberInputStateWrapper::default_() {
    return NumberInputStateWrapper(AzNumberInputStateWrapper_default());
}

inline void NumberInputStateWrapper::delete_() {
    AzNumberInputStateWrapper_delete(&inner_);
}

inline NumberInputStateWrapper NumberInputStateWrapper::clone() const {
    return NumberInputStateWrapper(AzNumberInputStateWrapper_clone(&inner_));
}

inline bool NumberInputStateWrapper::partialEq(const NumberInputStateWrapper& b) const {
    return AzNumberInputStateWrapper_partialEq(&inner_, b.ptr());
}

inline String NumberInputStateWrapper::toDbgString() const {
    return String(AzNumberInputStateWrapper_toDbgString(&inner_));
}

inline TabHeader TabHeader::create(StringVec tabs) {
    return TabHeader(AzTabHeader_create(tabs.release()));
}

inline TabHeader TabHeader::default_() {
    return TabHeader(AzTabHeader_default());
}

inline void TabHeader::set_active_tab(size_t active_tab) {
    AzTabHeader_setActiveTab(&inner_, active_tab);
}

inline TabHeader TabHeader::with_active_tab(size_t active_tab) const {
    return TabHeader(AzTabHeader_withActiveTab(inner_, active_tab));
}

inline void TabHeader::set_on_click(RefAny data, AzTabOnClickCallbackType callback) {
    AzTabHeader_setOnClick(&inner_, data.release(), callback);
}

inline TabHeader TabHeader::with_on_click(RefAny data, AzTabOnClickCallbackType callback) const {
    return TabHeader(AzTabHeader_withOnClick(inner_, data.release(), callback));
}

inline Dom TabHeader::dom() const {
    return Dom(AzTabHeader_dom(inner_));
}

inline void TabHeader::delete_() {
    AzTabHeader_delete(&inner_);
}

inline TabHeader TabHeader::clone() const {
    return TabHeader(AzTabHeader_clone(&inner_));
}

inline String TabHeader::toDbgString() const {
    return String(AzTabHeader_toDbgString(&inner_));
}

inline ListView ListView::create(StringVec columns) {
    return ListView(AzListView_create(columns.release()));
}

inline ListView ListView::default_() {
    return ListView(AzListView_default());
}

inline ListView ListView::with_rows(ListViewRowVec rows) const {
    return ListView(AzListView_withRows(inner_, rows.release()));
}

inline Dom ListView::dom() const {
    return Dom(AzListView_dom(inner_));
}

inline void ListView::delete_() {
    AzListView_delete(&inner_);
}

inline ListView ListView::clone() const {
    return ListView(AzListView_clone(&inner_));
}

inline String ListView::toDbgString() const {
    return String(AzListView_toDbgString(&inner_));
}

inline Ribbon Ribbon::new_(RibbonTabVec tabs) {
    return Ribbon(AzRibbon_new(tabs.release()));
}

inline void Ribbon::set_active_tab(size_t index) {
    AzRibbon_setActiveTab(&inner_, index);
}

inline void Ribbon::set_on_tab_click(RefAny data, AzRibbonOnTabClickCallbackType cb) {
    AzRibbon_setOnTabClick(&inner_, data.release(), cb);
}

inline Ribbon Ribbon::with_on_tab_click(RefAny data, AzRibbonOnTabClickCallbackType cb) const {
    return Ribbon(AzRibbon_withOnTabClick(inner_, data.release(), cb));
}

inline Dom Ribbon::dom() const {
    return Dom(AzRibbon_dom(inner_));
}

inline void Ribbon::delete_() {
    AzRibbon_delete(&inner_);
}

inline Ribbon Ribbon::clone() const {
    return Ribbon(AzRibbon_clone(&inner_));
}

inline String Ribbon::toDbgString() const {
    return String(AzRibbon_toDbgString(&inner_));
}

inline TreeView TreeView::new_(TreeViewNode root) {
    return TreeView(AzTreeView_new(root.release()));
}

inline void TreeView::set_on_node_click(RefAny data, AzTreeViewOnNodeClickCallbackType callback) {
    AzTreeView_setOnNodeClick(&inner_, data.release(), callback);
}

inline TreeView TreeView::with_on_node_click(RefAny data, AzTreeViewOnNodeClickCallbackType callback) const {
    return TreeView(AzTreeView_withOnNodeClick(inner_, data.release(), callback));
}

inline Dom TreeView::dom() const {
    return Dom(AzTreeView_dom(inner_));
}

inline void TreeView::delete_() {
    AzTreeView_delete(&inner_);
}

inline TreeView TreeView::clone() const {
    return TreeView(AzTreeView_clone(&inner_));
}

inline bool TreeView::partialEq(const TreeView& b) const {
    return AzTreeView_partialEq(&inner_, b.ptr());
}

inline String TreeView::toDbgString() const {
    return String(AzTreeView_toDbgString(&inner_));
}

inline CameraWidget CameraWidget::create(CameraConfig config) {
    return CameraWidget(AzCameraWidget_create(config.release()));
}

inline Dom CameraWidget::dom() const {
    return Dom(AzCameraWidget_dom(inner_));
}

inline CameraWidget CameraWidget::with_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame) const {
    return CameraWidget(AzCameraWidget_withOnFrame(inner_, data.release(), az_detail_wrap_cb<AzOnVideoFrameCallback>(on_frame)));
}

inline void CameraWidget::set_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame) {
    AzCameraWidget_setOnFrame(&inner_, data.release(), az_detail_wrap_cb<AzOnVideoFrameCallback>(on_frame));
}

inline void CameraWidget::delete_() {
    AzCameraWidget_delete(&inner_);
}

inline ScreenCaptureWidget ScreenCaptureWidget::create(ScreenCaptureConfig config) {
    return ScreenCaptureWidget(AzScreenCaptureWidget_create(config.release()));
}

inline Dom ScreenCaptureWidget::dom() const {
    return Dom(AzScreenCaptureWidget_dom(inner_));
}

inline ScreenCaptureWidget ScreenCaptureWidget::with_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame) const {
    return ScreenCaptureWidget(AzScreenCaptureWidget_withOnFrame(inner_, data.release(), az_detail_wrap_cb<AzOnVideoFrameCallback>(on_frame)));
}

inline void ScreenCaptureWidget::set_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame) {
    AzScreenCaptureWidget_setOnFrame(&inner_, data.release(), az_detail_wrap_cb<AzOnVideoFrameCallback>(on_frame));
}

inline void ScreenCaptureWidget::delete_() {
    AzScreenCaptureWidget_delete(&inner_);
}

inline VideoWidget VideoWidget::create(VideoConfig config) {
    return VideoWidget(AzVideoWidget_create(config.release()));
}

inline Dom VideoWidget::dom() const {
    return Dom(AzVideoWidget_dom(inner_));
}

inline VideoWidget VideoWidget::with_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame) const {
    return VideoWidget(AzVideoWidget_withOnFrame(inner_, data.release(), az_detail_wrap_cb<AzOnVideoFrameCallback>(on_frame)));
}

inline void VideoWidget::set_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame) {
    AzVideoWidget_setOnFrame(&inner_, data.release(), az_detail_wrap_cb<AzOnVideoFrameCallback>(on_frame));
}

inline void VideoWidget::delete_() {
    AzVideoWidget_delete(&inner_);
}

inline MicrophoneWidget MicrophoneWidget::create(AudioConfig config) {
    return MicrophoneWidget(AzMicrophoneWidget_create(config.release()));
}

inline MicrophoneWidget MicrophoneWidget::with_on_frame(RefAny data, AzOnAudioFrameCallbackType on_frame) const {
    return MicrophoneWidget(AzMicrophoneWidget_withOnFrame(inner_, data.release(), az_detail_wrap_cb<AzOnAudioFrameCallback>(on_frame)));
}

inline void MicrophoneWidget::set_on_frame(RefAny data, AzOnAudioFrameCallbackType on_frame) {
    AzMicrophoneWidget_setOnFrame(&inner_, data.release(), az_detail_wrap_cb<AzOnAudioFrameCallback>(on_frame));
}

inline Dom MicrophoneWidget::dom() const {
    return Dom(AzMicrophoneWidget_dom(inner_));
}

inline void MicrophoneWidget::delete_() {
    AzMicrophoneWidget_delete(&inner_);
}

inline TessellatedGPUSvgNode TessellatedGPUSvgNode::create(TessellatedSvgNode node, GlContextPtr gl) {
    return TessellatedGPUSvgNode(AzTessellatedGPUSvgNode_create(node.release(), gl.release()));
}

inline bool TessellatedGPUSvgNode::draw(Texture& texture, AzPhysicalSizeU32 target_size, ColorU color, StyleTransformVec transforms) const {
    return AzTessellatedGPUSvgNode_draw(&inner_, texture.ptr(), target_size, color.release(), transforms.release());
}

inline void TessellatedGPUSvgNode::delete_() {
    AzTessellatedGPUSvgNode_delete(&inner_);
}

inline TessellatedGPUSvgNode TessellatedGPUSvgNode::clone() const {
    return TessellatedGPUSvgNode(AzTessellatedGPUSvgNode_clone(&inner_));
}

inline bool TessellatedGPUSvgNode::partialEq(const TessellatedGPUSvgNode& b) const {
    return AzTessellatedGPUSvgNode_partialEq(&inner_, b.ptr());
}

inline uint8_t TessellatedGPUSvgNode::partialCmp(const TessellatedGPUSvgNode& b) const {
    return AzTessellatedGPUSvgNode_partialCmp(&inner_, b.ptr());
}

inline String TessellatedGPUSvgNode::toDbgString() const {
    return String(AzTessellatedGPUSvgNode_toDbgString(&inner_));
}

inline void TessellatedColoredGPUSvgNode::delete_() {
    AzTessellatedColoredGPUSvgNode_delete(&inner_);
}

inline TessellatedColoredGPUSvgNode TessellatedColoredGPUSvgNode::clone() const {
    return TessellatedColoredGPUSvgNode(AzTessellatedColoredGPUSvgNode_clone(&inner_));
}

inline bool TessellatedColoredGPUSvgNode::partialEq(const TessellatedColoredGPUSvgNode& b) const {
    return AzTessellatedColoredGPUSvgNode_partialEq(&inner_, b.ptr());
}

inline uint8_t TessellatedColoredGPUSvgNode::partialCmp(const TessellatedColoredGPUSvgNode& b) const {
    return AzTessellatedColoredGPUSvgNode_partialCmp(&inner_, b.ptr());
}

inline String TessellatedColoredGPUSvgNode::toDbgString() const {
    return String(AzTessellatedColoredGPUSvgNode_toDbgString(&inner_));
}

inline void XmlTextError::delete_() {
    AzXmlTextError_delete(&inner_);
}

inline XmlTextError XmlTextError::clone() const {
    return XmlTextError(AzXmlTextError_clone(&inner_));
}

inline bool XmlTextError::partialEq(const XmlTextError& b) const {
    return AzXmlTextError_partialEq(&inner_, b.ptr());
}

inline uint8_t XmlTextError::partialCmp(const XmlTextError& b) const {
    return AzXmlTextError_partialCmp(&inner_, b.ptr());
}

inline String XmlTextError::toDbgString() const {
    return String(AzXmlTextError_toDbgString(&inner_));
}

inline JsonKeyValue JsonKeyValue::create(String key, Json value) {
    return JsonKeyValue(AzJsonKeyValue_create(key.release(), value.release()));
}

inline void JsonKeyValue::delete_() {
    AzJsonKeyValue_delete(&inner_);
}

inline JsonKeyValue JsonKeyValue::clone() const {
    return JsonKeyValue(AzJsonKeyValue_clone(&inner_));
}

inline bool JsonKeyValue::partialEq(const JsonKeyValue& b) const {
    return AzJsonKeyValue_partialEq(&inner_, b.ptr());
}

inline String JsonKeyValue::toDbgString() const {
    return String(AzJsonKeyValue_toDbgString(&inner_));
}

inline void ExternalResource::delete_() {
    AzExternalResource_delete(&inner_);
}

inline ExternalResource ExternalResource::clone() const {
    return ExternalResource(AzExternalResource_clone(&inner_));
}

inline bool ExternalResource::partialEq(const ExternalResource& b) const {
    return AzExternalResource_partialEq(&inner_, b.ptr());
}

inline uint64_t ExternalResource::hash() const {
    return AzExternalResource_hash(&inner_);
}

inline uint8_t ExternalResource::partialCmp(const ExternalResource& b) const {
    return AzExternalResource_partialCmp(&inner_, b.ptr());
}

inline uint8_t ExternalResource::cmp(const ExternalResource& b) const {
    return AzExternalResource_cmp(&inner_, b.ptr());
}

inline String ExternalResource::toDbgString() const {
    return String(AzExternalResource_toDbgString(&inner_));
}

inline void ComponentCallbackArg::delete_() {
    AzComponentCallbackArg_delete(&inner_);
}

inline ComponentCallbackArg ComponentCallbackArg::clone() const {
    return ComponentCallbackArg(AzComponentCallbackArg_clone(&inner_));
}

inline bool ComponentCallbackArg::partialEq(const ComponentCallbackArg& b) const {
    return AzComponentCallbackArg_partialEq(&inner_, b.ptr());
}

inline uint64_t ComponentCallbackArg::hash() const {
    return AzComponentCallbackArg_hash(&inner_);
}

inline uint8_t ComponentCallbackArg::partialCmp(const ComponentCallbackArg& b) const {
    return AzComponentCallbackArg_partialCmp(&inner_, b.ptr());
}

inline uint8_t ComponentCallbackArg::cmp(const ComponentCallbackArg& b) const {
    return AzComponentCallbackArg_cmp(&inner_, b.ptr());
}

inline String ComponentCallbackArg::toDbgString() const {
    return String(AzComponentCallbackArg_toDbgString(&inner_));
}

inline PlatformSpecificOptions PlatformSpecificOptions::default_() {
    return PlatformSpecificOptions(AzPlatformSpecificOptions_default());
}

inline void PlatformSpecificOptions::delete_() {
    AzPlatformSpecificOptions_delete(&inner_);
}

inline PlatformSpecificOptions PlatformSpecificOptions::clone() const {
    return PlatformSpecificOptions(AzPlatformSpecificOptions_clone(&inner_));
}

inline bool PlatformSpecificOptions::partialEq(const PlatformSpecificOptions& b) const {
    return AzPlatformSpecificOptions_partialEq(&inner_, b.ptr());
}

inline uint8_t PlatformSpecificOptions::partialCmp(const PlatformSpecificOptions& b) const {
    return AzPlatformSpecificOptions_partialCmp(&inner_, b.ptr());
}

inline String PlatformSpecificOptions::toDbgString() const {
    return String(AzPlatformSpecificOptions_toDbgString(&inner_));
}

inline void TextChangeset::delete_() {
    AzTextChangeset_delete(&inner_);
}

inline TextChangeset TextChangeset::clone() const {
    return TextChangeset(AzTextChangeset_clone(&inner_));
}

inline String TextChangeset::toDbgString() const {
    return String(AzTextChangeset_toDbgString(&inner_));
}

inline Dom Dom::create_body() {
    return Dom(AzDom_createBody());
}

inline Dom Dom::create_div() {
    return Dom(AzDom_createDiv());
}

inline Dom Dom::create_br() {
    return Dom(AzDom_createBr());
}

inline Dom Dom::create_text(String value) {
    return Dom(AzDom_createText(value.release()));
}

inline Dom Dom::create_image(ImageRef image) {
    return Dom(AzDom_createImage(image.release()));
}

inline Dom Dom::create_icon(String icon_name) {
    return Dom(AzDom_createIcon(icon_name.release()));
}

inline Dom Dom::create_virtual_view(RefAny data, AzVirtualViewCallbackType callback) {
    return Dom(AzDom_createVirtualView(data.release(), callback));
}

inline Dom Dom::create_node(AzNodeType node_type) {
    return Dom(AzDom_createNode(node_type));
}

inline Dom Dom::create_from_data(NodeData node_data) {
    return Dom(AzDom_createFromData(node_data.release()));
}

inline Dom Dom::create_from_parsed_xml(AzXml xml) {
    return Dom(AzDom_createFromParsedXml(xml));
}

inline Dom Dom::create_html() {
    return Dom(AzDom_createHtml());
}

inline Dom Dom::create_head() {
    return Dom(AzDom_createHead());
}

inline Dom Dom::create_article() {
    return Dom(AzDom_createArticle());
}

inline Dom Dom::create_section() {
    return Dom(AzDom_createSection());
}

inline Dom Dom::create_nav() {
    return Dom(AzDom_createNav());
}

inline Dom Dom::create_aside() {
    return Dom(AzDom_createAside());
}

inline Dom Dom::create_header() {
    return Dom(AzDom_createHeader());
}

inline Dom Dom::create_footer() {
    return Dom(AzDom_createFooter());
}

inline Dom Dom::create_main() {
    return Dom(AzDom_createMain());
}

inline Dom Dom::create_figure() {
    return Dom(AzDom_createFigure());
}

inline Dom Dom::create_figcaption() {
    return Dom(AzDom_createFigcaption());
}

inline Dom Dom::create_details(SmallAriaInfo aria) {
    return Dom(AzDom_createDetails(aria.release()));
}

inline Dom Dom::create_details_no_a11y() {
    return Dom(AzDom_createDetailsNoA11y());
}

inline Dom Dom::create_summary(SmallAriaInfo aria) {
    return Dom(AzDom_createSummary(aria.release()));
}

inline Dom Dom::create_summary_no_a11y() {
    return Dom(AzDom_createSummaryNoA11y());
}

inline Dom Dom::create_summary_with_text(String text, SmallAriaInfo aria) {
    return Dom(AzDom_createSummaryWithText(text.release(), aria.release()));
}

inline Dom Dom::create_summary_with_text_no_a11y(String text) {
    return Dom(AzDom_createSummaryWithTextNoA11y(text.release()));
}

inline Dom Dom::create_dialog(DialogAriaInfo aria) {
    return Dom(AzDom_createDialog(aria.release()));
}

inline Dom Dom::create_dialog_no_a11y() {
    return Dom(AzDom_createDialogNoA11y());
}

inline Dom Dom::create_p() {
    return Dom(AzDom_createP());
}

inline Dom Dom::create_h1() {
    return Dom(AzDom_createH1());
}

inline Dom Dom::create_h1_with_text(String text) {
    return Dom(AzDom_createH1WithText(text.release()));
}

inline Dom Dom::create_h2() {
    return Dom(AzDom_createH2());
}

inline Dom Dom::create_h2_with_text(String text) {
    return Dom(AzDom_createH2WithText(text.release()));
}

inline Dom Dom::create_h3() {
    return Dom(AzDom_createH3());
}

inline Dom Dom::create_h3_with_text(String text) {
    return Dom(AzDom_createH3WithText(text.release()));
}

inline Dom Dom::create_h4() {
    return Dom(AzDom_createH4());
}

inline Dom Dom::create_h4_with_text(String text) {
    return Dom(AzDom_createH4WithText(text.release()));
}

inline Dom Dom::create_h5() {
    return Dom(AzDom_createH5());
}

inline Dom Dom::create_h5_with_text(String text) {
    return Dom(AzDom_createH5WithText(text.release()));
}

inline Dom Dom::create_h6() {
    return Dom(AzDom_createH6());
}

inline Dom Dom::create_h6_with_text(String text) {
    return Dom(AzDom_createH6WithText(text.release()));
}

inline Dom Dom::create_span() {
    return Dom(AzDom_createSpan());
}

inline Dom Dom::create_span_with_text(String text) {
    return Dom(AzDom_createSpanWithText(text.release()));
}

inline Dom Dom::create_strong() {
    return Dom(AzDom_createStrong());
}

inline Dom Dom::create_strong_with_text(String text) {
    return Dom(AzDom_createStrongWithText(text.release()));
}

inline Dom Dom::create_em() {
    return Dom(AzDom_createEm());
}

inline Dom Dom::create_em_with_text(String text) {
    return Dom(AzDom_createEmWithText(text.release()));
}

inline Dom Dom::create_code() {
    return Dom(AzDom_createCode());
}

inline Dom Dom::create_code_with_text(String code) {
    return Dom(AzDom_createCodeWithText(code.release()));
}

inline Dom Dom::create_pre() {
    return Dom(AzDom_createPre());
}

inline Dom Dom::create_pre_with_text(String text) {
    return Dom(AzDom_createPreWithText(text.release()));
}

inline Dom Dom::create_blockquote() {
    return Dom(AzDom_createBlockquote());
}

inline Dom Dom::create_blockquote_with_text(String text) {
    return Dom(AzDom_createBlockquoteWithText(text.release()));
}

inline Dom Dom::create_cite() {
    return Dom(AzDom_createCite());
}

inline Dom Dom::create_cite_with_text(String text) {
    return Dom(AzDom_createCiteWithText(text.release()));
}

inline Dom Dom::create_abbr() {
    return Dom(AzDom_createAbbr());
}

inline Dom Dom::create_abbr_with_title(String abbr_text, String title) {
    return Dom(AzDom_createAbbrWithTitle(abbr_text.release(), title.release()));
}

inline Dom Dom::create_kbd() {
    return Dom(AzDom_createKbd());
}

inline Dom Dom::create_kbd_with_text(String text) {
    return Dom(AzDom_createKbdWithText(text.release()));
}

inline Dom Dom::create_samp() {
    return Dom(AzDom_createSamp());
}

inline Dom Dom::create_samp_with_text(String text) {
    return Dom(AzDom_createSampWithText(text.release()));
}

inline Dom Dom::create_var() {
    return Dom(AzDom_createVar());
}

inline Dom Dom::create_var_with_text(String text) {
    return Dom(AzDom_createVarWithText(text.release()));
}

inline Dom Dom::create_sub() {
    return Dom(AzDom_createSub());
}

inline Dom Dom::create_sub_with_text(String text) {
    return Dom(AzDom_createSubWithText(text.release()));
}

inline Dom Dom::create_sup() {
    return Dom(AzDom_createSup());
}

inline Dom Dom::create_sup_with_text(String text) {
    return Dom(AzDom_createSupWithText(text.release()));
}

inline Dom Dom::create_u() {
    return Dom(AzDom_createU());
}

inline Dom Dom::create_u_with_text(String text) {
    return Dom(AzDom_createUWithText(text.release()));
}

inline Dom Dom::create_s() {
    return Dom(AzDom_createS());
}

inline Dom Dom::create_s_with_text(String text) {
    return Dom(AzDom_createSWithText(text.release()));
}

inline Dom Dom::create_mark() {
    return Dom(AzDom_createMark());
}

inline Dom Dom::create_mark_with_text(String text) {
    return Dom(AzDom_createMarkWithText(text.release()));
}

inline Dom Dom::create_del() {
    return Dom(AzDom_createDel());
}

inline Dom Dom::create_del_with_text(String text) {
    return Dom(AzDom_createDelWithText(text.release()));
}

inline Dom Dom::create_ins() {
    return Dom(AzDom_createIns());
}

inline Dom Dom::create_ins_with_text(String text) {
    return Dom(AzDom_createInsWithText(text.release()));
}

inline Dom Dom::create_dfn() {
    return Dom(AzDom_createDfn());
}

inline Dom Dom::create_dfn_with_text(String text) {
    return Dom(AzDom_createDfnWithText(text.release()));
}

inline Dom Dom::create_time(String text, OptionString datetime) {
    return Dom(AzDom_createTime(text.release(), datetime.release()));
}

inline Dom Dom::create_bdo() {
    return Dom(AzDom_createBdo());
}

inline Dom Dom::create_bdo_with_text(String text) {
    return Dom(AzDom_createBdoWithText(text.release()));
}

inline Dom Dom::create_a(String href, String text, SmallAriaInfo aria) {
    return Dom(AzDom_createA(href.release(), text.release(), aria.release()));
}

inline Dom Dom::create_a_no_a11y(String href, OptionString label) {
    return Dom(AzDom_createANoA11y(href.release(), label.release()));
}

inline Dom Dom::create_button(String text, SmallAriaInfo aria) {
    return Dom(AzDom_createButton(text.release(), aria.release()));
}

inline Dom Dom::create_button_no_a11y(String text) {
    return Dom(AzDom_createButtonNoA11y(text.release()));
}

inline Dom Dom::create_label(String for_id, String text, SmallAriaInfo aria) {
    return Dom(AzDom_createLabel(for_id.release(), text.release(), aria.release()));
}

inline Dom Dom::create_label_no_a11y(String for_id, String text) {
    return Dom(AzDom_createLabelNoA11y(for_id.release(), text.release()));
}

inline Dom Dom::create_input(String input_type, String name, String label, SmallAriaInfo aria) {
    return Dom(AzDom_createInput(input_type.release(), name.release(), label.release(), aria.release()));
}

inline Dom Dom::create_input_no_a11y(String input_type, String name, String label) {
    return Dom(AzDom_createInputNoA11y(input_type.release(), name.release(), label.release()));
}

inline Dom Dom::create_textarea(String name, String label, SmallAriaInfo aria) {
    return Dom(AzDom_createTextarea(name.release(), label.release(), aria.release()));
}

inline Dom Dom::create_textarea_no_a11y(String name, String label) {
    return Dom(AzDom_createTextareaNoA11y(name.release(), label.release()));
}

inline Dom Dom::create_select(String name, String label, SmallAriaInfo aria) {
    return Dom(AzDom_createSelect(name.release(), label.release(), aria.release()));
}

inline Dom Dom::create_select_no_a11y(String name, String label) {
    return Dom(AzDom_createSelectNoA11y(name.release(), label.release()));
}

inline Dom Dom::create_option(String value, String text, SmallAriaInfo aria) {
    return Dom(AzDom_createOption(value.release(), text.release(), aria.release()));
}

inline Dom Dom::create_option_no_a11y(String value, String text) {
    return Dom(AzDom_createOptionNoA11y(value.release(), text.release()));
}

inline Dom Dom::create_ul() {
    return Dom(AzDom_createUl());
}

inline Dom Dom::create_ol() {
    return Dom(AzDom_createOl());
}

inline Dom Dom::create_li() {
    return Dom(AzDom_createLi());
}

inline Dom Dom::create_table(String caption, SmallAriaInfo aria) {
    return Dom(AzDom_createTable(caption.release(), aria.release()));
}

inline Dom Dom::create_table_no_a11y() {
    return Dom(AzDom_createTableNoA11y());
}

inline Dom Dom::create_caption() {
    return Dom(AzDom_createCaption());
}

inline Dom Dom::create_thead() {
    return Dom(AzDom_createThead());
}

inline Dom Dom::create_tbody() {
    return Dom(AzDom_createTbody());
}

inline Dom Dom::create_tfoot() {
    return Dom(AzDom_createTfoot());
}

inline Dom Dom::create_tr() {
    return Dom(AzDom_createTr());
}

inline Dom Dom::create_th() {
    return Dom(AzDom_createTh());
}

inline Dom Dom::create_td() {
    return Dom(AzDom_createTd());
}

inline Dom Dom::create_form(SmallAriaInfo aria) {
    return Dom(AzDom_createForm(aria.release()));
}

inline Dom Dom::create_form_no_a11y() {
    return Dom(AzDom_createFormNoA11y());
}

inline Dom Dom::create_fieldset(SmallAriaInfo aria) {
    return Dom(AzDom_createFieldset(aria.release()));
}

inline Dom Dom::create_fieldset_no_a11y() {
    return Dom(AzDom_createFieldsetNoA11y());
}

inline Dom Dom::create_legend(SmallAriaInfo aria) {
    return Dom(AzDom_createLegend(aria.release()));
}

inline Dom Dom::create_legend_no_a11y() {
    return Dom(AzDom_createLegendNoA11y());
}

inline Dom Dom::create_hr() {
    return Dom(AzDom_createHr());
}

inline Dom Dom::create_address() {
    return Dom(AzDom_createAddress());
}

inline Dom Dom::create_dl() {
    return Dom(AzDom_createDl());
}

inline Dom Dom::create_dt() {
    return Dom(AzDom_createDt());
}

inline Dom Dom::create_dd() {
    return Dom(AzDom_createDd());
}

inline Dom Dom::create_colgroup() {
    return Dom(AzDom_createColgroup());
}

inline Dom Dom::create_col(int32_t span) {
    return Dom(AzDom_createCol(span));
}

inline Dom Dom::create_optgroup(String label, SmallAriaInfo aria) {
    return Dom(AzDom_createOptgroup(label.release(), aria.release()));
}

inline Dom Dom::create_optgroup_no_a11y(String label) {
    return Dom(AzDom_createOptgroupNoA11y(label.release()));
}

inline Dom Dom::create_q() {
    return Dom(AzDom_createQ());
}

inline Dom Dom::create_acronym() {
    return Dom(AzDom_createAcronym());
}

inline Dom Dom::create_acronym_with_text(String text) {
    return Dom(AzDom_createAcronymWithText(text.release()));
}

inline Dom Dom::create_menu(SmallAriaInfo aria) {
    return Dom(AzDom_createMenu(aria.release()));
}

inline Dom Dom::create_menu_no_a11y() {
    return Dom(AzDom_createMenuNoA11y());
}

inline Dom Dom::create_menuitem(SmallAriaInfo aria) {
    return Dom(AzDom_createMenuitem(aria.release()));
}

inline Dom Dom::create_menuitem_no_a11y() {
    return Dom(AzDom_createMenuitemNoA11y());
}

inline Dom Dom::create_menuitem_with_text(String text, SmallAriaInfo aria) {
    return Dom(AzDom_createMenuitemWithText(text.release(), aria.release()));
}

inline Dom Dom::create_menuitem_with_text_no_a11y(String text) {
    return Dom(AzDom_createMenuitemWithTextNoA11y(text.release()));
}

inline Dom Dom::create_output(SmallAriaInfo aria) {
    return Dom(AzDom_createOutput(aria.release()));
}

inline Dom Dom::create_output_no_a11y() {
    return Dom(AzDom_createOutputNoA11y());
}

inline Dom Dom::create_progress(ProgressAriaInfo aria) {
    return Dom(AzDom_createProgress(aria.release()));
}

inline Dom Dom::create_progress_no_a11y(float value, float max) {
    return Dom(AzDom_createProgressNoA11y(value, max));
}

inline Dom Dom::create_meter(MeterAriaInfo aria) {
    return Dom(AzDom_createMeter(aria.release()));
}

inline Dom Dom::create_meter_no_a11y(float value, float min, float max) {
    return Dom(AzDom_createMeterNoA11y(value, min, max));
}

inline Dom Dom::create_datalist(SmallAriaInfo aria) {
    return Dom(AzDom_createDatalist(aria.release()));
}

inline Dom Dom::create_datalist_no_a11y() {
    return Dom(AzDom_createDatalistNoA11y());
}

inline Dom Dom::create_canvas(SmallAriaInfo aria) {
    return Dom(AzDom_createCanvas(aria.release()));
}

inline Dom Dom::create_canvas_no_a11y() {
    return Dom(AzDom_createCanvasNoA11y());
}

inline Dom Dom::create_object() {
    return Dom(AzDom_createObject());
}

inline Dom Dom::create_param(String name, String value) {
    return Dom(AzDom_createParam(name.release(), value.release()));
}

inline Dom Dom::create_embed() {
    return Dom(AzDom_createEmbed());
}

inline Dom Dom::create_audio(SmallAriaInfo aria) {
    return Dom(AzDom_createAudio(aria.release()));
}

inline Dom Dom::create_audio_no_a11y() {
    return Dom(AzDom_createAudioNoA11y());
}

inline Dom Dom::create_video(SmallAriaInfo aria) {
    return Dom(AzDom_createVideo(aria.release()));
}

inline Dom Dom::create_video_no_a11y() {
    return Dom(AzDom_createVideoNoA11y());
}

inline Dom Dom::create_source(String src, String media_type) {
    return Dom(AzDom_createSource(src.release(), media_type.release()));
}

inline Dom Dom::create_track(String src, String kind) {
    return Dom(AzDom_createTrack(src.release(), kind.release()));
}

inline Dom Dom::create_map() {
    return Dom(AzDom_createMap());
}

inline Dom Dom::create_area(SmallAriaInfo aria) {
    return Dom(AzDom_createArea(aria.release()));
}

inline Dom Dom::create_area_no_a11y() {
    return Dom(AzDom_createAreaNoA11y());
}

inline Dom Dom::create_title() {
    return Dom(AzDom_createTitle());
}

inline Dom Dom::create_title_with_text(String text) {
    return Dom(AzDom_createTitleWithText(text.release()));
}

inline Dom Dom::create_meta() {
    return Dom(AzDom_createMeta());
}

inline Dom Dom::create_link() {
    return Dom(AzDom_createLink());
}

inline Dom Dom::create_script() {
    return Dom(AzDom_createScript());
}

inline Dom Dom::create_style() {
    return Dom(AzDom_createStyle());
}

inline Dom Dom::create_style_with_text(String text) {
    return Dom(AzDom_createStyleWithText(text.release()));
}

inline Dom Dom::create_base(String href) {
    return Dom(AzDom_createBase(href.release()));
}

inline Dom Dom::create_b() {
    return Dom(AzDom_createB());
}

inline Dom Dom::create_b_with_text(String text) {
    return Dom(AzDom_createBWithText(text.release()));
}

inline Dom Dom::create_i() {
    return Dom(AzDom_createI());
}

inline Dom Dom::create_i_with_text(String text) {
    return Dom(AzDom_createIWithText(text.release()));
}

inline Dom Dom::create_small() {
    return Dom(AzDom_createSmall());
}

inline Dom Dom::create_small_with_text(String text) {
    return Dom(AzDom_createSmallWithText(text.release()));
}

inline Dom Dom::create_big() {
    return Dom(AzDom_createBig());
}

inline Dom Dom::create_big_with_text(String text) {
    return Dom(AzDom_createBigWithText(text.release()));
}

inline Dom Dom::create_bdi() {
    return Dom(AzDom_createBdi());
}

inline Dom Dom::create_bdi_with_text(String text) {
    return Dom(AzDom_createBdiWithText(text.release()));
}

inline Dom Dom::create_wbr() {
    return Dom(AzDom_createWbr());
}

inline Dom Dom::create_ruby() {
    return Dom(AzDom_createRuby());
}

inline Dom Dom::create_rt() {
    return Dom(AzDom_createRt());
}

inline Dom Dom::create_rt_with_text(String text) {
    return Dom(AzDom_createRtWithText(text.release()));
}

inline Dom Dom::create_rtc() {
    return Dom(AzDom_createRtc());
}

inline Dom Dom::create_rp() {
    return Dom(AzDom_createRp());
}

inline Dom Dom::create_rp_with_text(String text) {
    return Dom(AzDom_createRpWithText(text.release()));
}

inline Dom Dom::create_data(String value) {
    return Dom(AzDom_createData(value.release()));
}

inline Dom Dom::create_data_with_text(String value, String text) {
    return Dom(AzDom_createDataWithText(value.release(), text.release()));
}

inline Dom Dom::create_dir() {
    return Dom(AzDom_createDir());
}

inline Dom Dom::create_svg() {
    return Dom(AzDom_createSvg());
}

inline Dom Dom::create_th_with_scope(String scope, String text) {
    return Dom(AzDom_createThWithScope(scope.release(), text.release()));
}

inline Dom Dom::create_td_with_text(String text) {
    return Dom(AzDom_createTdWithText(text.release()));
}

inline Dom Dom::create_th_with_text(String text) {
    return Dom(AzDom_createThWithText(text.release()));
}

inline Dom Dom::create_li_with_text(String text) {
    return Dom(AzDom_createLiWithText(text.release()));
}

inline Dom Dom::create_p_with_text(String text) {
    return Dom(AzDom_createPWithText(text.release()));
}

inline Dom Dom::create_geolocation_probe(GeolocationProbeConfig config) {
    return Dom(AzDom_createGeolocationProbe(config.release()));
}

inline Dom Dom::default_() {
    return Dom(AzDom_default());
}

inline Dom Dom::with_dataset(OptionRefAny data) const {
    return Dom(AzDom_withDataset(inner_, data.release()));
}

inline Dom Dom::with_ids_and_classes(IdOrClassVec ids_and_classes) const {
    return Dom(AzDom_withIdsAndClasses(inner_, ids_and_classes.release()));
}

inline Dom Dom::with_callbacks(CoreCallbackDataVec callbacks) const {
    return Dom(AzDom_withCallbacks(inner_, callbacks.release()));
}

inline Dom Dom::with_callback(AzEventFilter event, RefAny data, AzCallbackType callback) const {
    return Dom(AzDom_withCallback(inner_, event, data.release(), callback));
}

inline void Dom::add_child(Dom child) {
    AzDom_addChild(&inner_, child.release());
}

inline Dom Dom::with_child(Dom child) const {
    return Dom(AzDom_withChild(inner_, child.release()));
}

inline void Dom::set_children(DomVec children) {
    AzDom_setChildren(&inner_, children.release());
}

inline Dom Dom::with_children(DomVec children) const {
    return Dom(AzDom_withChildren(inner_, children.release()));
}

inline Dom Dom::with_id(String id) const {
    return Dom(AzDom_withId(inner_, id.release()));
}

inline Dom Dom::with_class(String class_) const {
    return Dom(AzDom_withClass(inner_, class_.release()));
}

inline void Dom::add_css_property(CssPropertyWithConditions prop) {
    AzDom_addCssProperty(&inner_, prop.release());
}

inline Dom Dom::with_css_property(CssPropertyWithConditions prop) const {
    return Dom(AzDom_withCssProperty(inner_, prop.release()));
}

inline Dom Dom::with_clip_mask(ImageMask clip_mask) const {
    return Dom(AzDom_withClipMask(inner_, clip_mask.release()));
}

inline Dom Dom::with_tab_index(AzTabIndex tab_index) const {
    return Dom(AzDom_withTabIndex(inner_, tab_index));
}

inline Dom Dom::with_contenteditable(bool contenteditable) const {
    return Dom(AzDom_withContenteditable(inner_, contenteditable));
}

inline Dom Dom::with_accessibility_info(AccessibilityInfo accessibility_info) const {
    return Dom(AzDom_withAccessibilityInfo(inner_, accessibility_info.release()));
}

inline void Dom::set_menu_bar(Menu menu_bar) {
    AzDom_setMenuBar(&inner_, menu_bar.release());
}

inline Dom Dom::with_menu_bar(Menu menu_bar) const {
    return Dom(AzDom_withMenuBar(inner_, menu_bar.release()));
}

inline void Dom::set_context_menu(Menu context_menu) {
    AzDom_setContextMenu(&inner_, context_menu.release());
}

inline Dom Dom::with_context_menu(Menu context_menu) const {
    return Dom(AzDom_withContextMenu(inner_, context_menu.release()));
}

inline size_t Dom::node_count() const {
    return AzDom_nodeCount(&inner_);
}

inline Dom Dom::with_component_css(Css css) const {
    return Dom(AzDom_withComponentCss(inner_, css.release()));
}

inline void Dom::add_component_css(Css css) {
    AzDom_addComponentCss(&inner_, css.release());
}

inline void Dom::set_component_css(CssVec css) {
    AzDom_setComponentCss(&inner_, css.release());
}

inline Dom Dom::swap_with_default() {
    return Dom(AzDom_swapWithDefault(&inner_));
}

inline Dom Dom::copy_except_for_root() {
    return Dom(AzDom_copyExceptForRoot(&inner_));
}

inline Dom Dom::with_attribute(AzAttributeType attr) const {
    return Dom(AzDom_withAttribute(inner_, attr));
}

inline Dom Dom::with_attributes(AttributeTypeVec attributes) const {
    return Dom(AzDom_withAttributes(inner_, attributes.release()));
}

inline size_t Dom::fixup_children_estimated() {
    return AzDom_fixupChildrenEstimated(&inner_);
}

inline Dom Dom::with_merge_callback(AzDatasetMergeCallbackType callback) const {
    return Dom(AzDom_withMergeCallback(inner_, az_detail_wrap_cb<AzDatasetMergeCallback>(callback)));
}

inline Dom Dom::with_css(String style) const {
    return Dom(AzDom_withCss(inner_, style.release()));
}

inline Dom Dom::with_css_props(CssPropertyWithConditionsVec css_props) const {
    return Dom(AzDom_withCssProps(inner_, css_props.release()));
}

inline Dom Dom::with_node_type(AzNodeType node_type) const {
    return Dom(AzDom_withNodeType(inner_, node_type));
}

inline void Dom::set_css(String style) {
    AzDom_setCss(&inner_, style.release());
}

inline void Dom::add_class(String class_) {
    AzDom_addClass(&inner_, class_.release());
}

inline void Dom::add_callback(AzEventFilter event, RefAny data, AzCallbackType callback) {
    AzDom_addCallback(&inner_, event, data.release(), callback);
}

inline void Dom::set_tab_index(AzTabIndex tab_index) {
    AzDom_setTabIndex(&inner_, tab_index);
}

inline void Dom::set_contenteditable(bool contenteditable) {
    AzDom_setContenteditable(&inner_, contenteditable);
}

inline void Dom::delete_() {
    AzDom_delete(&inner_);
}

inline Dom Dom::clone() const {
    return Dom(AzDom_clone(&inner_));
}

inline bool Dom::partialEq(const Dom& b) const {
    return AzDom_partialEq(&inner_, b.ptr());
}

inline uint64_t Dom::hash() const {
    return AzDom_hash(&inner_);
}

inline uint8_t Dom::partialCmp(const Dom& b) const {
    return AzDom_partialCmp(&inner_, b.ptr());
}

inline uint8_t Dom::cmp(const Dom& b) const {
    return AzDom_cmp(&inner_, b.ptr());
}

inline String Dom::toDbgString() const {
    return String(AzDom_toDbgString(&inner_));
}

inline SystemStyle SystemStyle::detect() {
    return SystemStyle(AzSystemStyle_detect());
}

inline SystemStyle SystemStyle::default_() {
    return SystemStyle(AzSystemStyle_default());
}

inline Css SystemStyle::create_csd_stylesheet() const {
    return Css(AzSystemStyle_createCsdStylesheet(&inner_));
}

inline void SystemStyle::delete_() {
    AzSystemStyle_delete(&inner_);
}

inline SystemStyle SystemStyle::clone() const {
    return SystemStyle(AzSystemStyle_clone(&inner_));
}

inline bool SystemStyle::partialEq(const SystemStyle& b) const {
    return AzSystemStyle_partialEq(&inner_, b.ptr());
}

inline String SystemStyle::toDbgString() const {
    return String(AzSystemStyle_toDbgString(&inner_));
}

inline void CssStyleBorderRadiusParseErrorOwned::delete_() {
    AzCssStyleBorderRadiusParseErrorOwned_delete(&inner_);
}

inline CssStyleBorderRadiusParseErrorOwned CssStyleBorderRadiusParseErrorOwned::clone() const {
    return CssStyleBorderRadiusParseErrorOwned(AzCssStyleBorderRadiusParseErrorOwned_clone(&inner_));
}

inline bool CssStyleBorderRadiusParseErrorOwned::partialEq(const CssStyleBorderRadiusParseErrorOwned& b) const {
    return AzCssStyleBorderRadiusParseErrorOwned_partialEq(&inner_, b.ptr());
}

inline String CssStyleBorderRadiusParseErrorOwned::toDbgString() const {
    return String(AzCssStyleBorderRadiusParseErrorOwned_toDbgString(&inner_));
}

inline FileInput FileInput::create(OptionString path) {
    return FileInput(AzFileInput_create(path.release()));
}

inline FileInput FileInput::default_() {
    return FileInput(AzFileInput_default());
}

inline void FileInput::set_default_text(String default_text) {
    AzFileInput_setDefaultText(&inner_, default_text.release());
}

inline FileInput FileInput::with_default_text(String default_text) const {
    return FileInput(AzFileInput_withDefaultText(inner_, default_text.release()));
}

inline void FileInput::set_on_path_change(RefAny data, AzFileInputOnPathChangeCallbackType callback) {
    AzFileInput_setOnPathChange(&inner_, data.release(), callback);
}

inline FileInput FileInput::with_on_path_change(RefAny data, AzFileInputOnPathChangeCallbackType callback) const {
    return FileInput(AzFileInput_withOnPathChange(inner_, data.release(), callback));
}

inline Dom FileInput::dom() const {
    return Dom(AzFileInput_dom(inner_));
}

inline void FileInput::delete_() {
    AzFileInput_delete(&inner_);
}

inline FileInput FileInput::clone() const {
    return FileInput(AzFileInput_clone(&inner_));
}

inline bool FileInput::partialEq(const FileInput& b) const {
    return AzFileInput_partialEq(&inner_, b.ptr());
}

inline String FileInput::toDbgString() const {
    return String(AzFileInput_toDbgString(&inner_));
}

inline CheckBox CheckBox::create(bool checked) {
    return CheckBox(AzCheckBox_create(checked));
}

inline void CheckBox::set_on_toggle(RefAny data, AzCheckBoxOnToggleCallbackType callback) {
    AzCheckBox_setOnToggle(&inner_, data.release(), callback);
}

inline CheckBox CheckBox::with_on_toggle(RefAny data, AzCheckBoxOnToggleCallbackType callback) const {
    return CheckBox(AzCheckBox_withOnToggle(inner_, data.release(), callback));
}

inline Dom CheckBox::dom() const {
    return Dom(AzCheckBox_dom(inner_));
}

inline void CheckBox::delete_() {
    AzCheckBox_delete(&inner_);
}

inline CheckBox CheckBox::clone() const {
    return CheckBox(AzCheckBox_clone(&inner_));
}

inline bool CheckBox::partialEq(const CheckBox& b) const {
    return AzCheckBox_partialEq(&inner_, b.ptr());
}

inline String CheckBox::toDbgString() const {
    return String(AzCheckBox_toDbgString(&inner_));
}

inline ColorInput ColorInput::create(ColorU color) {
    return ColorInput(AzColorInput_create(color.release()));
}

inline ColorInput ColorInput::default_() {
    return ColorInput(AzColorInput_default());
}

inline void ColorInput::set_on_value_change(RefAny data, AzColorInputOnValueChangeCallbackType callback) {
    AzColorInput_setOnValueChange(&inner_, data.release(), callback);
}

inline ColorInput ColorInput::with_on_value_change(RefAny data, AzColorInputOnValueChangeCallbackType callback) const {
    return ColorInput(AzColorInput_withOnValueChange(inner_, data.release(), callback));
}

inline Dom ColorInput::dom() const {
    return Dom(AzColorInput_dom(inner_));
}

inline void ColorInput::delete_() {
    AzColorInput_delete(&inner_);
}

inline ColorInput ColorInput::clone() const {
    return ColorInput(AzColorInput_clone(&inner_));
}

inline bool ColorInput::partialEq(const ColorInput& b) const {
    return AzColorInput_partialEq(&inner_, b.ptr());
}

inline String ColorInput::toDbgString() const {
    return String(AzColorInput_toDbgString(&inner_));
}

inline TextInput TextInput::create() {
    return TextInput(AzTextInput_create());
}

inline TextInput TextInput::default_() {
    return TextInput(AzTextInput_default());
}

inline void TextInput::set_text(String text) {
    AzTextInput_setText(&inner_, text.release());
}

inline TextInput TextInput::with_text(String text) const {
    return TextInput(AzTextInput_withText(inner_, text.release()));
}

inline void TextInput::set_placeholder(String text) {
    AzTextInput_setPlaceholder(&inner_, text.release());
}

inline TextInput TextInput::with_placeholder(String text) const {
    return TextInput(AzTextInput_withPlaceholder(inner_, text.release()));
}

inline void TextInput::set_on_text_input(RefAny data, AzTextInputOnTextInputCallbackType callback) {
    AzTextInput_setOnTextInput(&inner_, data.release(), callback);
}

inline TextInput TextInput::with_on_text_input(RefAny data, AzTextInputOnTextInputCallbackType callback) const {
    return TextInput(AzTextInput_withOnTextInput(inner_, data.release(), callback));
}

inline void TextInput::set_on_virtual_key_down(RefAny data, AzTextInputOnVirtualKeyDownCallbackType callback) {
    AzTextInput_setOnVirtualKeyDown(&inner_, data.release(), callback);
}

inline TextInput TextInput::with_on_virtual_key_down(RefAny data, AzTextInputOnVirtualKeyDownCallbackType callback) const {
    return TextInput(AzTextInput_withOnVirtualKeyDown(inner_, data.release(), callback));
}

inline void TextInput::set_on_focus_lost(RefAny data, AzTextInputOnFocusLostCallbackType callback) {
    AzTextInput_setOnFocusLost(&inner_, data.release(), callback);
}

inline TextInput TextInput::with_on_focus_lost(RefAny data, AzTextInputOnFocusLostCallbackType callback) const {
    return TextInput(AzTextInput_withOnFocusLost(inner_, data.release(), callback));
}

inline Dom TextInput::dom() const {
    return Dom(AzTextInput_dom(inner_));
}

inline void TextInput::delete_() {
    AzTextInput_delete(&inner_);
}

inline TextInput TextInput::clone() const {
    return TextInput(AzTextInput_clone(&inner_));
}

inline bool TextInput::partialEq(const TextInput& b) const {
    return AzTextInput_partialEq(&inner_, b.ptr());
}

inline String TextInput::toDbgString() const {
    return String(AzTextInput_toDbgString(&inner_));
}

inline void ComponentDataField::delete_() {
    AzComponentDataField_delete(&inner_);
}

inline ComponentDataField ComponentDataField::clone() const {
    return ComponentDataField(AzComponentDataField_clone(&inner_));
}

inline bool ComponentDataField::partialEq(const ComponentDataField& b) const {
    return AzComponentDataField_partialEq(&inner_, b.ptr());
}

inline String ComponentDataField::toDbgString() const {
    return String(AzComponentDataField_toDbgString(&inner_));
}

inline FullWindowState FullWindowState::default_() {
    return FullWindowState(AzFullWindowState_default());
}

inline void FullWindowState::delete_() {
    AzFullWindowState_delete(&inner_);
}

inline FullWindowState FullWindowState::clone() const {
    return FullWindowState(AzFullWindowState_clone(&inner_));
}

inline bool FullWindowState::partialEq(const FullWindowState& b) const {
    return AzFullWindowState_partialEq(&inner_, b.ptr());
}

inline String FullWindowState::toDbgString() const {
    return String(AzFullWindowState_toDbgString(&inner_));
}

inline void UndoableOperation::delete_() {
    AzUndoableOperation_delete(&inner_);
}

inline UndoableOperation UndoableOperation::clone() const {
    return UndoableOperation(AzUndoableOperation_clone(&inner_));
}

inline String UndoableOperation::toDbgString() const {
    return String(AzUndoableOperation_toDbgString(&inner_));
}

inline NumberInput NumberInput::create(float number) {
    return NumberInput(AzNumberInput_create(number));
}

inline NumberInput NumberInput::default_() {
    return NumberInput(AzNumberInput_default());
}

inline void NumberInput::set_on_text_input(RefAny data, AzTextInputOnTextInputCallbackType callback) {
    AzNumberInput_setOnTextInput(&inner_, data.release(), callback);
}

inline NumberInput NumberInput::with_on_text_input(RefAny data, AzTextInputOnTextInputCallbackType callback) const {
    return NumberInput(AzNumberInput_withOnTextInput(inner_, data.release(), callback));
}

inline void NumberInput::set_on_virtual_key_down(RefAny data, AzTextInputOnVirtualKeyDownCallbackType callback) {
    AzNumberInput_setOnVirtualKeyDown(&inner_, data.release(), callback);
}

inline NumberInput NumberInput::with_on_virtual_key_down(RefAny data, AzTextInputOnVirtualKeyDownCallbackType callback) const {
    return NumberInput(AzNumberInput_withOnVirtualKeyDown(inner_, data.release(), callback));
}

inline void NumberInput::set_on_focus_lost(RefAny data, AzNumberInputOnFocusLostCallbackType callback) {
    AzNumberInput_setOnFocusLost(&inner_, data.release(), callback);
}

inline NumberInput NumberInput::with_on_focus_lost(RefAny data, AzNumberInputOnFocusLostCallbackType callback) const {
    return NumberInput(AzNumberInput_withOnFocusLost(inner_, data.release(), callback));
}

inline void NumberInput::set_on_value_change(RefAny data, AzNumberInputOnValueChangeCallbackType callback) {
    AzNumberInput_setOnValueChange(&inner_, data.release(), callback);
}

inline NumberInput NumberInput::with_on_value_change(RefAny data, AzNumberInputOnValueChangeCallbackType callback) const {
    return NumberInput(AzNumberInput_withOnValueChange(inner_, data.release(), callback));
}

inline Dom NumberInput::dom() const {
    return Dom(AzNumberInput_dom(inner_));
}

inline void NumberInput::delete_() {
    AzNumberInput_delete(&inner_);
}

inline NumberInput NumberInput::clone() const {
    return NumberInput(AzNumberInput_clone(&inner_));
}

inline bool NumberInput::partialEq(const NumberInput& b) const {
    return AzNumberInput_partialEq(&inner_, b.ptr());
}

inline String NumberInput::toDbgString() const {
    return String(AzNumberInput_toDbgString(&inner_));
}

inline Frame Frame::create(String title, Dom dom) {
    return Frame(AzFrame_create(title.release(), dom.release()));
}

inline void Frame::set_flex_grow(float flex_grow) {
    AzFrame_setFlexGrow(&inner_, flex_grow);
}

inline Frame Frame::with_flex_grow(float flex_grow) const {
    return Frame(AzFrame_withFlexGrow(inner_, flex_grow));
}

inline Dom Frame::dom() const {
    return Dom(AzFrame_dom(inner_));
}

inline void Frame::delete_() {
    AzFrame_delete(&inner_);
}

inline Frame Frame::clone() const {
    return Frame(AzFrame_clone(&inner_));
}

inline String Frame::toDbgString() const {
    return String(AzFrame_toDbgString(&inner_));
}

inline RibbonSection RibbonSection::new_(String title, Dom content) {
    return RibbonSection(AzRibbonSection_new(title.release(), content.release()));
}

inline void RibbonSection::delete_() {
    AzRibbonSection_delete(&inner_);
}

inline RibbonSection RibbonSection::clone() const {
    return RibbonSection(AzRibbonSection_clone(&inner_));
}

inline String RibbonSection::toDbgString() const {
    return String(AzRibbonSection_toDbgString(&inner_));
}

inline AppConfig AppConfig::create() {
    return AppConfig(AzAppConfig_create());
}

inline AppConfig AppConfig::default_() {
    return AppConfig(AzAppConfig_default());
}

inline void AppConfig::delete_() {
    AzAppConfig_delete(&inner_);
}

inline AppConfig AppConfig::clone() const {
    return AppConfig(AzAppConfig_clone(&inner_));
}

inline String AppConfig::toDbgString() const {
    return String(AzAppConfig_toDbgString(&inner_));
}

inline WindowCreateOptions WindowCreateOptions::create(AzLayoutCallbackType layout_callback) {
    return WindowCreateOptions(AzWindowCreateOptions_create(layout_callback));
}

inline WindowCreateOptions WindowCreateOptions::default_() {
    return WindowCreateOptions(AzWindowCreateOptions_default());
}

inline void WindowCreateOptions::delete_() {
    AzWindowCreateOptions_delete(&inner_);
}

inline WindowCreateOptions WindowCreateOptions::clone() const {
    return WindowCreateOptions(AzWindowCreateOptions_clone(&inner_));
}

inline bool WindowCreateOptions::partialEq(const WindowCreateOptions& b) const {
    return AzWindowCreateOptions_partialEq(&inner_, b.ptr());
}

inline String WindowCreateOptions::toDbgString() const {
    return String(AzWindowCreateOptions_toDbgString(&inner_));
}

inline VirtualViewReturn VirtualViewReturn::with_dom(Dom dom, LogicalSize scroll_size, LogicalPosition scroll_offset, LogicalSize virtual_scroll_size, LogicalPosition virtual_scroll_offset) {
    return VirtualViewReturn(AzVirtualViewReturn_withDom(dom.release(), scroll_size.release(), scroll_offset.release(), virtual_scroll_size.release(), virtual_scroll_offset.release()));
}

inline VirtualViewReturn VirtualViewReturn::keep_current(LogicalSize scroll_size, LogicalPosition scroll_offset, LogicalSize virtual_scroll_size, LogicalPosition virtual_scroll_offset) {
    return VirtualViewReturn(AzVirtualViewReturn_keepCurrent(scroll_size.release(), scroll_offset.release(), virtual_scroll_size.release(), virtual_scroll_offset.release()));
}

inline VirtualViewReturn VirtualViewReturn::default_() {
    return VirtualViewReturn(AzVirtualViewReturn_default());
}

inline void VirtualViewReturn::delete_() {
    AzVirtualViewReturn_delete(&inner_);
}

inline VirtualViewReturn VirtualViewReturn::clone() const {
    return VirtualViewReturn(AzVirtualViewReturn_clone(&inner_));
}

inline bool VirtualViewReturn::partialEq(const VirtualViewReturn& b) const {
    return AzVirtualViewReturn_partialEq(&inner_, b.ptr());
}

inline String VirtualViewReturn::toDbgString() const {
    return String(AzVirtualViewReturn_toDbgString(&inner_));
}

inline void DynamicCssProperty::delete_() {
    AzDynamicCssProperty_delete(&inner_);
}

inline DynamicCssProperty DynamicCssProperty::clone() const {
    return DynamicCssProperty(AzDynamicCssProperty_clone(&inner_));
}

inline bool DynamicCssProperty::partialEq(const DynamicCssProperty& b) const {
    return AzDynamicCssProperty_partialEq(&inner_, b.ptr());
}

inline uint64_t DynamicCssProperty::hash() const {
    return AzDynamicCssProperty_hash(&inner_);
}

inline uint8_t DynamicCssProperty::partialCmp(const DynamicCssProperty& b) const {
    return AzDynamicCssProperty_partialCmp(&inner_, b.ptr());
}

inline uint8_t DynamicCssProperty::cmp(const DynamicCssProperty& b) const {
    return AzDynamicCssProperty_cmp(&inner_, b.ptr());
}

inline String DynamicCssProperty::toDbgString() const {
    return String(AzDynamicCssProperty_toDbgString(&inner_));
}

inline CssPropertyWithConditions CssPropertyWithConditions::simple(AzCssProperty property) {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_simple(property));
}

inline CssPropertyWithConditions CssPropertyWithConditions::with_condition(AzCssProperty property, AzDynamicSelector condition) {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_withCondition(property, condition));
}

inline CssPropertyWithConditions CssPropertyWithConditions::with_conditions(AzCssProperty property, DynamicSelectorVec conditions) {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_withConditions(property, conditions.release()));
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_hover(AzCssProperty property) {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_onHover(property));
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_active(AzCssProperty property) {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_onActive(property));
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_focus(AzCssProperty property) {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_onFocus(property));
}

inline CssPropertyWithConditions CssPropertyWithConditions::when_disabled(AzCssProperty property) {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_whenDisabled(property));
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_os(AzCssProperty property, AzOsCondition os) {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_onOs(property, os));
}

inline CssPropertyWithConditions CssPropertyWithConditions::dark_theme(AzCssProperty property) {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_darkTheme(property));
}

inline CssPropertyWithConditions CssPropertyWithConditions::light_theme(AzCssProperty property) {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_lightTheme(property));
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_windows(AzCssProperty property) {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_onWindows(property));
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_macos(AzCssProperty property) {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_onMacos(property));
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_linux(AzCssProperty property) {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_onLinux(property));
}

inline bool CssPropertyWithConditions::is_conditional() const {
    return AzCssPropertyWithConditions_isConditional(&inner_);
}

inline bool CssPropertyWithConditions::is_pseudo_state_only() const {
    return AzCssPropertyWithConditions_isPseudoStateOnly(&inner_);
}

inline bool CssPropertyWithConditions::is_layout_affecting() const {
    return AzCssPropertyWithConditions_isLayoutAffecting(&inner_);
}

inline void CssPropertyWithConditions::delete_() {
    AzCssPropertyWithConditions_delete(&inner_);
}

inline CssPropertyWithConditions CssPropertyWithConditions::clone() const {
    return CssPropertyWithConditions(AzCssPropertyWithConditions_clone(&inner_));
}

inline bool CssPropertyWithConditions::partialEq(const CssPropertyWithConditions& b) const {
    return AzCssPropertyWithConditions_partialEq(&inner_, b.ptr());
}

inline uint64_t CssPropertyWithConditions::hash() const {
    return AzCssPropertyWithConditions_hash(&inner_);
}

inline uint8_t CssPropertyWithConditions::partialCmp(const CssPropertyWithConditions& b) const {
    return AzCssPropertyWithConditions_partialCmp(&inner_, b.ptr());
}

inline uint8_t CssPropertyWithConditions::cmp(const CssPropertyWithConditions& b) const {
    return AzCssPropertyWithConditions_cmp(&inner_, b.ptr());
}

inline String CssPropertyWithConditions::toDbgString() const {
    return String(AzCssPropertyWithConditions_toDbgString(&inner_));
}

inline void CssBorderParseErrorOwned::delete_() {
    AzCssBorderParseErrorOwned_delete(&inner_);
}

inline CssBorderParseErrorOwned CssBorderParseErrorOwned::clone() const {
    return CssBorderParseErrorOwned(AzCssBorderParseErrorOwned_clone(&inner_));
}

inline bool CssBorderParseErrorOwned::partialEq(const CssBorderParseErrorOwned& b) const {
    return AzCssBorderParseErrorOwned_partialEq(&inner_, b.ptr());
}

inline String CssBorderParseErrorOwned::toDbgString() const {
    return String(AzCssBorderParseErrorOwned_toDbgString(&inner_));
}

inline void CssParseErrorOwned::delete_() {
    AzCssParseErrorOwned_delete(&inner_);
}

inline CssParseErrorOwned CssParseErrorOwned::clone() const {
    return CssParseErrorOwned(AzCssParseErrorOwned_clone(&inner_));
}

inline bool CssParseErrorOwned::partialEq(const CssParseErrorOwned& b) const {
    return AzCssParseErrorOwned_partialEq(&inner_, b.ptr());
}

inline String CssParseErrorOwned::toDbgString() const {
    return String(AzCssParseErrorOwned_toDbgString(&inner_));
}

inline OptionI16 OptionI16::none() {
    return OptionI16(AzOptionI16_none());
}

inline OptionI16 OptionI16::some(int16_t payload) {
    return OptionI16(AzOptionI16_some(payload));
}

inline bool OptionI16::partialEq(const OptionI16& b) const {
    return AzOptionI16_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionI16::hash() const {
    return AzOptionI16_hash(&inner_);
}

inline uint8_t OptionI16::partialCmp(const OptionI16& b) const {
    return AzOptionI16_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionI16::cmp(const OptionI16& b) const {
    return AzOptionI16_cmp(&inner_, b.ptr());
}

inline String OptionI16::toDbgString() const {
    return String(AzOptionI16_toDbgString(&inner_));
}

inline OptionU16 OptionU16::none() {
    return OptionU16(AzOptionU16_none());
}

inline OptionU16 OptionU16::some(uint16_t payload) {
    return OptionU16(AzOptionU16_some(payload));
}

inline bool OptionU16::partialEq(const OptionU16& b) const {
    return AzOptionU16_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionU16::hash() const {
    return AzOptionU16_hash(&inner_);
}

inline uint8_t OptionU16::partialCmp(const OptionU16& b) const {
    return AzOptionU16_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionU16::cmp(const OptionU16& b) const {
    return AzOptionU16_cmp(&inner_, b.ptr());
}

inline String OptionU16::toDbgString() const {
    return String(AzOptionU16_toDbgString(&inner_));
}

inline OptionU32 OptionU32::none() {
    return OptionU32(AzOptionU32_none());
}

inline OptionU32 OptionU32::some(uint32_t payload) {
    return OptionU32(AzOptionU32_some(payload));
}

inline bool OptionU32::partialEq(const OptionU32& b) const {
    return AzOptionU32_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionU32::hash() const {
    return AzOptionU32_hash(&inner_);
}

inline uint8_t OptionU32::partialCmp(const OptionU32& b) const {
    return AzOptionU32_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionU32::cmp(const OptionU32& b) const {
    return AzOptionU32_cmp(&inner_, b.ptr());
}

inline String OptionU32::toDbgString() const {
    return String(AzOptionU32_toDbgString(&inner_));
}

inline OptionUsize OptionUsize::none() {
    return OptionUsize(AzOptionUsize_none());
}

inline OptionUsize OptionUsize::some(size_t payload) {
    return OptionUsize(AzOptionUsize_some(payload));
}

inline bool OptionUsize::partialEq(const OptionUsize& b) const {
    return AzOptionUsize_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionUsize::hash() const {
    return AzOptionUsize_hash(&inner_);
}

inline uint8_t OptionUsize::partialCmp(const OptionUsize& b) const {
    return AzOptionUsize_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionUsize::cmp(const OptionUsize& b) const {
    return AzOptionUsize_cmp(&inner_, b.ptr());
}

inline String OptionUsize::toDbgString() const {
    return String(AzOptionUsize_toDbgString(&inner_));
}

inline OptionF32 OptionF32::none() {
    return OptionF32(AzOptionF32_none());
}

inline OptionF32 OptionF32::some(float payload) {
    return OptionF32(AzOptionF32_some(payload));
}

inline bool OptionF32::partialEq(const OptionF32& b) const {
    return AzOptionF32_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionF32::hash() const {
    return AzOptionF32_hash(&inner_);
}

inline uint8_t OptionF32::partialCmp(const OptionF32& b) const {
    return AzOptionF32_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionF32::cmp(const OptionF32& b) const {
    return AzOptionF32_cmp(&inner_, b.ptr());
}

inline String OptionF32::toDbgString() const {
    return String(AzOptionF32_toDbgString(&inner_));
}

inline OptionF64 OptionF64::none() {
    return OptionF64(AzOptionF64_none());
}

inline OptionF64 OptionF64::some(double payload) {
    return OptionF64(AzOptionF64_some(payload));
}

inline bool OptionF64::partialEq(const OptionF64& b) const {
    return AzOptionF64_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionF64::partialCmp(const OptionF64& b) const {
    return AzOptionF64_partialCmp(&inner_, b.ptr());
}

inline String OptionF64::toDbgString() const {
    return String(AzOptionF64_toDbgString(&inner_));
}

inline OptionBool OptionBool::none() {
    return OptionBool(AzOptionBool_none());
}

inline OptionBool OptionBool::some(bool payload) {
    return OptionBool(AzOptionBool_some(payload));
}

inline bool OptionBool::partialEq(const OptionBool& b) const {
    return AzOptionBool_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionBool::hash() const {
    return AzOptionBool_hash(&inner_);
}

inline uint8_t OptionBool::partialCmp(const OptionBool& b) const {
    return AzOptionBool_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionBool::cmp(const OptionBool& b) const {
    return AzOptionBool_cmp(&inner_, b.ptr());
}

inline String OptionBool::toDbgString() const {
    return String(AzOptionBool_toDbgString(&inner_));
}

inline OptionI64 OptionI64::none() {
    return OptionI64(AzOptionI64_none());
}

inline OptionI64 OptionI64::some(int64_t payload) {
    return OptionI64(AzOptionI64_some(payload));
}

inline bool OptionI64::partialEq(const OptionI64& b) const {
    return AzOptionI64_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionI64::hash() const {
    return AzOptionI64_hash(&inner_);
}

inline uint8_t OptionI64::partialCmp(const OptionI64& b) const {
    return AzOptionI64_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionI64::cmp(const OptionI64& b) const {
    return AzOptionI64_cmp(&inner_, b.ptr());
}

inline String OptionI64::toDbgString() const {
    return String(AzOptionI64_toDbgString(&inner_));
}

inline OptionI32 OptionI32::none() {
    return OptionI32(AzOptionI32_none());
}

inline OptionI32 OptionI32::some(int32_t payload) {
    return OptionI32(AzOptionI32_some(payload));
}

inline bool OptionI32::partialEq(const OptionI32& b) const {
    return AzOptionI32_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionI32::hash() const {
    return AzOptionI32_hash(&inner_);
}

inline uint8_t OptionI32::partialCmp(const OptionI32& b) const {
    return AzOptionI32_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionI32::cmp(const OptionI32& b) const {
    return AzOptionI32_cmp(&inner_, b.ptr());
}

inline String OptionI32::toDbgString() const {
    return String(AzOptionI32_toDbgString(&inner_));
}

inline OptionU64 OptionU64::none() {
    return OptionU64(AzOptionU64_none());
}

inline OptionU64 OptionU64::some(uint64_t payload) {
    return OptionU64(AzOptionU64_some(payload));
}

inline bool OptionU64::partialEq(const OptionU64& b) const {
    return AzOptionU64_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionU64::hash() const {
    return AzOptionU64_hash(&inner_);
}

inline uint8_t OptionU64::partialCmp(const OptionU64& b) const {
    return AzOptionU64_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionU64::cmp(const OptionU64& b) const {
    return AzOptionU64_cmp(&inner_, b.ptr());
}

inline String OptionU64::toDbgString() const {
    return String(AzOptionU64_toDbgString(&inner_));
}

inline OptionU8 OptionU8::none() {
    return OptionU8(AzOptionU8_none());
}

inline OptionU8 OptionU8::some(uint8_t payload) {
    return OptionU8(AzOptionU8_some(payload));
}

inline bool OptionU8::partialEq(const OptionU8& b) const {
    return AzOptionU8_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionU8::hash() const {
    return AzOptionU8_hash(&inner_);
}

inline uint8_t OptionU8::partialCmp(const OptionU8& b) const {
    return AzOptionU8_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionU8::cmp(const OptionU8& b) const {
    return AzOptionU8_cmp(&inner_, b.ptr());
}

inline String OptionU8::toDbgString() const {
    return String(AzOptionU8_toDbgString(&inner_));
}

inline OptionTimerId OptionTimerId::none() {
    return OptionTimerId(AzOptionTimerId_none());
}

inline OptionTimerId OptionTimerId::some(TimerId payload) {
    return OptionTimerId(AzOptionTimerId_some(payload.release()));
}

inline bool OptionTimerId::partialEq(const OptionTimerId& b) const {
    return AzOptionTimerId_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionTimerId::hash() const {
    return AzOptionTimerId_hash(&inner_);
}

inline uint8_t OptionTimerId::partialCmp(const OptionTimerId& b) const {
    return AzOptionTimerId_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionTimerId::cmp(const OptionTimerId& b) const {
    return AzOptionTimerId_cmp(&inner_, b.ptr());
}

inline String OptionTimerId::toDbgString() const {
    return String(AzOptionTimerId_toDbgString(&inner_));
}

inline OptionThread OptionThread::none() {
    return OptionThread(AzOptionThread_none());
}

inline OptionThread OptionThread::some(Thread payload) {
    return OptionThread(AzOptionThread_some(payload.release()));
}

inline void OptionThread::delete_() {
    AzOptionThread_delete(&inner_);
}

inline OptionThread OptionThread::clone() const {
    return OptionThread(AzOptionThread_clone(&inner_));
}

inline String OptionThread::toDbgString() const {
    return String(AzOptionThread_toDbgString(&inner_));
}

inline OptionImageRef OptionImageRef::none() {
    return OptionImageRef(AzOptionImageRef_none());
}

inline OptionImageRef OptionImageRef::some(ImageRef payload) {
    return OptionImageRef(AzOptionImageRef_some(payload.release()));
}

inline void OptionImageRef::delete_() {
    AzOptionImageRef_delete(&inner_);
}

inline OptionImageRef OptionImageRef::clone() const {
    return OptionImageRef(AzOptionImageRef_clone(&inner_));
}

inline bool OptionImageRef::partialEq(const OptionImageRef& b) const {
    return AzOptionImageRef_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionImageRef::hash() const {
    return AzOptionImageRef_hash(&inner_);
}

inline uint8_t OptionImageRef::partialCmp(const OptionImageRef& b) const {
    return AzOptionImageRef_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionImageRef::cmp(const OptionImageRef& b) const {
    return AzOptionImageRef_cmp(&inner_, b.ptr());
}

inline String OptionImageRef::toDbgString() const {
    return String(AzOptionImageRef_toDbgString(&inner_));
}

inline OptionLayoutSize OptionLayoutSize::none() {
    return OptionLayoutSize(AzOptionLayoutSize_none());
}

inline OptionLayoutSize OptionLayoutSize::some(LayoutSize payload) {
    return OptionLayoutSize(AzOptionLayoutSize_some(payload.release()));
}

inline bool OptionLayoutSize::partialEq(const OptionLayoutSize& b) const {
    return AzOptionLayoutSize_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionLayoutSize::hash() const {
    return AzOptionLayoutSize_hash(&inner_);
}

inline uint8_t OptionLayoutSize::partialCmp(const OptionLayoutSize& b) const {
    return AzOptionLayoutSize_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionLayoutSize::cmp(const OptionLayoutSize& b) const {
    return AzOptionLayoutSize_cmp(&inner_, b.ptr());
}

inline String OptionLayoutSize::toDbgString() const {
    return String(AzOptionLayoutSize_toDbgString(&inner_));
}

inline OptionColorU OptionColorU::none() {
    return OptionColorU(AzOptionColorU_none());
}

inline OptionColorU OptionColorU::some(ColorU payload) {
    return OptionColorU(AzOptionColorU_some(payload.release()));
}

inline bool OptionColorU::partialEq(const OptionColorU& b) const {
    return AzOptionColorU_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionColorU::hash() const {
    return AzOptionColorU_hash(&inner_);
}

inline uint8_t OptionColorU::partialCmp(const OptionColorU& b) const {
    return AzOptionColorU_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionColorU::cmp(const OptionColorU& b) const {
    return AzOptionColorU_cmp(&inner_, b.ptr());
}

inline String OptionColorU::toDbgString() const {
    return String(AzOptionColorU_toDbgString(&inner_));
}

inline OptionTabIndex OptionTabIndex::none() {
    return OptionTabIndex(AzOptionTabIndex_none());
}

inline OptionTabIndex OptionTabIndex::some(AzTabIndex payload) {
    return OptionTabIndex(AzOptionTabIndex_some(payload));
}

inline bool OptionTabIndex::partialEq(const OptionTabIndex& b) const {
    return AzOptionTabIndex_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionTabIndex::hash() const {
    return AzOptionTabIndex_hash(&inner_);
}

inline uint8_t OptionTabIndex::partialCmp(const OptionTabIndex& b) const {
    return AzOptionTabIndex_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionTabIndex::cmp(const OptionTabIndex& b) const {
    return AzOptionTabIndex_cmp(&inner_, b.ptr());
}

inline String OptionTabIndex::toDbgString() const {
    return String(AzOptionTabIndex_toDbgString(&inner_));
}

inline OptionLogicalPosition OptionLogicalPosition::none() {
    return OptionLogicalPosition(AzOptionLogicalPosition_none());
}

inline OptionLogicalPosition OptionLogicalPosition::some(LogicalPosition payload) {
    return OptionLogicalPosition(AzOptionLogicalPosition_some(payload.release()));
}

inline bool OptionLogicalPosition::partialEq(const OptionLogicalPosition& b) const {
    return AzOptionLogicalPosition_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionLogicalPosition::partialCmp(const OptionLogicalPosition& b) const {
    return AzOptionLogicalPosition_partialCmp(&inner_, b.ptr());
}

inline String OptionLogicalPosition::toDbgString() const {
    return String(AzOptionLogicalPosition_toDbgString(&inner_));
}

inline OptionScreenPosition OptionScreenPosition::none() {
    return OptionScreenPosition(AzOptionScreenPosition_none());
}

inline OptionScreenPosition OptionScreenPosition::some(ScreenPosition payload) {
    return OptionScreenPosition(AzOptionScreenPosition_some(payload.release()));
}

inline bool OptionScreenPosition::partialEq(const OptionScreenPosition& b) const {
    return AzOptionScreenPosition_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionScreenPosition::partialCmp(const OptionScreenPosition& b) const {
    return AzOptionScreenPosition_partialCmp(&inner_, b.ptr());
}

inline String OptionScreenPosition::toDbgString() const {
    return String(AzOptionScreenPosition_toDbgString(&inner_));
}

inline OptionCursorNodePosition OptionCursorNodePosition::none() {
    return OptionCursorNodePosition(AzOptionCursorNodePosition_none());
}

inline OptionCursorNodePosition OptionCursorNodePosition::some(CursorNodePosition payload) {
    return OptionCursorNodePosition(AzOptionCursorNodePosition_some(payload.release()));
}

inline bool OptionCursorNodePosition::partialEq(const OptionCursorNodePosition& b) const {
    return AzOptionCursorNodePosition_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionCursorNodePosition::partialCmp(const OptionCursorNodePosition& b) const {
    return AzOptionCursorNodePosition_partialCmp(&inner_, b.ptr());
}

inline String OptionCursorNodePosition::toDbgString() const {
    return String(AzOptionCursorNodePosition_toDbgString(&inner_));
}

inline OptionDragDelta OptionDragDelta::none() {
    return OptionDragDelta(AzOptionDragDelta_none());
}

inline OptionDragDelta OptionDragDelta::some(DragDelta payload) {
    return OptionDragDelta(AzOptionDragDelta_some(payload.release()));
}

inline bool OptionDragDelta::partialEq(const OptionDragDelta& b) const {
    return AzOptionDragDelta_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionDragDelta::partialCmp(const OptionDragDelta& b) const {
    return AzOptionDragDelta_partialCmp(&inner_, b.ptr());
}

inline String OptionDragDelta::toDbgString() const {
    return String(AzOptionDragDelta_toDbgString(&inner_));
}

inline OptionMouseCursorType OptionMouseCursorType::none() {
    return OptionMouseCursorType(AzOptionMouseCursorType_none());
}

inline OptionMouseCursorType OptionMouseCursorType::some(AzMouseCursorType payload) {
    return OptionMouseCursorType(AzOptionMouseCursorType_some(payload));
}

inline bool OptionMouseCursorType::partialEq(const OptionMouseCursorType& b) const {
    return AzOptionMouseCursorType_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionMouseCursorType::hash() const {
    return AzOptionMouseCursorType_hash(&inner_);
}

inline uint8_t OptionMouseCursorType::partialCmp(const OptionMouseCursorType& b) const {
    return AzOptionMouseCursorType_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionMouseCursorType::cmp(const OptionMouseCursorType& b) const {
    return AzOptionMouseCursorType_cmp(&inner_, b.ptr());
}

inline String OptionMouseCursorType::toDbgString() const {
    return String(AzOptionMouseCursorType_toDbgString(&inner_));
}

inline OptionHwndHandle OptionHwndHandle::none() {
    return OptionHwndHandle(AzOptionHwndHandle_none());
}

inline OptionHwndHandle OptionHwndHandle::some(AzHwndHandle payload) {
    return OptionHwndHandle(AzOptionHwndHandle_some(payload));
}

inline void OptionHwndHandle::delete_() {
    AzOptionHwndHandle_delete(&inner_);
}

inline OptionHwndHandle OptionHwndHandle::clone() const {
    return OptionHwndHandle(AzOptionHwndHandle_clone(&inner_));
}

inline bool OptionHwndHandle::partialEq(const OptionHwndHandle& b) const {
    return AzOptionHwndHandle_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionHwndHandle::hash() const {
    return AzOptionHwndHandle_hash(&inner_);
}

inline uint8_t OptionHwndHandle::partialCmp(const OptionHwndHandle& b) const {
    return AzOptionHwndHandle_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionHwndHandle::cmp(const OptionHwndHandle& b) const {
    return AzOptionHwndHandle_cmp(&inner_, b.ptr());
}

inline String OptionHwndHandle::toDbgString() const {
    return String(AzOptionHwndHandle_toDbgString(&inner_));
}

inline OptionLinuxDecorationsState OptionLinuxDecorationsState::none() {
    return OptionLinuxDecorationsState(AzOptionLinuxDecorationsState_none());
}

inline OptionLinuxDecorationsState OptionLinuxDecorationsState::some(LinuxDecorationsState payload) {
    return OptionLinuxDecorationsState(AzOptionLinuxDecorationsState_some(payload.release()));
}

inline bool OptionLinuxDecorationsState::partialEq(const OptionLinuxDecorationsState& b) const {
    return AzOptionLinuxDecorationsState_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionLinuxDecorationsState::hash() const {
    return AzOptionLinuxDecorationsState_hash(&inner_);
}

inline uint8_t OptionLinuxDecorationsState::partialCmp(const OptionLinuxDecorationsState& b) const {
    return AzOptionLinuxDecorationsState_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionLinuxDecorationsState::cmp(const OptionLinuxDecorationsState& b) const {
    return AzOptionLinuxDecorationsState_cmp(&inner_, b.ptr());
}

inline String OptionLinuxDecorationsState::toDbgString() const {
    return String(AzOptionLinuxDecorationsState_toDbgString(&inner_));
}

inline OptionLogicalSize OptionLogicalSize::none() {
    return OptionLogicalSize(AzOptionLogicalSize_none());
}

inline OptionLogicalSize OptionLogicalSize::some(LogicalSize payload) {
    return OptionLogicalSize(AzOptionLogicalSize_some(payload.release()));
}

inline bool OptionLogicalSize::partialEq(const OptionLogicalSize& b) const {
    return AzOptionLogicalSize_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionLogicalSize::partialCmp(const OptionLogicalSize& b) const {
    return AzOptionLogicalSize_partialCmp(&inner_, b.ptr());
}

inline String OptionLogicalSize::toDbgString() const {
    return String(AzOptionLogicalSize_toDbgString(&inner_));
}

inline OptionVirtualKeyCode OptionVirtualKeyCode::none() {
    return OptionVirtualKeyCode(AzOptionVirtualKeyCode_none());
}

inline OptionVirtualKeyCode OptionVirtualKeyCode::some(AzVirtualKeyCode payload) {
    return OptionVirtualKeyCode(AzOptionVirtualKeyCode_some(payload));
}

inline bool OptionVirtualKeyCode::partialEq(const OptionVirtualKeyCode& b) const {
    return AzOptionVirtualKeyCode_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionVirtualKeyCode::hash() const {
    return AzOptionVirtualKeyCode_hash(&inner_);
}

inline uint8_t OptionVirtualKeyCode::partialCmp(const OptionVirtualKeyCode& b) const {
    return AzOptionVirtualKeyCode_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionVirtualKeyCode::cmp(const OptionVirtualKeyCode& b) const {
    return AzOptionVirtualKeyCode_cmp(&inner_, b.ptr());
}

inline String OptionVirtualKeyCode::toDbgString() const {
    return String(AzOptionVirtualKeyCode_toDbgString(&inner_));
}

inline OptionX11Visual OptionX11Visual::none() {
    return OptionX11Visual(AzOptionX11Visual_none());
}

inline OptionX11Visual OptionX11Visual::some(AzX11Visual payload) {
    return OptionX11Visual(AzOptionX11Visual_some(payload));
}

inline bool OptionX11Visual::partialEq(const OptionX11Visual& b) const {
    return AzOptionX11Visual_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionX11Visual::hash() const {
    return AzOptionX11Visual_hash(&inner_);
}

inline uint8_t OptionX11Visual::partialCmp(const OptionX11Visual& b) const {
    return AzOptionX11Visual_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionX11Visual::cmp(const OptionX11Visual& b) const {
    return AzOptionX11Visual_cmp(&inner_, b.ptr());
}

inline String OptionX11Visual::toDbgString() const {
    return String(AzOptionX11Visual_toDbgString(&inner_));
}

inline OptionWindowTheme OptionWindowTheme::none() {
    return OptionWindowTheme(AzOptionWindowTheme_none());
}

inline OptionWindowTheme OptionWindowTheme::some(AzWindowTheme payload) {
    return OptionWindowTheme(AzOptionWindowTheme_some(payload));
}

inline bool OptionWindowTheme::partialEq(const OptionWindowTheme& b) const {
    return AzOptionWindowTheme_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionWindowTheme::hash() const {
    return AzOptionWindowTheme_hash(&inner_);
}

inline uint8_t OptionWindowTheme::partialCmp(const OptionWindowTheme& b) const {
    return AzOptionWindowTheme_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionWindowTheme::cmp(const OptionWindowTheme& b) const {
    return AzOptionWindowTheme_cmp(&inner_, b.ptr());
}

inline String OptionWindowTheme::toDbgString() const {
    return String(AzOptionWindowTheme_toDbgString(&inner_));
}

inline OptionAccessibilityRole OptionAccessibilityRole::none() {
    return OptionAccessibilityRole(AzOptionAccessibilityRole_none());
}

inline OptionAccessibilityRole OptionAccessibilityRole::some(AzAccessibilityRole payload) {
    return OptionAccessibilityRole(AzOptionAccessibilityRole_some(payload));
}

inline bool OptionAccessibilityRole::partialEq(const OptionAccessibilityRole& b) const {
    return AzOptionAccessibilityRole_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionAccessibilityRole::hash() const {
    return AzOptionAccessibilityRole_hash(&inner_);
}

inline uint8_t OptionAccessibilityRole::partialCmp(const OptionAccessibilityRole& b) const {
    return AzOptionAccessibilityRole_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionAccessibilityRole::cmp(const OptionAccessibilityRole& b) const {
    return AzOptionAccessibilityRole_cmp(&inner_, b.ptr());
}

inline String OptionAccessibilityRole::toDbgString() const {
    return String(AzOptionAccessibilityRole_toDbgString(&inner_));
}

inline OptionPenTilt OptionPenTilt::none() {
    return OptionPenTilt(AzOptionPenTilt_none());
}

inline OptionPenTilt OptionPenTilt::some(PenTilt payload) {
    return OptionPenTilt(AzOptionPenTilt_some(payload.release()));
}

inline bool OptionPenTilt::partialEq(const OptionPenTilt& b) const {
    return AzOptionPenTilt_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionPenTilt::partialCmp(const OptionPenTilt& b) const {
    return AzOptionPenTilt_partialCmp(&inner_, b.ptr());
}

inline String OptionPenTilt::toDbgString() const {
    return String(AzOptionPenTilt_toDbgString(&inner_));
}

inline OptionGestureDirection OptionGestureDirection::none() {
    return OptionGestureDirection(AzOptionGestureDirection_none());
}

inline OptionGestureDirection OptionGestureDirection::some(AzGestureDirection payload) {
    return OptionGestureDirection(AzOptionGestureDirection_some(payload));
}

inline bool OptionGestureDirection::partialEq(const OptionGestureDirection& b) const {
    return AzOptionGestureDirection_partialEq(&inner_, b.ptr());
}

inline String OptionGestureDirection::toDbgString() const {
    return String(AzOptionGestureDirection_toDbgString(&inner_));
}

inline OptionThreadId OptionThreadId::none() {
    return OptionThreadId(AzOptionThreadId_none());
}

inline OptionThreadId OptionThreadId::some(ThreadId payload) {
    return OptionThreadId(AzOptionThreadId_some(payload.release()));
}

inline bool OptionThreadId::partialEq(const OptionThreadId& b) const {
    return AzOptionThreadId_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionThreadId::hash() const {
    return AzOptionThreadId_hash(&inner_);
}

inline uint8_t OptionThreadId::partialCmp(const OptionThreadId& b) const {
    return AzOptionThreadId_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionThreadId::cmp(const OptionThreadId& b) const {
    return AzOptionThreadId_cmp(&inner_, b.ptr());
}

inline String OptionThreadId::toDbgString() const {
    return String(AzOptionThreadId_toDbgString(&inner_));
}

inline OptionDomId OptionDomId::none() {
    return OptionDomId(AzOptionDomId_none());
}

inline OptionDomId OptionDomId::some(DomId payload) {
    return OptionDomId(AzOptionDomId_some(payload.release()));
}

inline bool OptionDomId::partialEq(const OptionDomId& b) const {
    return AzOptionDomId_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionDomId::hash() const {
    return AzOptionDomId_hash(&inner_);
}

inline uint8_t OptionDomId::partialCmp(const OptionDomId& b) const {
    return AzOptionDomId_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionDomId::cmp(const OptionDomId& b) const {
    return AzOptionDomId_cmp(&inner_, b.ptr());
}

inline String OptionDomId::toDbgString() const {
    return String(AzOptionDomId_toDbgString(&inner_));
}

inline OptionAccessibilityState OptionAccessibilityState::none() {
    return OptionAccessibilityState(AzOptionAccessibilityState_none());
}

inline OptionAccessibilityState OptionAccessibilityState::some(AzAccessibilityState payload) {
    return OptionAccessibilityState(AzOptionAccessibilityState_some(payload));
}

inline bool OptionAccessibilityState::partialEq(const OptionAccessibilityState& b) const {
    return AzOptionAccessibilityState_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionAccessibilityState::hash() const {
    return AzOptionAccessibilityState_hash(&inner_);
}

inline uint8_t OptionAccessibilityState::partialCmp(const OptionAccessibilityState& b) const {
    return AzOptionAccessibilityState_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionAccessibilityState::cmp(const OptionAccessibilityState& b) const {
    return AzOptionAccessibilityState_cmp(&inner_, b.ptr());
}

inline String OptionAccessibilityState::toDbgString() const {
    return String(AzOptionAccessibilityState_toDbgString(&inner_));
}

inline OptionSvgVertex OptionSvgVertex::none() {
    return OptionSvgVertex(AzOptionSvgVertex_none());
}

inline OptionSvgVertex OptionSvgVertex::some(SvgVertex payload) {
    return OptionSvgVertex(AzOptionSvgVertex_some(payload.release()));
}

inline bool OptionSvgVertex::partialEq(const OptionSvgVertex& b) const {
    return AzOptionSvgVertex_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionSvgVertex::partialCmp(const OptionSvgVertex& b) const {
    return AzOptionSvgVertex_partialCmp(&inner_, b.ptr());
}

inline String OptionSvgVertex::toDbgString() const {
    return String(AzOptionSvgVertex_toDbgString(&inner_));
}

inline OptionCascadeInfo OptionCascadeInfo::none() {
    return OptionCascadeInfo(AzOptionCascadeInfo_none());
}

inline OptionCascadeInfo OptionCascadeInfo::some(CascadeInfo payload) {
    return OptionCascadeInfo(AzOptionCascadeInfo_some(payload.release()));
}

inline bool OptionCascadeInfo::partialEq(const OptionCascadeInfo& b) const {
    return AzOptionCascadeInfo_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionCascadeInfo::hash() const {
    return AzOptionCascadeInfo_hash(&inner_);
}

inline uint8_t OptionCascadeInfo::partialCmp(const OptionCascadeInfo& b) const {
    return AzOptionCascadeInfo_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionCascadeInfo::cmp(const OptionCascadeInfo& b) const {
    return AzOptionCascadeInfo_cmp(&inner_, b.ptr());
}

inline String OptionCascadeInfo::toDbgString() const {
    return String(AzOptionCascadeInfo_toDbgString(&inner_));
}

inline OptionNodeHierarchyItem OptionNodeHierarchyItem::none() {
    return OptionNodeHierarchyItem(AzOptionNodeHierarchyItem_none());
}

inline OptionNodeHierarchyItem OptionNodeHierarchyItem::some(NodeHierarchyItem payload) {
    return OptionNodeHierarchyItem(AzOptionNodeHierarchyItem_some(payload.release()));
}

inline bool OptionNodeHierarchyItem::partialEq(const OptionNodeHierarchyItem& b) const {
    return AzOptionNodeHierarchyItem_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionNodeHierarchyItem::hash() const {
    return AzOptionNodeHierarchyItem_hash(&inner_);
}

inline uint8_t OptionNodeHierarchyItem::partialCmp(const OptionNodeHierarchyItem& b) const {
    return AzOptionNodeHierarchyItem_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionNodeHierarchyItem::cmp(const OptionNodeHierarchyItem& b) const {
    return AzOptionNodeHierarchyItem_cmp(&inner_, b.ptr());
}

inline String OptionNodeHierarchyItem::toDbgString() const {
    return String(AzOptionNodeHierarchyItem_toDbgString(&inner_));
}

inline OptionXWindowType OptionXWindowType::none() {
    return OptionXWindowType(AzOptionXWindowType_none());
}

inline OptionXWindowType OptionXWindowType::some(AzXWindowType payload) {
    return OptionXWindowType(AzOptionXWindowType_some(payload));
}

inline bool OptionXWindowType::partialEq(const OptionXWindowType& b) const {
    return AzOptionXWindowType_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionXWindowType::hash() const {
    return AzOptionXWindowType_hash(&inner_);
}

inline uint8_t OptionXWindowType::partialCmp(const OptionXWindowType& b) const {
    return AzOptionXWindowType_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionXWindowType::cmp(const OptionXWindowType& b) const {
    return AzOptionXWindowType_cmp(&inner_, b.ptr());
}

inline String OptionXWindowType::toDbgString() const {
    return String(AzOptionXWindowType_toDbgString(&inner_));
}

inline OptionStyleBackgroundRepeat OptionStyleBackgroundRepeat::none() {
    return OptionStyleBackgroundRepeat(AzOptionStyleBackgroundRepeat_none());
}

inline OptionStyleBackgroundRepeat OptionStyleBackgroundRepeat::some(AzStyleBackgroundRepeat payload) {
    return OptionStyleBackgroundRepeat(AzOptionStyleBackgroundRepeat_some(payload));
}

inline bool OptionStyleBackgroundRepeat::partialEq(const OptionStyleBackgroundRepeat& b) const {
    return AzOptionStyleBackgroundRepeat_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionStyleBackgroundRepeat::hash() const {
    return AzOptionStyleBackgroundRepeat_hash(&inner_);
}

inline uint8_t OptionStyleBackgroundRepeat::partialCmp(const OptionStyleBackgroundRepeat& b) const {
    return AzOptionStyleBackgroundRepeat_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionStyleBackgroundRepeat::cmp(const OptionStyleBackgroundRepeat& b) const {
    return AzOptionStyleBackgroundRepeat_cmp(&inner_, b.ptr());
}

inline String OptionStyleBackgroundRepeat::toDbgString() const {
    return String(AzOptionStyleBackgroundRepeat_toDbgString(&inner_));
}

inline OptionShapePoint OptionShapePoint::none() {
    return OptionShapePoint(AzOptionShapePoint_none());
}

inline OptionShapePoint OptionShapePoint::some(ShapePoint payload) {
    return OptionShapePoint(AzOptionShapePoint_some(payload.release()));
}

inline bool OptionShapePoint::partialEq(const OptionShapePoint& b) const {
    return AzOptionShapePoint_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionShapePoint::partialCmp(const OptionShapePoint& b) const {
    return AzOptionShapePoint_partialCmp(&inner_, b.ptr());
}

inline String OptionShapePoint::toDbgString() const {
    return String(AzOptionShapePoint_toDbgString(&inner_));
}

inline OptionU8VecRef OptionU8VecRef::none() {
    return OptionU8VecRef(AzOptionU8VecRef_none());
}

inline OptionU8VecRef OptionU8VecRef::some(U8VecRef payload) {
    return OptionU8VecRef(AzOptionU8VecRef_some(payload.release()));
}

inline void OptionU8VecRef::delete_() {
    AzOptionU8VecRef_delete(&inner_);
}

inline OptionU8VecRef OptionU8VecRef::clone() const {
    return OptionU8VecRef(AzOptionU8VecRef_clone(&inner_));
}

inline bool OptionU8VecRef::partialEq(const OptionU8VecRef& b) const {
    return AzOptionU8VecRef_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionU8VecRef::hash() const {
    return AzOptionU8VecRef_hash(&inner_);
}

inline uint8_t OptionU8VecRef::partialCmp(const OptionU8VecRef& b) const {
    return AzOptionU8VecRef_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionU8VecRef::cmp(const OptionU8VecRef& b) const {
    return AzOptionU8VecRef_cmp(&inner_, b.ptr());
}

inline String OptionU8VecRef::toDbgString() const {
    return String(AzOptionU8VecRef_toDbgString(&inner_));
}

inline OptionNodeHierarchyItemId OptionNodeHierarchyItemId::none() {
    return OptionNodeHierarchyItemId(AzOptionNodeHierarchyItemId_none());
}

inline OptionNodeHierarchyItemId OptionNodeHierarchyItemId::some(NodeHierarchyItemId payload) {
    return OptionNodeHierarchyItemId(AzOptionNodeHierarchyItemId_some(payload.release()));
}

inline bool OptionNodeHierarchyItemId::partialEq(const OptionNodeHierarchyItemId& b) const {
    return AzOptionNodeHierarchyItemId_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionNodeHierarchyItemId::hash() const {
    return AzOptionNodeHierarchyItemId_hash(&inner_);
}

inline uint8_t OptionNodeHierarchyItemId::partialCmp(const OptionNodeHierarchyItemId& b) const {
    return AzOptionNodeHierarchyItemId_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionNodeHierarchyItemId::cmp(const OptionNodeHierarchyItemId& b) const {
    return AzOptionNodeHierarchyItemId_cmp(&inner_, b.ptr());
}

inline String OptionNodeHierarchyItemId::toDbgString() const {
    return String(AzOptionNodeHierarchyItemId_toDbgString(&inner_));
}

inline OptionLinuxDesktopEnv OptionLinuxDesktopEnv::none() {
    return OptionLinuxDesktopEnv(AzOptionLinuxDesktopEnv_none());
}

inline OptionLinuxDesktopEnv OptionLinuxDesktopEnv::some(AzLinuxDesktopEnv payload) {
    return OptionLinuxDesktopEnv(AzOptionLinuxDesktopEnv_some(payload));
}

inline bool OptionLinuxDesktopEnv::partialEq(const OptionLinuxDesktopEnv& b) const {
    return AzOptionLinuxDesktopEnv_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionLinuxDesktopEnv::hash() const {
    return AzOptionLinuxDesktopEnv_hash(&inner_);
}

inline String OptionLinuxDesktopEnv::toDbgString() const {
    return String(AzOptionLinuxDesktopEnv_toDbgString(&inner_));
}

inline OptionOsCondition OptionOsCondition::none() {
    return OptionOsCondition(AzOptionOsCondition_none());
}

inline OptionOsCondition OptionOsCondition::some(AzOsCondition payload) {
    return OptionOsCondition(AzOptionOsCondition_some(payload));
}

inline bool OptionOsCondition::partialEq(const OptionOsCondition& b) const {
    return AzOptionOsCondition_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionOsCondition::hash() const {
    return AzOptionOsCondition_hash(&inner_);
}

inline String OptionOsCondition::toDbgString() const {
    return String(AzOptionOsCondition_toDbgString(&inner_));
}

inline OptionSvgDashPattern OptionSvgDashPattern::none() {
    return OptionSvgDashPattern(AzOptionSvgDashPattern_none());
}

inline OptionSvgDashPattern OptionSvgDashPattern::some(SvgDashPattern payload) {
    return OptionSvgDashPattern(AzOptionSvgDashPattern_some(payload.release()));
}

inline bool OptionSvgDashPattern::partialEq(const OptionSvgDashPattern& b) const {
    return AzOptionSvgDashPattern_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionSvgDashPattern::partialCmp(const OptionSvgDashPattern& b) const {
    return AzOptionSvgDashPattern_partialCmp(&inner_, b.ptr());
}

inline String OptionSvgDashPattern::toDbgString() const {
    return String(AzOptionSvgDashPattern_toDbgString(&inner_));
}

inline OptionSvgPoint OptionSvgPoint::none() {
    return OptionSvgPoint(AzOptionSvgPoint_none());
}

inline OptionSvgPoint OptionSvgPoint::some(SvgPoint payload) {
    return OptionSvgPoint(AzOptionSvgPoint_some(payload.release()));
}

inline void OptionSvgPoint::delete_() {
    AzOptionSvgPoint_delete(&inner_);
}

inline OptionSvgPoint OptionSvgPoint::clone() const {
    return OptionSvgPoint(AzOptionSvgPoint_clone(&inner_));
}

inline bool OptionSvgPoint::partialEq(const OptionSvgPoint& b) const {
    return AzOptionSvgPoint_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionSvgPoint::partialCmp(const OptionSvgPoint& b) const {
    return AzOptionSvgPoint_partialCmp(&inner_, b.ptr());
}

inline String OptionSvgPoint::toDbgString() const {
    return String(AzOptionSvgPoint_toDbgString(&inner_));
}

inline OptionLocationFix OptionLocationFix::none() {
    return OptionLocationFix(AzOptionLocationFix_none());
}

inline OptionLocationFix OptionLocationFix::some(LocationFix payload) {
    return OptionLocationFix(AzOptionLocationFix_some(payload.release()));
}

inline bool OptionLocationFix::partialEq(const OptionLocationFix& b) const {
    return AzOptionLocationFix_partialEq(&inner_, b.ptr());
}

inline String OptionLocationFix::toDbgString() const {
    return String(AzOptionLocationFix_toDbgString(&inner_));
}

inline OptionBiometricResult OptionBiometricResult::none() {
    return OptionBiometricResult(AzOptionBiometricResult_none());
}

inline OptionBiometricResult OptionBiometricResult::some(AzBiometricResult payload) {
    return OptionBiometricResult(AzOptionBiometricResult_some(payload));
}

inline bool OptionBiometricResult::partialEq(const OptionBiometricResult& b) const {
    return AzOptionBiometricResult_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionBiometricResult::hash() const {
    return AzOptionBiometricResult_hash(&inner_);
}

inline uint8_t OptionBiometricResult::partialCmp(const OptionBiometricResult& b) const {
    return AzOptionBiometricResult_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionBiometricResult::cmp(const OptionBiometricResult& b) const {
    return AzOptionBiometricResult_cmp(&inner_, b.ptr());
}

inline String OptionBiometricResult::toDbgString() const {
    return String(AzOptionBiometricResult_toDbgString(&inner_));
}

inline OptionWacomPadState OptionWacomPadState::none() {
    return OptionWacomPadState(AzOptionWacomPadState_none());
}

inline OptionWacomPadState OptionWacomPadState::some(WacomPadState payload) {
    return OptionWacomPadState(AzOptionWacomPadState_some(payload.release()));
}

inline bool OptionWacomPadState::partialEq(const OptionWacomPadState& b) const {
    return AzOptionWacomPadState_partialEq(&inner_, b.ptr());
}

inline String OptionWacomPadState::toDbgString() const {
    return String(AzOptionWacomPadState_toDbgString(&inner_));
}

inline OptionScrollState OptionScrollState::none() {
    return OptionScrollState(AzOptionScrollState_none());
}

inline OptionScrollState OptionScrollState::some(ScrollState payload) {
    return OptionScrollState(AzOptionScrollState_some(payload.release()));
}

inline bool OptionScrollState::partialEq(const OptionScrollState& b) const {
    return AzOptionScrollState_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionScrollState::partialCmp(const OptionScrollState& b) const {
    return AzOptionScrollState_partialCmp(&inner_, b.ptr());
}

inline String OptionScrollState::toDbgString() const {
    return String(AzOptionScrollState_toDbgString(&inner_));
}

inline OptionPixelValue OptionPixelValue::none() {
    return OptionPixelValue(AzOptionPixelValue_none());
}

inline OptionPixelValue OptionPixelValue::some(PixelValue payload) {
    return OptionPixelValue(AzOptionPixelValue_some(payload.release()));
}

inline bool OptionPixelValue::partialEq(const OptionPixelValue& b) const {
    return AzOptionPixelValue_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionPixelValue::hash() const {
    return AzOptionPixelValue_hash(&inner_);
}

inline uint8_t OptionPixelValue::partialCmp(const OptionPixelValue& b) const {
    return AzOptionPixelValue_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionPixelValue::cmp(const OptionPixelValue& b) const {
    return AzOptionPixelValue_cmp(&inner_, b.ptr());
}

inline String OptionPixelValue::toDbgString() const {
    return String(AzOptionPixelValue_toDbgString(&inner_));
}

inline OptionTextInputSelection OptionTextInputSelection::none() {
    return OptionTextInputSelection(AzOptionTextInputSelection_none());
}

inline OptionTextInputSelection OptionTextInputSelection::some(AzTextInputSelection payload) {
    return OptionTextInputSelection(AzOptionTextInputSelection_some(payload));
}

inline void OptionTextInputSelection::delete_() {
    AzOptionTextInputSelection_delete(&inner_);
}

inline OptionTextInputSelection OptionTextInputSelection::clone() const {
    return OptionTextInputSelection(AzOptionTextInputSelection_clone(&inner_));
}

inline bool OptionTextInputSelection::partialEq(const OptionTextInputSelection& b) const {
    return AzOptionTextInputSelection_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionTextInputSelection::hash() const {
    return AzOptionTextInputSelection_hash(&inner_);
}

inline String OptionTextInputSelection::toDbgString() const {
    return String(AzOptionTextInputSelection_toDbgString(&inner_));
}

inline OptionMenuItemIcon OptionMenuItemIcon::none() {
    return OptionMenuItemIcon(AzOptionMenuItemIcon_none());
}

inline OptionMenuItemIcon OptionMenuItemIcon::some(AzMenuItemIcon payload) {
    return OptionMenuItemIcon(AzOptionMenuItemIcon_some(payload));
}

inline void OptionMenuItemIcon::delete_() {
    AzOptionMenuItemIcon_delete(&inner_);
}

inline OptionMenuItemIcon OptionMenuItemIcon::clone() const {
    return OptionMenuItemIcon(AzOptionMenuItemIcon_clone(&inner_));
}

inline bool OptionMenuItemIcon::partialEq(const OptionMenuItemIcon& b) const {
    return AzOptionMenuItemIcon_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionMenuItemIcon::hash() const {
    return AzOptionMenuItemIcon_hash(&inner_);
}

inline uint8_t OptionMenuItemIcon::partialCmp(const OptionMenuItemIcon& b) const {
    return AzOptionMenuItemIcon_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionMenuItemIcon::cmp(const OptionMenuItemIcon& b) const {
    return AzOptionMenuItemIcon_cmp(&inner_, b.ptr());
}

inline String OptionMenuItemIcon::toDbgString() const {
    return String(AzOptionMenuItemIcon_toDbgString(&inner_));
}

inline OptionFontRef OptionFontRef::none() {
    return OptionFontRef(AzOptionFontRef_none());
}

inline OptionFontRef OptionFontRef::some(FontRef payload) {
    return OptionFontRef(AzOptionFontRef_some(payload.release()));
}

inline void OptionFontRef::delete_() {
    AzOptionFontRef_delete(&inner_);
}

inline OptionFontRef OptionFontRef::clone() const {
    return OptionFontRef(AzOptionFontRef_clone(&inner_));
}

inline bool OptionFontRef::partialEq(const OptionFontRef& b) const {
    return AzOptionFontRef_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionFontRef::hash() const {
    return AzOptionFontRef_hash(&inner_);
}

inline String OptionFontRef::toDbgString() const {
    return String(AzOptionFontRef_toDbgString(&inner_));
}

inline OptionRefAny OptionRefAny::none() {
    return OptionRefAny(AzOptionRefAny_none());
}

inline OptionRefAny OptionRefAny::some(RefAny payload) {
    return OptionRefAny(AzOptionRefAny_some(payload.release()));
}

inline void OptionRefAny::delete_() {
    AzOptionRefAny_delete(&inner_);
}

inline OptionRefAny OptionRefAny::clone() const {
    return OptionRefAny(AzOptionRefAny_clone(&inner_));
}

inline bool OptionRefAny::partialEq(const OptionRefAny& b) const {
    return AzOptionRefAny_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionRefAny::hash() const {
    return AzOptionRefAny_hash(&inner_);
}

inline uint8_t OptionRefAny::partialCmp(const OptionRefAny& b) const {
    return AzOptionRefAny_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionRefAny::cmp(const OptionRefAny& b) const {
    return AzOptionRefAny_cmp(&inner_, b.ptr());
}

inline String OptionRefAny::toDbgString() const {
    return String(AzOptionRefAny_toDbgString(&inner_));
}

inline OptionLayoutRect OptionLayoutRect::none() {
    return OptionLayoutRect(AzOptionLayoutRect_none());
}

inline OptionLayoutRect OptionLayoutRect::some(LayoutRect payload) {
    return OptionLayoutRect(AzOptionLayoutRect_some(payload.release()));
}

inline bool OptionLayoutRect::partialEq(const OptionLayoutRect& b) const {
    return AzOptionLayoutRect_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionLayoutRect::partialCmp(const OptionLayoutRect& b) const {
    return AzOptionLayoutRect_partialCmp(&inner_, b.ptr());
}

inline String OptionLayoutRect::toDbgString() const {
    return String(AzOptionLayoutRect_toDbgString(&inner_));
}

inline OptionDomNodeId OptionDomNodeId::none() {
    return OptionDomNodeId(AzOptionDomNodeId_none());
}

inline OptionDomNodeId OptionDomNodeId::some(DomNodeId payload) {
    return OptionDomNodeId(AzOptionDomNodeId_some(payload.release()));
}

inline bool OptionDomNodeId::partialEq(const OptionDomNodeId& b) const {
    return AzOptionDomNodeId_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionDomNodeId::hash() const {
    return AzOptionDomNodeId_hash(&inner_);
}

inline uint8_t OptionDomNodeId::partialCmp(const OptionDomNodeId& b) const {
    return AzOptionDomNodeId_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionDomNodeId::cmp(const OptionDomNodeId& b) const {
    return AzOptionDomNodeId_cmp(&inner_, b.ptr());
}

inline String OptionDomNodeId::toDbgString() const {
    return String(AzOptionDomNodeId_toDbgString(&inner_));
}

inline OptionDuration OptionDuration::none() {
    return OptionDuration(AzOptionDuration_none());
}

inline OptionDuration OptionDuration::some(AzDuration payload) {
    return OptionDuration(AzOptionDuration_some(payload));
}

inline bool OptionDuration::partialEq(const OptionDuration& b) const {
    return AzOptionDuration_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionDuration::hash() const {
    return AzOptionDuration_hash(&inner_);
}

inline uint8_t OptionDuration::partialCmp(const OptionDuration& b) const {
    return AzOptionDuration_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionDuration::cmp(const OptionDuration& b) const {
    return AzOptionDuration_cmp(&inner_, b.ptr());
}

inline String OptionDuration::toDbgString() const {
    return String(AzOptionDuration_toDbgString(&inner_));
}

inline OptionLogicalRect OptionLogicalRect::none() {
    return OptionLogicalRect(AzOptionLogicalRect_none());
}

inline OptionLogicalRect OptionLogicalRect::some(LogicalRect payload) {
    return OptionLogicalRect(AzOptionLogicalRect_some(payload.release()));
}

inline bool OptionLogicalRect::partialEq(const OptionLogicalRect& b) const {
    return AzOptionLogicalRect_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionLogicalRect::partialCmp(const OptionLogicalRect& b) const {
    return AzOptionLogicalRect_partialCmp(&inner_, b.ptr());
}

inline String OptionLogicalRect::toDbgString() const {
    return String(AzOptionLogicalRect_toDbgString(&inner_));
}

inline OptionRendererOptions OptionRendererOptions::none() {
    return OptionRendererOptions(AzOptionRendererOptions_none());
}

inline OptionRendererOptions OptionRendererOptions::some(RendererOptions payload) {
    return OptionRendererOptions(AzOptionRendererOptions_some(payload.release()));
}

inline bool OptionRendererOptions::partialEq(const OptionRendererOptions& b) const {
    return AzOptionRendererOptions_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionRendererOptions::hash() const {
    return AzOptionRendererOptions_hash(&inner_);
}

inline uint8_t OptionRendererOptions::partialCmp(const OptionRendererOptions& b) const {
    return AzOptionRendererOptions_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionRendererOptions::cmp(const OptionRendererOptions& b) const {
    return AzOptionRendererOptions_cmp(&inner_, b.ptr());
}

inline String OptionRendererOptions::toDbgString() const {
    return String(AzOptionRendererOptions_toDbgString(&inner_));
}

inline OptionGlContextPtr OptionGlContextPtr::none() {
    return OptionGlContextPtr(AzOptionGlContextPtr_none());
}

inline OptionGlContextPtr OptionGlContextPtr::some(GlContextPtr payload) {
    return OptionGlContextPtr(AzOptionGlContextPtr_some(payload.release()));
}

inline void OptionGlContextPtr::delete_() {
    AzOptionGlContextPtr_delete(&inner_);
}

inline OptionGlContextPtr OptionGlContextPtr::clone() const {
    return OptionGlContextPtr(AzOptionGlContextPtr_clone(&inner_));
}

inline bool OptionGlContextPtr::partialEq(const OptionGlContextPtr& b) const {
    return AzOptionGlContextPtr_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionGlContextPtr::partialCmp(const OptionGlContextPtr& b) const {
    return AzOptionGlContextPtr_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionGlContextPtr::cmp(const OptionGlContextPtr& b) const {
    return AzOptionGlContextPtr_cmp(&inner_, b.ptr());
}

inline String OptionGlContextPtr::toDbgString() const {
    return String(AzOptionGlContextPtr_toDbgString(&inner_));
}

inline OptionTextCursor OptionTextCursor::none() {
    return OptionTextCursor(AzOptionTextCursor_none());
}

inline OptionTextCursor OptionTextCursor::some(TextCursor payload) {
    return OptionTextCursor(AzOptionTextCursor_some(payload.release()));
}

inline bool OptionTextCursor::partialEq(const OptionTextCursor& b) const {
    return AzOptionTextCursor_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionTextCursor::hash() const {
    return AzOptionTextCursor_hash(&inner_);
}

inline uint8_t OptionTextCursor::partialCmp(const OptionTextCursor& b) const {
    return AzOptionTextCursor_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionTextCursor::cmp(const OptionTextCursor& b) const {
    return AzOptionTextCursor_cmp(&inner_, b.ptr());
}

inline String OptionTextCursor::toDbgString() const {
    return String(AzOptionTextCursor_toDbgString(&inner_));
}

inline OptionWindowFlags OptionWindowFlags::none() {
    return OptionWindowFlags(AzOptionWindowFlags_none());
}

inline OptionWindowFlags OptionWindowFlags::some(WindowFlags payload) {
    return OptionWindowFlags(AzOptionWindowFlags_some(payload.release()));
}

inline void OptionWindowFlags::delete_() {
    AzOptionWindowFlags_delete(&inner_);
}

inline OptionWindowFlags OptionWindowFlags::clone() const {
    return OptionWindowFlags(AzOptionWindowFlags_clone(&inner_));
}

inline bool OptionWindowFlags::partialEq(const OptionWindowFlags& b) const {
    return AzOptionWindowFlags_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionWindowFlags::hash() const {
    return AzOptionWindowFlags_hash(&inner_);
}

inline uint8_t OptionWindowFlags::partialCmp(const OptionWindowFlags& b) const {
    return AzOptionWindowFlags_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionWindowFlags::cmp(const OptionWindowFlags& b) const {
    return AzOptionWindowFlags_cmp(&inner_, b.ptr());
}

inline String OptionWindowFlags::toDbgString() const {
    return String(AzOptionWindowFlags_toDbgString(&inner_));
}

inline OptionDetectedPinch OptionDetectedPinch::none() {
    return OptionDetectedPinch(AzOptionDetectedPinch_none());
}

inline OptionDetectedPinch OptionDetectedPinch::some(DetectedPinch payload) {
    return OptionDetectedPinch(AzOptionDetectedPinch_some(payload.release()));
}

inline bool OptionDetectedPinch::partialEq(const OptionDetectedPinch& b) const {
    return AzOptionDetectedPinch_partialEq(&inner_, b.ptr());
}

inline String OptionDetectedPinch::toDbgString() const {
    return String(AzOptionDetectedPinch_toDbgString(&inner_));
}

inline OptionDetectedRotation OptionDetectedRotation::none() {
    return OptionDetectedRotation(AzOptionDetectedRotation_none());
}

inline OptionDetectedRotation OptionDetectedRotation::some(DetectedRotation payload) {
    return OptionDetectedRotation(AzOptionDetectedRotation_some(payload.release()));
}

inline bool OptionDetectedRotation::partialEq(const OptionDetectedRotation& b) const {
    return AzOptionDetectedRotation_partialEq(&inner_, b.ptr());
}

inline String OptionDetectedRotation::toDbgString() const {
    return String(AzOptionDetectedRotation_toDbgString(&inner_));
}

inline OptionDetectedLongPress OptionDetectedLongPress::none() {
    return OptionDetectedLongPress(AzOptionDetectedLongPress_none());
}

inline OptionDetectedLongPress OptionDetectedLongPress::some(DetectedLongPress payload) {
    return OptionDetectedLongPress(AzOptionDetectedLongPress_some(payload.release()));
}

inline bool OptionDetectedLongPress::partialEq(const OptionDetectedLongPress& b) const {
    return AzOptionDetectedLongPress_partialEq(&inner_, b.ptr());
}

inline String OptionDetectedLongPress::toDbgString() const {
    return String(AzOptionDetectedLongPress_toDbgString(&inner_));
}

inline OptionPenState OptionPenState::none() {
    return OptionPenState(AzOptionPenState_none());
}

inline OptionPenState OptionPenState::some(PenState payload) {
    return OptionPenState(AzOptionPenState_some(payload.release()));
}

inline bool OptionPenState::partialEq(const OptionPenState& b) const {
    return AzOptionPenState_partialEq(&inner_, b.ptr());
}

inline String OptionPenState::toDbgString() const {
    return String(AzOptionPenState_toDbgString(&inner_));
}

inline OptionStyledNode OptionStyledNode::none() {
    return OptionStyledNode(AzOptionStyledNode_none());
}

inline OptionStyledNode OptionStyledNode::some(StyledNode payload) {
    return OptionStyledNode(AzOptionStyledNode_some(payload.release()));
}

inline void OptionStyledNode::delete_() {
    AzOptionStyledNode_delete(&inner_);
}

inline OptionStyledNode OptionStyledNode::clone() const {
    return OptionStyledNode(AzOptionStyledNode_clone(&inner_));
}

inline bool OptionStyledNode::partialEq(const OptionStyledNode& b) const {
    return AzOptionStyledNode_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionStyledNode::partialCmp(const OptionStyledNode& b) const {
    return AzOptionStyledNode_partialCmp(&inner_, b.ptr());
}

inline String OptionStyledNode::toDbgString() const {
    return String(AzOptionStyledNode_toDbgString(&inner_));
}

inline OptionParentWithNodeDepth OptionParentWithNodeDepth::none() {
    return OptionParentWithNodeDepth(AzOptionParentWithNodeDepth_none());
}

inline OptionParentWithNodeDepth OptionParentWithNodeDepth::some(ParentWithNodeDepth payload) {
    return OptionParentWithNodeDepth(AzOptionParentWithNodeDepth_some(payload.release()));
}

inline bool OptionParentWithNodeDepth::partialEq(const OptionParentWithNodeDepth& b) const {
    return AzOptionParentWithNodeDepth_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionParentWithNodeDepth::hash() const {
    return AzOptionParentWithNodeDepth_hash(&inner_);
}

inline uint8_t OptionParentWithNodeDepth::partialCmp(const OptionParentWithNodeDepth& b) const {
    return AzOptionParentWithNodeDepth_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionParentWithNodeDepth::cmp(const OptionParentWithNodeDepth& b) const {
    return AzOptionParentWithNodeDepth_cmp(&inner_, b.ptr());
}

inline OptionVideoMode OptionVideoMode::none() {
    return OptionVideoMode(AzOptionVideoMode_none());
}

inline OptionVideoMode OptionVideoMode::some(VideoMode payload) {
    return OptionVideoMode(AzOptionVideoMode_some(payload.release()));
}

inline bool OptionVideoMode::partialEq(const OptionVideoMode& b) const {
    return AzOptionVideoMode_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionVideoMode::hash() const {
    return AzOptionVideoMode_hash(&inner_);
}

inline uint8_t OptionVideoMode::partialCmp(const OptionVideoMode& b) const {
    return AzOptionVideoMode_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionVideoMode::cmp(const OptionVideoMode& b) const {
    return AzOptionVideoMode_cmp(&inner_, b.ptr());
}

inline String OptionVideoMode::toDbgString() const {
    return String(AzOptionVideoMode_toDbgString(&inner_));
}

inline OptionOsVersion OptionOsVersion::none() {
    return OptionOsVersion(AzOptionOsVersion_none());
}

inline OptionOsVersion OptionOsVersion::some(OsVersion payload) {
    return OptionOsVersion(AzOptionOsVersion_some(payload.release()));
}

inline bool OptionOsVersion::partialEq(const OptionOsVersion& b) const {
    return AzOptionOsVersion_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionOsVersion::hash() const {
    return AzOptionOsVersion_hash(&inner_);
}

inline String OptionOsVersion::toDbgString() const {
    return String(AzOptionOsVersion_toDbgString(&inner_));
}

inline OptionTouchPoint OptionTouchPoint::none() {
    return OptionTouchPoint(AzOptionTouchPoint_none());
}

inline OptionTouchPoint OptionTouchPoint::some(TouchPoint payload) {
    return OptionTouchPoint(AzOptionTouchPoint_some(payload.release()));
}

inline bool OptionTouchPoint::partialEq(const OptionTouchPoint& b) const {
    return AzOptionTouchPoint_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionTouchPoint::partialCmp(const OptionTouchPoint& b) const {
    return AzOptionTouchPoint_partialCmp(&inner_, b.ptr());
}

inline String OptionTouchPoint::toDbgString() const {
    return String(AzOptionTouchPoint_toDbgString(&inner_));
}

inline OptionSensorReading OptionSensorReading::none() {
    return OptionSensorReading(AzOptionSensorReading_none());
}

inline OptionSensorReading OptionSensorReading::some(SensorReading payload) {
    return OptionSensorReading(AzOptionSensorReading_some(payload.release()));
}

inline bool OptionSensorReading::partialEq(const OptionSensorReading& b) const {
    return AzOptionSensorReading_partialEq(&inner_, b.ptr());
}

inline String OptionSensorReading::toDbgString() const {
    return String(AzOptionSensorReading_toDbgString(&inner_));
}

inline OptionGamepadState OptionGamepadState::none() {
    return OptionGamepadState(AzOptionGamepadState_none());
}

inline OptionGamepadState OptionGamepadState::some(GamepadState payload) {
    return OptionGamepadState(AzOptionGamepadState_some(payload.release()));
}

inline bool OptionGamepadState::partialEq(const OptionGamepadState& b) const {
    return AzOptionGamepadState_partialEq(&inner_, b.ptr());
}

inline String OptionGamepadState::toDbgString() const {
    return String(AzOptionGamepadState_toDbgString(&inner_));
}

inline OptionPixelValueNoPercent OptionPixelValueNoPercent::none() {
    return OptionPixelValueNoPercent(AzOptionPixelValueNoPercent_none());
}

inline OptionPixelValueNoPercent OptionPixelValueNoPercent::some(PixelValueNoPercent payload) {
    return OptionPixelValueNoPercent(AzOptionPixelValueNoPercent_some(payload.release()));
}

inline bool OptionPixelValueNoPercent::partialEq(const OptionPixelValueNoPercent& b) const {
    return AzOptionPixelValueNoPercent_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionPixelValueNoPercent::hash() const {
    return AzOptionPixelValueNoPercent_hash(&inner_);
}

inline uint8_t OptionPixelValueNoPercent::partialCmp(const OptionPixelValueNoPercent& b) const {
    return AzOptionPixelValueNoPercent_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionPixelValueNoPercent::cmp(const OptionPixelValueNoPercent& b) const {
    return AzOptionPixelValueNoPercent_cmp(&inner_, b.ptr());
}

inline String OptionPixelValueNoPercent::toDbgString() const {
    return String(AzOptionPixelValueNoPercent_toDbgString(&inner_));
}

inline OptionSelectionRange OptionSelectionRange::none() {
    return OptionSelectionRange(AzOptionSelectionRange_none());
}

inline OptionSelectionRange OptionSelectionRange::some(SelectionRange payload) {
    return OptionSelectionRange(AzOptionSelectionRange_some(payload.release()));
}

inline bool OptionSelectionRange::partialEq(const OptionSelectionRange& b) const {
    return AzOptionSelectionRange_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionSelectionRange::hash() const {
    return AzOptionSelectionRange_hash(&inner_);
}

inline uint8_t OptionSelectionRange::partialCmp(const OptionSelectionRange& b) const {
    return AzOptionSelectionRange_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionSelectionRange::cmp(const OptionSelectionRange& b) const {
    return AzOptionSelectionRange_cmp(&inner_, b.ptr());
}

inline String OptionSelectionRange::toDbgString() const {
    return String(AzOptionSelectionRange_toDbgString(&inner_));
}

inline OptionMouseState OptionMouseState::none() {
    return OptionMouseState(AzOptionMouseState_none());
}

inline OptionMouseState OptionMouseState::some(MouseState payload) {
    return OptionMouseState(AzOptionMouseState_some(payload.release()));
}

inline bool OptionMouseState::partialEq(const OptionMouseState& b) const {
    return AzOptionMouseState_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionMouseState::partialCmp(const OptionMouseState& b) const {
    return AzOptionMouseState_partialCmp(&inner_, b.ptr());
}

inline String OptionMouseState::toDbgString() const {
    return String(AzOptionMouseState_toDbgString(&inner_));
}

inline OptionThreadSendMsg OptionThreadSendMsg::none() {
    return OptionThreadSendMsg(AzOptionThreadSendMsg_none());
}

inline OptionThreadSendMsg OptionThreadSendMsg::some(AzThreadSendMsg payload) {
    return OptionThreadSendMsg(AzOptionThreadSendMsg_some(payload));
}

inline void OptionThreadSendMsg::delete_() {
    AzOptionThreadSendMsg_delete(&inner_);
}

inline OptionThreadSendMsg OptionThreadSendMsg::clone() const {
    return OptionThreadSendMsg(AzOptionThreadSendMsg_clone(&inner_));
}

inline bool OptionThreadSendMsg::partialEq(const OptionThreadSendMsg& b) const {
    return AzOptionThreadSendMsg_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionThreadSendMsg::hash() const {
    return AzOptionThreadSendMsg_hash(&inner_);
}

inline uint8_t OptionThreadSendMsg::partialCmp(const OptionThreadSendMsg& b) const {
    return AzOptionThreadSendMsg_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionThreadSendMsg::cmp(const OptionThreadSendMsg& b) const {
    return AzOptionThreadSendMsg_cmp(&inner_, b.ptr());
}

inline String OptionThreadSendMsg::toDbgString() const {
    return String(AzOptionThreadSendMsg_toDbgString(&inner_));
}

inline OptionTagIdToNodeIdMapping OptionTagIdToNodeIdMapping::none() {
    return OptionTagIdToNodeIdMapping(AzOptionTagIdToNodeIdMapping_none());
}

inline OptionTagIdToNodeIdMapping OptionTagIdToNodeIdMapping::some(TagIdToNodeIdMapping payload) {
    return OptionTagIdToNodeIdMapping(AzOptionTagIdToNodeIdMapping_some(payload.release()));
}

inline void OptionTagIdToNodeIdMapping::delete_() {
    AzOptionTagIdToNodeIdMapping_delete(&inner_);
}

inline OptionTagIdToNodeIdMapping OptionTagIdToNodeIdMapping::clone() const {
    return OptionTagIdToNodeIdMapping(AzOptionTagIdToNodeIdMapping_clone(&inner_));
}

inline bool OptionTagIdToNodeIdMapping::partialEq(const OptionTagIdToNodeIdMapping& b) const {
    return AzOptionTagIdToNodeIdMapping_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionTagIdToNodeIdMapping::partialCmp(const OptionTagIdToNodeIdMapping& b) const {
    return AzOptionTagIdToNodeIdMapping_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionTagIdToNodeIdMapping::cmp(const OptionTagIdToNodeIdMapping& b) const {
    return AzOptionTagIdToNodeIdMapping_cmp(&inner_, b.ptr());
}

inline String OptionTagIdToNodeIdMapping::toDbgString() const {
    return String(AzOptionTagIdToNodeIdMapping_toDbgString(&inner_));
}

inline OptionNormalizedRadialColorStop OptionNormalizedRadialColorStop::none() {
    return OptionNormalizedRadialColorStop(AzOptionNormalizedRadialColorStop_none());
}

inline OptionNormalizedRadialColorStop OptionNormalizedRadialColorStop::some(NormalizedRadialColorStop payload) {
    return OptionNormalizedRadialColorStop(AzOptionNormalizedRadialColorStop_some(payload.release()));
}

inline void OptionNormalizedRadialColorStop::delete_() {
    AzOptionNormalizedRadialColorStop_delete(&inner_);
}

inline OptionNormalizedRadialColorStop OptionNormalizedRadialColorStop::clone() const {
    return OptionNormalizedRadialColorStop(AzOptionNormalizedRadialColorStop_clone(&inner_));
}

inline bool OptionNormalizedRadialColorStop::partialEq(const OptionNormalizedRadialColorStop& b) const {
    return AzOptionNormalizedRadialColorStop_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionNormalizedRadialColorStop::hash() const {
    return AzOptionNormalizedRadialColorStop_hash(&inner_);
}

inline uint8_t OptionNormalizedRadialColorStop::partialCmp(const OptionNormalizedRadialColorStop& b) const {
    return AzOptionNormalizedRadialColorStop_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionNormalizedRadialColorStop::cmp(const OptionNormalizedRadialColorStop& b) const {
    return AzOptionNormalizedRadialColorStop_cmp(&inner_, b.ptr());
}

inline String OptionNormalizedRadialColorStop::toDbgString() const {
    return String(AzOptionNormalizedRadialColorStop_toDbgString(&inner_));
}

inline OptionNormalizedLinearColorStop OptionNormalizedLinearColorStop::none() {
    return OptionNormalizedLinearColorStop(AzOptionNormalizedLinearColorStop_none());
}

inline OptionNormalizedLinearColorStop OptionNormalizedLinearColorStop::some(NormalizedLinearColorStop payload) {
    return OptionNormalizedLinearColorStop(AzOptionNormalizedLinearColorStop_some(payload.release()));
}

inline void OptionNormalizedLinearColorStop::delete_() {
    AzOptionNormalizedLinearColorStop_delete(&inner_);
}

inline OptionNormalizedLinearColorStop OptionNormalizedLinearColorStop::clone() const {
    return OptionNormalizedLinearColorStop(AzOptionNormalizedLinearColorStop_clone(&inner_));
}

inline bool OptionNormalizedLinearColorStop::partialEq(const OptionNormalizedLinearColorStop& b) const {
    return AzOptionNormalizedLinearColorStop_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionNormalizedLinearColorStop::hash() const {
    return AzOptionNormalizedLinearColorStop_hash(&inner_);
}

inline uint8_t OptionNormalizedLinearColorStop::partialCmp(const OptionNormalizedLinearColorStop& b) const {
    return AzOptionNormalizedLinearColorStop_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionNormalizedLinearColorStop::cmp(const OptionNormalizedLinearColorStop& b) const {
    return AzOptionNormalizedLinearColorStop_cmp(&inner_, b.ptr());
}

inline String OptionNormalizedLinearColorStop::toDbgString() const {
    return String(AzOptionNormalizedLinearColorStop_toDbgString(&inner_));
}

inline OptionGridTrackSizing OptionGridTrackSizing::none() {
    return OptionGridTrackSizing(AzOptionGridTrackSizing_none());
}

inline OptionGridTrackSizing OptionGridTrackSizing::some(AzGridTrackSizing payload) {
    return OptionGridTrackSizing(AzOptionGridTrackSizing_some(payload));
}

inline void OptionGridTrackSizing::delete_() {
    AzOptionGridTrackSizing_delete(&inner_);
}

inline OptionGridTrackSizing OptionGridTrackSizing::clone() const {
    return OptionGridTrackSizing(AzOptionGridTrackSizing_clone(&inner_));
}

inline bool OptionGridTrackSizing::partialEq(const OptionGridTrackSizing& b) const {
    return AzOptionGridTrackSizing_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionGridTrackSizing::hash() const {
    return AzOptionGridTrackSizing_hash(&inner_);
}

inline uint8_t OptionGridTrackSizing::partialCmp(const OptionGridTrackSizing& b) const {
    return AzOptionGridTrackSizing_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionGridTrackSizing::cmp(const OptionGridTrackSizing& b) const {
    return AzOptionGridTrackSizing_cmp(&inner_, b.ptr());
}

inline OptionStringVec OptionStringVec::none() {
    return OptionStringVec(AzOptionStringVec_none());
}

inline OptionStringVec OptionStringVec::some(StringVec payload) {
    return OptionStringVec(AzOptionStringVec_some(payload.release()));
}

inline void OptionStringVec::delete_() {
    AzOptionStringVec_delete(&inner_);
}

inline OptionStringVec OptionStringVec::clone() const {
    return OptionStringVec(AzOptionStringVec_clone(&inner_));
}

inline bool OptionStringVec::partialEq(const OptionStringVec& b) const {
    return AzOptionStringVec_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionStringVec::hash() const {
    return AzOptionStringVec_hash(&inner_);
}

inline uint8_t OptionStringVec::partialCmp(const OptionStringVec& b) const {
    return AzOptionStringVec_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionStringVec::cmp(const OptionStringVec& b) const {
    return AzOptionStringVec_cmp(&inner_, b.ptr());
}

inline String OptionStringVec::toDbgString() const {
    return String(AzOptionStringVec_toDbgString(&inner_));
}

inline OptionJsonVec OptionJsonVec::none() {
    return OptionJsonVec(AzOptionJsonVec_none());
}

inline OptionJsonVec OptionJsonVec::some(JsonVec payload) {
    return OptionJsonVec(AzOptionJsonVec_some(payload.release()));
}

inline void OptionJsonVec::delete_() {
    AzOptionJsonVec_delete(&inner_);
}

inline OptionJsonVec OptionJsonVec::clone() const {
    return OptionJsonVec(AzOptionJsonVec_clone(&inner_));
}

inline String OptionJsonVec::toDbgString() const {
    return String(AzOptionJsonVec_toDbgString(&inner_));
}

inline OptionJsonKeyValueVec OptionJsonKeyValueVec::none() {
    return OptionJsonKeyValueVec(AzOptionJsonKeyValueVec_none());
}

inline OptionJsonKeyValueVec OptionJsonKeyValueVec::some(JsonKeyValueVec payload) {
    return OptionJsonKeyValueVec(AzOptionJsonKeyValueVec_some(payload.release()));
}

inline void OptionJsonKeyValueVec::delete_() {
    AzOptionJsonKeyValueVec_delete(&inner_);
}

inline OptionJsonKeyValueVec OptionJsonKeyValueVec::clone() const {
    return OptionJsonKeyValueVec(AzOptionJsonKeyValueVec_clone(&inner_));
}

inline String OptionJsonKeyValueVec::toDbgString() const {
    return String(AzOptionJsonKeyValueVec_toDbgString(&inner_));
}

inline OptionCalcAstItem OptionCalcAstItem::none() {
    return OptionCalcAstItem(AzOptionCalcAstItem_none());
}

inline OptionCalcAstItem OptionCalcAstItem::some(AzCalcAstItem payload) {
    return OptionCalcAstItem(AzOptionCalcAstItem_some(payload));
}

inline void OptionCalcAstItem::delete_() {
    AzOptionCalcAstItem_delete(&inner_);
}

inline OptionCalcAstItem OptionCalcAstItem::clone() const {
    return OptionCalcAstItem(AzOptionCalcAstItem_clone(&inner_));
}

inline bool OptionCalcAstItem::partialEq(const OptionCalcAstItem& b) const {
    return AzOptionCalcAstItem_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionCalcAstItem::hash() const {
    return AzOptionCalcAstItem_hash(&inner_);
}

inline uint8_t OptionCalcAstItem::partialCmp(const OptionCalcAstItem& b) const {
    return AzOptionCalcAstItem_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionCalcAstItem::cmp(const OptionCalcAstItem& b) const {
    return AzOptionCalcAstItem_cmp(&inner_, b.ptr());
}

inline String OptionCalcAstItem::toDbgString() const {
    return String(AzOptionCalcAstItem_toDbgString(&inner_));
}

inline OptionSvgPathElement OptionSvgPathElement::none() {
    return OptionSvgPathElement(AzOptionSvgPathElement_none());
}

inline OptionSvgPathElement OptionSvgPathElement::some(AzSvgPathElement payload) {
    return OptionSvgPathElement(AzOptionSvgPathElement_some(payload));
}

inline bool OptionSvgPathElement::partialEq(const OptionSvgPathElement& b) const {
    return AzOptionSvgPathElement_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionSvgPathElement::partialCmp(const OptionSvgPathElement& b) const {
    return AzOptionSvgPathElement_partialCmp(&inner_, b.ptr());
}

inline String OptionSvgPathElement::toDbgString() const {
    return String(AzOptionSvgPathElement_toDbgString(&inner_));
}

inline OptionU8Vec OptionU8Vec::none() {
    return OptionU8Vec(AzOptionU8Vec_none());
}

inline OptionU8Vec OptionU8Vec::some(U8Vec payload) {
    return OptionU8Vec(AzOptionU8Vec_some(payload.release()));
}

inline void OptionU8Vec::delete_() {
    AzOptionU8Vec_delete(&inner_);
}

inline OptionU8Vec OptionU8Vec::clone() const {
    return OptionU8Vec(AzOptionU8Vec_clone(&inner_));
}

inline bool OptionU8Vec::partialEq(const OptionU8Vec& b) const {
    return AzOptionU8Vec_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionU8Vec::hash() const {
    return AzOptionU8Vec_hash(&inner_);
}

inline uint8_t OptionU8Vec::partialCmp(const OptionU8Vec& b) const {
    return AzOptionU8Vec_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionU8Vec::cmp(const OptionU8Vec& b) const {
    return AzOptionU8Vec_cmp(&inner_, b.ptr());
}

inline String OptionU8Vec::toDbgString() const {
    return String(AzOptionU8Vec_toDbgString(&inner_));
}

inline ResultU8VecEncodeImageError ResultU8VecEncodeImageError::ok(U8Vec payload) {
    return ResultU8VecEncodeImageError(AzResultU8VecEncodeImageError_ok(payload.release()));
}

inline ResultU8VecEncodeImageError ResultU8VecEncodeImageError::err(AzEncodeImageError payload) {
    return ResultU8VecEncodeImageError(AzResultU8VecEncodeImageError_err(payload));
}

inline void ResultU8VecEncodeImageError::delete_() {
    AzResultU8VecEncodeImageError_delete(&inner_);
}

inline ResultU8VecEncodeImageError ResultU8VecEncodeImageError::clone() const {
    return ResultU8VecEncodeImageError(AzResultU8VecEncodeImageError_clone(&inner_));
}

inline String ResultU8VecEncodeImageError::toDbgString() const {
    return String(AzResultU8VecEncodeImageError_toDbgString(&inner_));
}

inline OptionMenu OptionMenu::none() {
    return OptionMenu(AzOptionMenu_none());
}

inline OptionMenu OptionMenu::some(Menu payload) {
    return OptionMenu(AzOptionMenu_some(payload.release()));
}

inline void OptionMenu::delete_() {
    AzOptionMenu_delete(&inner_);
}

inline OptionMenu OptionMenu::clone() const {
    return OptionMenu(AzOptionMenu_clone(&inner_));
}

inline bool OptionMenu::partialEq(const OptionMenu& b) const {
    return AzOptionMenu_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionMenu::hash() const {
    return AzOptionMenu_hash(&inner_);
}

inline uint8_t OptionMenu::partialCmp(const OptionMenu& b) const {
    return AzOptionMenu_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionMenu::cmp(const OptionMenu& b) const {
    return AzOptionMenu_cmp(&inner_, b.ptr());
}

inline String OptionMenu::toDbgString() const {
    return String(AzOptionMenu_toDbgString(&inner_));
}

inline OptionVirtualKeyCodeCombo OptionVirtualKeyCodeCombo::none() {
    return OptionVirtualKeyCodeCombo(AzOptionVirtualKeyCodeCombo_none());
}

inline OptionVirtualKeyCodeCombo OptionVirtualKeyCodeCombo::some(VirtualKeyCodeCombo payload) {
    return OptionVirtualKeyCodeCombo(AzOptionVirtualKeyCodeCombo_some(payload.release()));
}

inline void OptionVirtualKeyCodeCombo::delete_() {
    AzOptionVirtualKeyCodeCombo_delete(&inner_);
}

inline OptionVirtualKeyCodeCombo OptionVirtualKeyCodeCombo::clone() const {
    return OptionVirtualKeyCodeCombo(AzOptionVirtualKeyCodeCombo_clone(&inner_));
}

inline bool OptionVirtualKeyCodeCombo::partialEq(const OptionVirtualKeyCodeCombo& b) const {
    return AzOptionVirtualKeyCodeCombo_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionVirtualKeyCodeCombo::hash() const {
    return AzOptionVirtualKeyCodeCombo_hash(&inner_);
}

inline uint8_t OptionVirtualKeyCodeCombo::partialCmp(const OptionVirtualKeyCodeCombo& b) const {
    return AzOptionVirtualKeyCodeCombo_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionVirtualKeyCodeCombo::cmp(const OptionVirtualKeyCodeCombo& b) const {
    return AzOptionVirtualKeyCodeCombo_cmp(&inner_, b.ptr());
}

inline String OptionVirtualKeyCodeCombo::toDbgString() const {
    return String(AzOptionVirtualKeyCodeCombo_toDbgString(&inner_));
}

inline OptionString OptionString::none() {
    return OptionString(AzOptionString_none());
}

inline OptionString OptionString::some(String payload) {
    return OptionString(AzOptionString_some(payload.release()));
}

inline void OptionString::delete_() {
    AzOptionString_delete(&inner_);
}

inline OptionString OptionString::clone() const {
    return OptionString(AzOptionString_clone(&inner_));
}

inline bool OptionString::partialEq(const OptionString& b) const {
    return AzOptionString_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionString::hash() const {
    return AzOptionString_hash(&inner_);
}

inline uint8_t OptionString::partialCmp(const OptionString& b) const {
    return AzOptionString_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionString::cmp(const OptionString& b) const {
    return AzOptionString_cmp(&inner_, b.ptr());
}

inline String OptionString::toDbgString() const {
    return String(AzOptionString_toDbgString(&inner_));
}

inline OptionCallback OptionCallback::none() {
    return OptionCallback(AzOptionCallback_none());
}

inline OptionCallback OptionCallback::some(Callback payload) {
    return OptionCallback(AzOptionCallback_some(payload.release()));
}

inline void OptionCallback::delete_() {
    AzOptionCallback_delete(&inner_);
}

inline OptionCallback OptionCallback::clone() const {
    return OptionCallback(AzOptionCallback_clone(&inner_));
}

inline bool OptionCallback::partialEq(const OptionCallback& b) const {
    return AzOptionCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionCallback::hash() const {
    return AzOptionCallback_hash(&inner_);
}

inline uint8_t OptionCallback::partialCmp(const OptionCallback& b) const {
    return AzOptionCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionCallback::cmp(const OptionCallback& b) const {
    return AzOptionCallback_cmp(&inner_, b.ptr());
}

inline String OptionCallback::toDbgString() const {
    return String(AzOptionCallback_toDbgString(&inner_));
}

inline OptionTaskBarIcon OptionTaskBarIcon::none() {
    return OptionTaskBarIcon(AzOptionTaskBarIcon_none());
}

inline OptionTaskBarIcon OptionTaskBarIcon::some(TaskBarIcon payload) {
    return OptionTaskBarIcon(AzOptionTaskBarIcon_some(payload.release()));
}

inline void OptionTaskBarIcon::delete_() {
    AzOptionTaskBarIcon_delete(&inner_);
}

inline OptionTaskBarIcon OptionTaskBarIcon::clone() const {
    return OptionTaskBarIcon(AzOptionTaskBarIcon_clone(&inner_));
}

inline bool OptionTaskBarIcon::partialEq(const OptionTaskBarIcon& b) const {
    return AzOptionTaskBarIcon_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionTaskBarIcon::hash() const {
    return AzOptionTaskBarIcon_hash(&inner_);
}

inline uint8_t OptionTaskBarIcon::partialCmp(const OptionTaskBarIcon& b) const {
    return AzOptionTaskBarIcon_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionTaskBarIcon::cmp(const OptionTaskBarIcon& b) const {
    return AzOptionTaskBarIcon_cmp(&inner_, b.ptr());
}

inline String OptionTaskBarIcon::toDbgString() const {
    return String(AzOptionTaskBarIcon_toDbgString(&inner_));
}

inline OptionInstant OptionInstant::none() {
    return OptionInstant(AzOptionInstant_none());
}

inline OptionInstant OptionInstant::some(AzInstant payload) {
    return OptionInstant(AzOptionInstant_some(payload));
}

inline void OptionInstant::delete_() {
    AzOptionInstant_delete(&inner_);
}

inline OptionInstant OptionInstant::clone() const {
    return OptionInstant(AzOptionInstant_clone(&inner_));
}

inline bool OptionInstant::partialEq(const OptionInstant& b) const {
    return AzOptionInstant_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionInstant::hash() const {
    return AzOptionInstant_hash(&inner_);
}

inline uint8_t OptionInstant::partialCmp(const OptionInstant& b) const {
    return AzOptionInstant_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionInstant::cmp(const OptionInstant& b) const {
    return AzOptionInstant_cmp(&inner_, b.ptr());
}

inline String OptionInstant::toDbgString() const {
    return String(AzOptionInstant_toDbgString(&inner_));
}

inline OptionKeyboardState OptionKeyboardState::none() {
    return OptionKeyboardState(AzOptionKeyboardState_none());
}

inline OptionKeyboardState OptionKeyboardState::some(KeyboardState payload) {
    return OptionKeyboardState(AzOptionKeyboardState_some(payload.release()));
}

inline void OptionKeyboardState::delete_() {
    AzOptionKeyboardState_delete(&inner_);
}

inline OptionKeyboardState OptionKeyboardState::clone() const {
    return OptionKeyboardState(AzOptionKeyboardState_clone(&inner_));
}

inline bool OptionKeyboardState::partialEq(const OptionKeyboardState& b) const {
    return AzOptionKeyboardState_partialEq(&inner_, b.ptr());
}

inline String OptionKeyboardState::toDbgString() const {
    return String(AzOptionKeyboardState_toDbgString(&inner_));
}

inline OptionSelectionState OptionSelectionState::none() {
    return OptionSelectionState(AzOptionSelectionState_none());
}

inline OptionSelectionState OptionSelectionState::some(SelectionState payload) {
    return OptionSelectionState(AzOptionSelectionState_some(payload.release()));
}

inline void OptionSelectionState::delete_() {
    AzOptionSelectionState_delete(&inner_);
}

inline OptionSelectionState OptionSelectionState::clone() const {
    return OptionSelectionState(AzOptionSelectionState_clone(&inner_));
}

inline bool OptionSelectionState::partialEq(const OptionSelectionState& b) const {
    return AzOptionSelectionState_partialEq(&inner_, b.ptr());
}

inline String OptionSelectionState::toDbgString() const {
    return String(AzOptionSelectionState_toDbgString(&inner_));
}

inline OptionDatasetMergeCallback OptionDatasetMergeCallback::none() {
    return OptionDatasetMergeCallback(AzOptionDatasetMergeCallback_none());
}

inline OptionDatasetMergeCallback OptionDatasetMergeCallback::some(DatasetMergeCallback payload) {
    return OptionDatasetMergeCallback(AzOptionDatasetMergeCallback_some(payload.release()));
}

inline void OptionDatasetMergeCallback::delete_() {
    AzOptionDatasetMergeCallback_delete(&inner_);
}

inline OptionDatasetMergeCallback OptionDatasetMergeCallback::clone() const {
    return OptionDatasetMergeCallback(AzOptionDatasetMergeCallback_clone(&inner_));
}

inline String OptionDatasetMergeCallback::toDbgString() const {
    return String(AzOptionDatasetMergeCallback_toDbgString(&inner_));
}

inline OptionStyleTransform OptionStyleTransform::none() {
    return OptionStyleTransform(AzOptionStyleTransform_none());
}

inline OptionStyleTransform OptionStyleTransform::some(AzStyleTransform payload) {
    return OptionStyleTransform(AzOptionStyleTransform_some(payload));
}

inline bool OptionStyleTransform::partialEq(const OptionStyleTransform& b) const {
    return AzOptionStyleTransform_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionStyleTransform::partialCmp(const OptionStyleTransform& b) const {
    return AzOptionStyleTransform_partialCmp(&inner_, b.ptr());
}

inline String OptionStyleTransform::toDbgString() const {
    return String(AzOptionStyleTransform_toDbgString(&inner_));
}

inline OptionStyleBackgroundPosition OptionStyleBackgroundPosition::none() {
    return OptionStyleBackgroundPosition(AzOptionStyleBackgroundPosition_none());
}

inline OptionStyleBackgroundPosition OptionStyleBackgroundPosition::some(StyleBackgroundPosition payload) {
    return OptionStyleBackgroundPosition(AzOptionStyleBackgroundPosition_some(payload.release()));
}

inline bool OptionStyleBackgroundPosition::partialEq(const OptionStyleBackgroundPosition& b) const {
    return AzOptionStyleBackgroundPosition_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionStyleBackgroundPosition::hash() const {
    return AzOptionStyleBackgroundPosition_hash(&inner_);
}

inline uint8_t OptionStyleBackgroundPosition::partialCmp(const OptionStyleBackgroundPosition& b) const {
    return AzOptionStyleBackgroundPosition_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionStyleBackgroundPosition::cmp(const OptionStyleBackgroundPosition& b) const {
    return AzOptionStyleBackgroundPosition_cmp(&inner_, b.ptr());
}

inline String OptionStyleBackgroundPosition::toDbgString() const {
    return String(AzOptionStyleBackgroundPosition_toDbgString(&inner_));
}

inline OptionCss OptionCss::none() {
    return OptionCss(AzOptionCss_none());
}

inline OptionCss OptionCss::some(Css payload) {
    return OptionCss(AzOptionCss_some(payload.release()));
}

inline void OptionCss::delete_() {
    AzOptionCss_delete(&inner_);
}

inline OptionCss OptionCss::clone() const {
    return OptionCss(AzOptionCss_clone(&inner_));
}

inline bool OptionCss::partialEq(const OptionCss& b) const {
    return AzOptionCss_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionCss::partialCmp(const OptionCss& b) const {
    return AzOptionCss_partialCmp(&inner_, b.ptr());
}

inline String OptionCss::toDbgString() const {
    return String(AzOptionCss_toDbgString(&inner_));
}

inline OptionStyleBackgroundSize OptionStyleBackgroundSize::none() {
    return OptionStyleBackgroundSize(AzOptionStyleBackgroundSize_none());
}

inline OptionStyleBackgroundSize OptionStyleBackgroundSize::some(AzStyleBackgroundSize payload) {
    return OptionStyleBackgroundSize(AzOptionStyleBackgroundSize_some(payload));
}

inline void OptionStyleBackgroundSize::delete_() {
    AzOptionStyleBackgroundSize_delete(&inner_);
}

inline OptionStyleBackgroundSize OptionStyleBackgroundSize::clone() const {
    return OptionStyleBackgroundSize(AzOptionStyleBackgroundSize_clone(&inner_));
}

inline bool OptionStyleBackgroundSize::partialEq(const OptionStyleBackgroundSize& b) const {
    return AzOptionStyleBackgroundSize_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionStyleBackgroundSize::hash() const {
    return AzOptionStyleBackgroundSize_hash(&inner_);
}

inline uint8_t OptionStyleBackgroundSize::partialCmp(const OptionStyleBackgroundSize& b) const {
    return AzOptionStyleBackgroundSize_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionStyleBackgroundSize::cmp(const OptionStyleBackgroundSize& b) const {
    return AzOptionStyleBackgroundSize_cmp(&inner_, b.ptr());
}

inline String OptionStyleBackgroundSize::toDbgString() const {
    return String(AzOptionStyleBackgroundSize_toDbgString(&inner_));
}

inline OptionSelection OptionSelection::none() {
    return OptionSelection(AzOptionSelection_none());
}

inline OptionSelection OptionSelection::some(AzSelection payload) {
    return OptionSelection(AzOptionSelection_some(payload));
}

inline bool OptionSelection::partialEq(const OptionSelection& b) const {
    return AzOptionSelection_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionSelection::hash() const {
    return AzOptionSelection_hash(&inner_);
}

inline uint8_t OptionSelection::partialCmp(const OptionSelection& b) const {
    return AzOptionSelection_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionSelection::cmp(const OptionSelection& b) const {
    return AzOptionSelection_cmp(&inner_, b.ptr());
}

inline String OptionSelection::toDbgString() const {
    return String(AzOptionSelection_toDbgString(&inner_));
}

inline OptionContentGroup OptionContentGroup::none() {
    return OptionContentGroup(AzOptionContentGroup_none());
}

inline OptionContentGroup OptionContentGroup::some(ContentGroup payload) {
    return OptionContentGroup(AzOptionContentGroup_some(payload.release()));
}

inline void OptionContentGroup::delete_() {
    AzOptionContentGroup_delete(&inner_);
}

inline OptionContentGroup OptionContentGroup::clone() const {
    return OptionContentGroup(AzOptionContentGroup_clone(&inner_));
}

inline bool OptionContentGroup::partialEq(const OptionContentGroup& b) const {
    return AzOptionContentGroup_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionContentGroup::partialCmp(const OptionContentGroup& b) const {
    return AzOptionContentGroup_partialCmp(&inner_, b.ptr());
}

inline String OptionContentGroup::toDbgString() const {
    return String(AzOptionContentGroup_toDbgString(&inner_));
}

inline OptionSvgPath OptionSvgPath::none() {
    return OptionSvgPath(AzOptionSvgPath_none());
}

inline OptionSvgPath OptionSvgPath::some(SvgPath payload) {
    return OptionSvgPath(AzOptionSvgPath_some(payload.release()));
}

inline void OptionSvgPath::delete_() {
    AzOptionSvgPath_delete(&inner_);
}

inline OptionSvgPath OptionSvgPath::clone() const {
    return OptionSvgPath(AzOptionSvgPath_clone(&inner_));
}

inline bool OptionSvgPath::partialEq(const OptionSvgPath& b) const {
    return AzOptionSvgPath_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionSvgPath::partialCmp(const OptionSvgPath& b) const {
    return AzOptionSvgPath_partialCmp(&inner_, b.ptr());
}

inline String OptionSvgPath::toDbgString() const {
    return String(AzOptionSvgPath_toDbgString(&inner_));
}

inline OptionVideoFrame OptionVideoFrame::none() {
    return OptionVideoFrame(AzOptionVideoFrame_none());
}

inline OptionVideoFrame OptionVideoFrame::some(VideoFrame payload) {
    return OptionVideoFrame(AzOptionVideoFrame_some(payload.release()));
}

inline void OptionVideoFrame::delete_() {
    AzOptionVideoFrame_delete(&inner_);
}

inline OptionVideoFrame OptionVideoFrame::clone() const {
    return OptionVideoFrame(AzOptionVideoFrame_clone(&inner_));
}

inline String OptionVideoFrame::toDbgString() const {
    return String(AzOptionVideoFrame_toDbgString(&inner_));
}

inline ResultRefAnyString ResultRefAnyString::ok(RefAny payload) {
    return ResultRefAnyString(AzResultRefAnyString_ok(payload.release()));
}

inline ResultRefAnyString ResultRefAnyString::err(String payload) {
    return ResultRefAnyString(AzResultRefAnyString_err(payload.release()));
}

inline void ResultRefAnyString::delete_() {
    AzResultRefAnyString_delete(&inner_);
}

inline ResultRefAnyString ResultRefAnyString::clone() const {
    return ResultRefAnyString(AzResultRefAnyString_clone(&inner_));
}

inline String ResultRefAnyString::toDbgString() const {
    return String(AzResultRefAnyString_toDbgString(&inner_));
}

inline ResultU8VecString ResultU8VecString::ok(U8Vec payload) {
    return ResultU8VecString(AzResultU8VecString_ok(payload.release()));
}

inline ResultU8VecString ResultU8VecString::err(String payload) {
    return ResultU8VecString(AzResultU8VecString_err(payload.release()));
}

inline void ResultU8VecString::delete_() {
    AzResultU8VecString_delete(&inner_);
}

inline ResultU8VecString ResultU8VecString::clone() const {
    return ResultU8VecString(AzResultU8VecString_clone(&inner_));
}

inline String ResultU8VecString::toDbgString() const {
    return String(AzResultU8VecString_toDbgString(&inner_));
}

inline ResultVoidString ResultVoidString::ok() {
    return ResultVoidString(AzResultVoidString_ok());
}

inline ResultVoidString ResultVoidString::err(String payload) {
    return ResultVoidString(AzResultVoidString_err(payload.release()));
}

inline void ResultVoidString::delete_() {
    AzResultVoidString_delete(&inner_);
}

inline ResultVoidString ResultVoidString::clone() const {
    return ResultVoidString(AzResultVoidString_clone(&inner_));
}

inline String ResultVoidString::toDbgString() const {
    return String(AzResultVoidString_toDbgString(&inner_));
}

inline ResultStringString ResultStringString::ok(String payload) {
    return ResultStringString(AzResultStringString_ok(payload.release()));
}

inline ResultStringString ResultStringString::err(String payload) {
    return ResultStringString(AzResultStringString_err(payload.release()));
}

inline void ResultStringString::delete_() {
    AzResultStringString_delete(&inner_);
}

inline ResultStringString ResultStringString::clone() const {
    return ResultStringString(AzResultStringString_clone(&inner_));
}

inline String ResultStringString::toDbgString() const {
    return String(AzResultStringString_toDbgString(&inner_));
}

inline OptionListViewOnRowClick OptionListViewOnRowClick::none() {
    return OptionListViewOnRowClick(AzOptionListViewOnRowClick_none());
}

inline OptionListViewOnRowClick OptionListViewOnRowClick::some(ListViewOnRowClick payload) {
    return OptionListViewOnRowClick(AzOptionListViewOnRowClick_some(payload.release()));
}

inline void OptionListViewOnRowClick::delete_() {
    AzOptionListViewOnRowClick_delete(&inner_);
}

inline OptionListViewOnRowClick OptionListViewOnRowClick::clone() const {
    return OptionListViewOnRowClick(AzOptionListViewOnRowClick_clone(&inner_));
}

inline bool OptionListViewOnRowClick::partialEq(const OptionListViewOnRowClick& b) const {
    return AzOptionListViewOnRowClick_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionListViewOnRowClick::hash() const {
    return AzOptionListViewOnRowClick_hash(&inner_);
}

inline uint8_t OptionListViewOnRowClick::partialCmp(const OptionListViewOnRowClick& b) const {
    return AzOptionListViewOnRowClick_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionListViewOnRowClick::cmp(const OptionListViewOnRowClick& b) const {
    return AzOptionListViewOnRowClick_cmp(&inner_, b.ptr());
}

inline String OptionListViewOnRowClick::toDbgString() const {
    return String(AzOptionListViewOnRowClick_toDbgString(&inner_));
}

inline OptionListViewOnColumnClick OptionListViewOnColumnClick::none() {
    return OptionListViewOnColumnClick(AzOptionListViewOnColumnClick_none());
}

inline OptionListViewOnColumnClick OptionListViewOnColumnClick::some(ListViewOnColumnClick payload) {
    return OptionListViewOnColumnClick(AzOptionListViewOnColumnClick_some(payload.release()));
}

inline void OptionListViewOnColumnClick::delete_() {
    AzOptionListViewOnColumnClick_delete(&inner_);
}

inline OptionListViewOnColumnClick OptionListViewOnColumnClick::clone() const {
    return OptionListViewOnColumnClick(AzOptionListViewOnColumnClick_clone(&inner_));
}

inline bool OptionListViewOnColumnClick::partialEq(const OptionListViewOnColumnClick& b) const {
    return AzOptionListViewOnColumnClick_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionListViewOnColumnClick::hash() const {
    return AzOptionListViewOnColumnClick_hash(&inner_);
}

inline uint8_t OptionListViewOnColumnClick::partialCmp(const OptionListViewOnColumnClick& b) const {
    return AzOptionListViewOnColumnClick_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionListViewOnColumnClick::cmp(const OptionListViewOnColumnClick& b) const {
    return AzOptionListViewOnColumnClick_cmp(&inner_, b.ptr());
}

inline String OptionListViewOnColumnClick::toDbgString() const {
    return String(AzOptionListViewOnColumnClick_toDbgString(&inner_));
}

inline OptionListViewOnLazyLoadScroll OptionListViewOnLazyLoadScroll::none() {
    return OptionListViewOnLazyLoadScroll(AzOptionListViewOnLazyLoadScroll_none());
}

inline OptionListViewOnLazyLoadScroll OptionListViewOnLazyLoadScroll::some(ListViewOnLazyLoadScroll payload) {
    return OptionListViewOnLazyLoadScroll(AzOptionListViewOnLazyLoadScroll_some(payload.release()));
}

inline void OptionListViewOnLazyLoadScroll::delete_() {
    AzOptionListViewOnLazyLoadScroll_delete(&inner_);
}

inline OptionListViewOnLazyLoadScroll OptionListViewOnLazyLoadScroll::clone() const {
    return OptionListViewOnLazyLoadScroll(AzOptionListViewOnLazyLoadScroll_clone(&inner_));
}

inline bool OptionListViewOnLazyLoadScroll::partialEq(const OptionListViewOnLazyLoadScroll& b) const {
    return AzOptionListViewOnLazyLoadScroll_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionListViewOnLazyLoadScroll::hash() const {
    return AzOptionListViewOnLazyLoadScroll_hash(&inner_);
}

inline uint8_t OptionListViewOnLazyLoadScroll::partialCmp(const OptionListViewOnLazyLoadScroll& b) const {
    return AzOptionListViewOnLazyLoadScroll_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionListViewOnLazyLoadScroll::cmp(const OptionListViewOnLazyLoadScroll& b) const {
    return AzOptionListViewOnLazyLoadScroll_cmp(&inner_, b.ptr());
}

inline String OptionListViewOnLazyLoadScroll::toDbgString() const {
    return String(AzOptionListViewOnLazyLoadScroll_toDbgString(&inner_));
}

inline OptionColorInputOnValueChange OptionColorInputOnValueChange::none() {
    return OptionColorInputOnValueChange(AzOptionColorInputOnValueChange_none());
}

inline OptionColorInputOnValueChange OptionColorInputOnValueChange::some(ColorInputOnValueChange payload) {
    return OptionColorInputOnValueChange(AzOptionColorInputOnValueChange_some(payload.release()));
}

inline void OptionColorInputOnValueChange::delete_() {
    AzOptionColorInputOnValueChange_delete(&inner_);
}

inline OptionColorInputOnValueChange OptionColorInputOnValueChange::clone() const {
    return OptionColorInputOnValueChange(AzOptionColorInputOnValueChange_clone(&inner_));
}

inline bool OptionColorInputOnValueChange::partialEq(const OptionColorInputOnValueChange& b) const {
    return AzOptionColorInputOnValueChange_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionColorInputOnValueChange::hash() const {
    return AzOptionColorInputOnValueChange_hash(&inner_);
}

inline uint8_t OptionColorInputOnValueChange::partialCmp(const OptionColorInputOnValueChange& b) const {
    return AzOptionColorInputOnValueChange_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionColorInputOnValueChange::cmp(const OptionColorInputOnValueChange& b) const {
    return AzOptionColorInputOnValueChange_cmp(&inner_, b.ptr());
}

inline String OptionColorInputOnValueChange::toDbgString() const {
    return String(AzOptionColorInputOnValueChange_toDbgString(&inner_));
}

inline OptionButtonOnClick OptionButtonOnClick::none() {
    return OptionButtonOnClick(AzOptionButtonOnClick_none());
}

inline OptionButtonOnClick OptionButtonOnClick::some(ButtonOnClick payload) {
    return OptionButtonOnClick(AzOptionButtonOnClick_some(payload.release()));
}

inline void OptionButtonOnClick::delete_() {
    AzOptionButtonOnClick_delete(&inner_);
}

inline OptionButtonOnClick OptionButtonOnClick::clone() const {
    return OptionButtonOnClick(AzOptionButtonOnClick_clone(&inner_));
}

inline bool OptionButtonOnClick::partialEq(const OptionButtonOnClick& b) const {
    return AzOptionButtonOnClick_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionButtonOnClick::hash() const {
    return AzOptionButtonOnClick_hash(&inner_);
}

inline uint8_t OptionButtonOnClick::partialCmp(const OptionButtonOnClick& b) const {
    return AzOptionButtonOnClick_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionButtonOnClick::cmp(const OptionButtonOnClick& b) const {
    return AzOptionButtonOnClick_cmp(&inner_, b.ptr());
}

inline String OptionButtonOnClick::toDbgString() const {
    return String(AzOptionButtonOnClick_toDbgString(&inner_));
}

inline OptionTabOnClick OptionTabOnClick::none() {
    return OptionTabOnClick(AzOptionTabOnClick_none());
}

inline OptionTabOnClick OptionTabOnClick::some(TabOnClick payload) {
    return OptionTabOnClick(AzOptionTabOnClick_some(payload.release()));
}

inline void OptionTabOnClick::delete_() {
    AzOptionTabOnClick_delete(&inner_);
}

inline OptionTabOnClick OptionTabOnClick::clone() const {
    return OptionTabOnClick(AzOptionTabOnClick_clone(&inner_));
}

inline bool OptionTabOnClick::partialEq(const OptionTabOnClick& b) const {
    return AzOptionTabOnClick_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionTabOnClick::hash() const {
    return AzOptionTabOnClick_hash(&inner_);
}

inline uint8_t OptionTabOnClick::partialCmp(const OptionTabOnClick& b) const {
    return AzOptionTabOnClick_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionTabOnClick::cmp(const OptionTabOnClick& b) const {
    return AzOptionTabOnClick_cmp(&inner_, b.ptr());
}

inline String OptionTabOnClick::toDbgString() const {
    return String(AzOptionTabOnClick_toDbgString(&inner_));
}

inline OptionFileInputOnPathChange OptionFileInputOnPathChange::none() {
    return OptionFileInputOnPathChange(AzOptionFileInputOnPathChange_none());
}

inline OptionFileInputOnPathChange OptionFileInputOnPathChange::some(FileInputOnPathChange payload) {
    return OptionFileInputOnPathChange(AzOptionFileInputOnPathChange_some(payload.release()));
}

inline void OptionFileInputOnPathChange::delete_() {
    AzOptionFileInputOnPathChange_delete(&inner_);
}

inline OptionFileInputOnPathChange OptionFileInputOnPathChange::clone() const {
    return OptionFileInputOnPathChange(AzOptionFileInputOnPathChange_clone(&inner_));
}

inline bool OptionFileInputOnPathChange::partialEq(const OptionFileInputOnPathChange& b) const {
    return AzOptionFileInputOnPathChange_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionFileInputOnPathChange::hash() const {
    return AzOptionFileInputOnPathChange_hash(&inner_);
}

inline uint8_t OptionFileInputOnPathChange::partialCmp(const OptionFileInputOnPathChange& b) const {
    return AzOptionFileInputOnPathChange_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionFileInputOnPathChange::cmp(const OptionFileInputOnPathChange& b) const {
    return AzOptionFileInputOnPathChange_cmp(&inner_, b.ptr());
}

inline String OptionFileInputOnPathChange::toDbgString() const {
    return String(AzOptionFileInputOnPathChange_toDbgString(&inner_));
}

inline OptionCheckBoxOnToggle OptionCheckBoxOnToggle::none() {
    return OptionCheckBoxOnToggle(AzOptionCheckBoxOnToggle_none());
}

inline OptionCheckBoxOnToggle OptionCheckBoxOnToggle::some(CheckBoxOnToggle payload) {
    return OptionCheckBoxOnToggle(AzOptionCheckBoxOnToggle_some(payload.release()));
}

inline void OptionCheckBoxOnToggle::delete_() {
    AzOptionCheckBoxOnToggle_delete(&inner_);
}

inline OptionCheckBoxOnToggle OptionCheckBoxOnToggle::clone() const {
    return OptionCheckBoxOnToggle(AzOptionCheckBoxOnToggle_clone(&inner_));
}

inline bool OptionCheckBoxOnToggle::partialEq(const OptionCheckBoxOnToggle& b) const {
    return AzOptionCheckBoxOnToggle_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionCheckBoxOnToggle::hash() const {
    return AzOptionCheckBoxOnToggle_hash(&inner_);
}

inline uint8_t OptionCheckBoxOnToggle::partialCmp(const OptionCheckBoxOnToggle& b) const {
    return AzOptionCheckBoxOnToggle_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionCheckBoxOnToggle::cmp(const OptionCheckBoxOnToggle& b) const {
    return AzOptionCheckBoxOnToggle_cmp(&inner_, b.ptr());
}

inline String OptionCheckBoxOnToggle::toDbgString() const {
    return String(AzOptionCheckBoxOnToggle_toDbgString(&inner_));
}

inline OptionDropDownOnChoiceChange OptionDropDownOnChoiceChange::none() {
    return OptionDropDownOnChoiceChange(AzOptionDropDownOnChoiceChange_none());
}

inline OptionDropDownOnChoiceChange OptionDropDownOnChoiceChange::some(DropDownOnChoiceChange payload) {
    return OptionDropDownOnChoiceChange(AzOptionDropDownOnChoiceChange_some(payload.release()));
}

inline void OptionDropDownOnChoiceChange::delete_() {
    AzOptionDropDownOnChoiceChange_delete(&inner_);
}

inline OptionDropDownOnChoiceChange OptionDropDownOnChoiceChange::clone() const {
    return OptionDropDownOnChoiceChange(AzOptionDropDownOnChoiceChange_clone(&inner_));
}

inline bool OptionDropDownOnChoiceChange::partialEq(const OptionDropDownOnChoiceChange& b) const {
    return AzOptionDropDownOnChoiceChange_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionDropDownOnChoiceChange::hash() const {
    return AzOptionDropDownOnChoiceChange_hash(&inner_);
}

inline uint8_t OptionDropDownOnChoiceChange::partialCmp(const OptionDropDownOnChoiceChange& b) const {
    return AzOptionDropDownOnChoiceChange_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionDropDownOnChoiceChange::cmp(const OptionDropDownOnChoiceChange& b) const {
    return AzOptionDropDownOnChoiceChange_cmp(&inner_, b.ptr());
}

inline String OptionDropDownOnChoiceChange::toDbgString() const {
    return String(AzOptionDropDownOnChoiceChange_toDbgString(&inner_));
}

inline OptionTextInputOnTextInput OptionTextInputOnTextInput::none() {
    return OptionTextInputOnTextInput(AzOptionTextInputOnTextInput_none());
}

inline OptionTextInputOnTextInput OptionTextInputOnTextInput::some(TextInputOnTextInput payload) {
    return OptionTextInputOnTextInput(AzOptionTextInputOnTextInput_some(payload.release()));
}

inline void OptionTextInputOnTextInput::delete_() {
    AzOptionTextInputOnTextInput_delete(&inner_);
}

inline OptionTextInputOnTextInput OptionTextInputOnTextInput::clone() const {
    return OptionTextInputOnTextInput(AzOptionTextInputOnTextInput_clone(&inner_));
}

inline bool OptionTextInputOnTextInput::partialEq(const OptionTextInputOnTextInput& b) const {
    return AzOptionTextInputOnTextInput_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionTextInputOnTextInput::hash() const {
    return AzOptionTextInputOnTextInput_hash(&inner_);
}

inline uint8_t OptionTextInputOnTextInput::partialCmp(const OptionTextInputOnTextInput& b) const {
    return AzOptionTextInputOnTextInput_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionTextInputOnTextInput::cmp(const OptionTextInputOnTextInput& b) const {
    return AzOptionTextInputOnTextInput_cmp(&inner_, b.ptr());
}

inline String OptionTextInputOnTextInput::toDbgString() const {
    return String(AzOptionTextInputOnTextInput_toDbgString(&inner_));
}

inline OptionTextInputOnVirtualKeyDown OptionTextInputOnVirtualKeyDown::none() {
    return OptionTextInputOnVirtualKeyDown(AzOptionTextInputOnVirtualKeyDown_none());
}

inline OptionTextInputOnVirtualKeyDown OptionTextInputOnVirtualKeyDown::some(TextInputOnVirtualKeyDown payload) {
    return OptionTextInputOnVirtualKeyDown(AzOptionTextInputOnVirtualKeyDown_some(payload.release()));
}

inline void OptionTextInputOnVirtualKeyDown::delete_() {
    AzOptionTextInputOnVirtualKeyDown_delete(&inner_);
}

inline OptionTextInputOnVirtualKeyDown OptionTextInputOnVirtualKeyDown::clone() const {
    return OptionTextInputOnVirtualKeyDown(AzOptionTextInputOnVirtualKeyDown_clone(&inner_));
}

inline bool OptionTextInputOnVirtualKeyDown::partialEq(const OptionTextInputOnVirtualKeyDown& b) const {
    return AzOptionTextInputOnVirtualKeyDown_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionTextInputOnVirtualKeyDown::hash() const {
    return AzOptionTextInputOnVirtualKeyDown_hash(&inner_);
}

inline uint8_t OptionTextInputOnVirtualKeyDown::partialCmp(const OptionTextInputOnVirtualKeyDown& b) const {
    return AzOptionTextInputOnVirtualKeyDown_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionTextInputOnVirtualKeyDown::cmp(const OptionTextInputOnVirtualKeyDown& b) const {
    return AzOptionTextInputOnVirtualKeyDown_cmp(&inner_, b.ptr());
}

inline String OptionTextInputOnVirtualKeyDown::toDbgString() const {
    return String(AzOptionTextInputOnVirtualKeyDown_toDbgString(&inner_));
}

inline OptionTextInputOnFocusLost OptionTextInputOnFocusLost::none() {
    return OptionTextInputOnFocusLost(AzOptionTextInputOnFocusLost_none());
}

inline OptionTextInputOnFocusLost OptionTextInputOnFocusLost::some(TextInputOnFocusLost payload) {
    return OptionTextInputOnFocusLost(AzOptionTextInputOnFocusLost_some(payload.release()));
}

inline void OptionTextInputOnFocusLost::delete_() {
    AzOptionTextInputOnFocusLost_delete(&inner_);
}

inline OptionTextInputOnFocusLost OptionTextInputOnFocusLost::clone() const {
    return OptionTextInputOnFocusLost(AzOptionTextInputOnFocusLost_clone(&inner_));
}

inline bool OptionTextInputOnFocusLost::partialEq(const OptionTextInputOnFocusLost& b) const {
    return AzOptionTextInputOnFocusLost_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionTextInputOnFocusLost::hash() const {
    return AzOptionTextInputOnFocusLost_hash(&inner_);
}

inline uint8_t OptionTextInputOnFocusLost::partialCmp(const OptionTextInputOnFocusLost& b) const {
    return AzOptionTextInputOnFocusLost_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionTextInputOnFocusLost::cmp(const OptionTextInputOnFocusLost& b) const {
    return AzOptionTextInputOnFocusLost_cmp(&inner_, b.ptr());
}

inline String OptionTextInputOnFocusLost::toDbgString() const {
    return String(AzOptionTextInputOnFocusLost_toDbgString(&inner_));
}

inline OptionNumberInputOnFocusLost OptionNumberInputOnFocusLost::none() {
    return OptionNumberInputOnFocusLost(AzOptionNumberInputOnFocusLost_none());
}

inline OptionNumberInputOnFocusLost OptionNumberInputOnFocusLost::some(NumberInputOnFocusLost payload) {
    return OptionNumberInputOnFocusLost(AzOptionNumberInputOnFocusLost_some(payload.release()));
}

inline void OptionNumberInputOnFocusLost::delete_() {
    AzOptionNumberInputOnFocusLost_delete(&inner_);
}

inline OptionNumberInputOnFocusLost OptionNumberInputOnFocusLost::clone() const {
    return OptionNumberInputOnFocusLost(AzOptionNumberInputOnFocusLost_clone(&inner_));
}

inline bool OptionNumberInputOnFocusLost::partialEq(const OptionNumberInputOnFocusLost& b) const {
    return AzOptionNumberInputOnFocusLost_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionNumberInputOnFocusLost::hash() const {
    return AzOptionNumberInputOnFocusLost_hash(&inner_);
}

inline uint8_t OptionNumberInputOnFocusLost::partialCmp(const OptionNumberInputOnFocusLost& b) const {
    return AzOptionNumberInputOnFocusLost_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionNumberInputOnFocusLost::cmp(const OptionNumberInputOnFocusLost& b) const {
    return AzOptionNumberInputOnFocusLost_cmp(&inner_, b.ptr());
}

inline String OptionNumberInputOnFocusLost::toDbgString() const {
    return String(AzOptionNumberInputOnFocusLost_toDbgString(&inner_));
}

inline OptionNumberInputOnValueChange OptionNumberInputOnValueChange::none() {
    return OptionNumberInputOnValueChange(AzOptionNumberInputOnValueChange_none());
}

inline OptionNumberInputOnValueChange OptionNumberInputOnValueChange::some(NumberInputOnValueChange payload) {
    return OptionNumberInputOnValueChange(AzOptionNumberInputOnValueChange_some(payload.release()));
}

inline void OptionNumberInputOnValueChange::delete_() {
    AzOptionNumberInputOnValueChange_delete(&inner_);
}

inline OptionNumberInputOnValueChange OptionNumberInputOnValueChange::clone() const {
    return OptionNumberInputOnValueChange(AzOptionNumberInputOnValueChange_clone(&inner_));
}

inline bool OptionNumberInputOnValueChange::partialEq(const OptionNumberInputOnValueChange& b) const {
    return AzOptionNumberInputOnValueChange_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionNumberInputOnValueChange::hash() const {
    return AzOptionNumberInputOnValueChange_hash(&inner_);
}

inline uint8_t OptionNumberInputOnValueChange::partialCmp(const OptionNumberInputOnValueChange& b) const {
    return AzOptionNumberInputOnValueChange_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionNumberInputOnValueChange::cmp(const OptionNumberInputOnValueChange& b) const {
    return AzOptionNumberInputOnValueChange_cmp(&inner_, b.ptr());
}

inline String OptionNumberInputOnValueChange::toDbgString() const {
    return String(AzOptionNumberInputOnValueChange_toDbgString(&inner_));
}

inline OptionRawImage OptionRawImage::none() {
    return OptionRawImage(AzOptionRawImage_none());
}

inline OptionRawImage OptionRawImage::some(RawImage payload) {
    return OptionRawImage(AzOptionRawImage_some(payload.release()));
}

inline void OptionRawImage::delete_() {
    AzOptionRawImage_delete(&inner_);
}

inline OptionRawImage OptionRawImage::clone() const {
    return OptionRawImage(AzOptionRawImage_clone(&inner_));
}

inline bool OptionRawImage::partialEq(const OptionRawImage& b) const {
    return AzOptionRawImage_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionRawImage::partialCmp(const OptionRawImage& b) const {
    return AzOptionRawImage_partialCmp(&inner_, b.ptr());
}

inline String OptionRawImage::toDbgString() const {
    return String(AzOptionRawImage_toDbgString(&inner_));
}

inline OptionCoreMenuCallback OptionCoreMenuCallback::none() {
    return OptionCoreMenuCallback(AzOptionCoreMenuCallback_none());
}

inline OptionCoreMenuCallback OptionCoreMenuCallback::some(CoreMenuCallback payload) {
    return OptionCoreMenuCallback(AzOptionCoreMenuCallback_some(payload.release()));
}

inline void OptionCoreMenuCallback::delete_() {
    AzOptionCoreMenuCallback_delete(&inner_);
}

inline OptionCoreMenuCallback OptionCoreMenuCallback::clone() const {
    return OptionCoreMenuCallback(AzOptionCoreMenuCallback_clone(&inner_));
}

inline bool OptionCoreMenuCallback::partialEq(const OptionCoreMenuCallback& b) const {
    return AzOptionCoreMenuCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionCoreMenuCallback::hash() const {
    return AzOptionCoreMenuCallback_hash(&inner_);
}

inline uint8_t OptionCoreMenuCallback::partialCmp(const OptionCoreMenuCallback& b) const {
    return AzOptionCoreMenuCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionCoreMenuCallback::cmp(const OptionCoreMenuCallback& b) const {
    return AzOptionCoreMenuCallback_cmp(&inner_, b.ptr());
}

inline String OptionCoreMenuCallback::toDbgString() const {
    return String(AzOptionCoreMenuCallback_toDbgString(&inner_));
}

inline OptionWaylandTheme OptionWaylandTheme::none() {
    return OptionWaylandTheme(AzOptionWaylandTheme_none());
}

inline OptionWaylandTheme OptionWaylandTheme::some(WaylandTheme payload) {
    return OptionWaylandTheme(AzOptionWaylandTheme_some(payload.release()));
}

inline void OptionWaylandTheme::delete_() {
    AzOptionWaylandTheme_delete(&inner_);
}

inline OptionWaylandTheme OptionWaylandTheme::clone() const {
    return OptionWaylandTheme(AzOptionWaylandTheme_clone(&inner_));
}

inline bool OptionWaylandTheme::partialEq(const OptionWaylandTheme& b) const {
    return AzOptionWaylandTheme_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionWaylandTheme::partialCmp(const OptionWaylandTheme& b) const {
    return AzOptionWaylandTheme_partialCmp(&inner_, b.ptr());
}

inline String OptionWaylandTheme::toDbgString() const {
    return String(AzOptionWaylandTheme_toDbgString(&inner_));
}

inline OptionWindowIcon OptionWindowIcon::none() {
    return OptionWindowIcon(AzOptionWindowIcon_none());
}

inline OptionWindowIcon OptionWindowIcon::some(AzWindowIcon payload) {
    return OptionWindowIcon(AzOptionWindowIcon_some(payload));
}

inline void OptionWindowIcon::delete_() {
    AzOptionWindowIcon_delete(&inner_);
}

inline OptionWindowIcon OptionWindowIcon::clone() const {
    return OptionWindowIcon(AzOptionWindowIcon_clone(&inner_));
}

inline bool OptionWindowIcon::partialEq(const OptionWindowIcon& b) const {
    return AzOptionWindowIcon_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionWindowIcon::hash() const {
    return AzOptionWindowIcon_hash(&inner_);
}

inline uint8_t OptionWindowIcon::partialCmp(const OptionWindowIcon& b) const {
    return AzOptionWindowIcon_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionWindowIcon::cmp(const OptionWindowIcon& b) const {
    return AzOptionWindowIcon_cmp(&inner_, b.ptr());
}

inline String OptionWindowIcon::toDbgString() const {
    return String(AzOptionWindowIcon_toDbgString(&inner_));
}

inline OptionCoreImageCallback OptionCoreImageCallback::none() {
    return OptionCoreImageCallback(AzOptionCoreImageCallback_none());
}

inline OptionCoreImageCallback OptionCoreImageCallback::some(CoreImageCallback payload) {
    return OptionCoreImageCallback(AzOptionCoreImageCallback_some(payload.release()));
}

inline void OptionCoreImageCallback::delete_() {
    AzOptionCoreImageCallback_delete(&inner_);
}

inline OptionCoreImageCallback OptionCoreImageCallback::clone() const {
    return OptionCoreImageCallback(AzOptionCoreImageCallback_clone(&inner_));
}

inline bool OptionCoreImageCallback::partialEq(const OptionCoreImageCallback& b) const {
    return AzOptionCoreImageCallback_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionCoreImageCallback::hash() const {
    return AzOptionCoreImageCallback_hash(&inner_);
}

inline uint8_t OptionCoreImageCallback::partialCmp(const OptionCoreImageCallback& b) const {
    return AzOptionCoreImageCallback_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionCoreImageCallback::cmp(const OptionCoreImageCallback& b) const {
    return AzOptionCoreImageCallback_cmp(&inner_, b.ptr());
}

inline String OptionCoreImageCallback::toDbgString() const {
    return String(AzOptionCoreImageCallback_toDbgString(&inner_));
}

inline OptionSelectAllResult OptionSelectAllResult::none() {
    return OptionSelectAllResult(AzOptionSelectAllResult_none());
}

inline OptionSelectAllResult OptionSelectAllResult::some(SelectAllResult payload) {
    return OptionSelectAllResult(AzOptionSelectAllResult_some(payload.release()));
}

inline void OptionSelectAllResult::delete_() {
    AzOptionSelectAllResult_delete(&inner_);
}

inline OptionSelectAllResult OptionSelectAllResult::clone() const {
    return OptionSelectAllResult(AzOptionSelectAllResult_clone(&inner_));
}

inline bool OptionSelectAllResult::partialEq(const OptionSelectAllResult& b) const {
    return AzOptionSelectAllResult_partialEq(&inner_, b.ptr());
}

inline String OptionSelectAllResult::toDbgString() const {
    return String(AzOptionSelectAllResult_toDbgString(&inner_));
}

inline OptionDeleteResult OptionDeleteResult::none() {
    return OptionDeleteResult(AzOptionDeleteResult_none());
}

inline OptionDeleteResult OptionDeleteResult::some(DeleteResult payload) {
    return OptionDeleteResult(AzOptionDeleteResult_some(payload.release()));
}

inline void OptionDeleteResult::delete_() {
    AzOptionDeleteResult_delete(&inner_);
}

inline OptionDeleteResult OptionDeleteResult::clone() const {
    return OptionDeleteResult(AzOptionDeleteResult_clone(&inner_));
}

inline bool OptionDeleteResult::partialEq(const OptionDeleteResult& b) const {
    return AzOptionDeleteResult_partialEq(&inner_, b.ptr());
}

inline String OptionDeleteResult::toDbgString() const {
    return String(AzOptionDeleteResult_toDbgString(&inner_));
}

inline OptionClipboardContent OptionClipboardContent::none() {
    return OptionClipboardContent(AzOptionClipboardContent_none());
}

inline OptionClipboardContent OptionClipboardContent::some(ClipboardContent payload) {
    return OptionClipboardContent(AzOptionClipboardContent_some(payload.release()));
}

inline void OptionClipboardContent::delete_() {
    AzOptionClipboardContent_delete(&inner_);
}

inline OptionClipboardContent OptionClipboardContent::clone() const {
    return OptionClipboardContent(AzOptionClipboardContent_clone(&inner_));
}

inline bool OptionClipboardContent::partialEq(const OptionClipboardContent& b) const {
    return AzOptionClipboardContent_partialEq(&inner_, b.ptr());
}

inline String OptionClipboardContent::toDbgString() const {
    return String(AzOptionClipboardContent_toDbgString(&inner_));
}

inline OptionFilePath OptionFilePath::none() {
    return OptionFilePath(AzOptionFilePath_none());
}

inline OptionFilePath OptionFilePath::some(FilePath payload) {
    return OptionFilePath(AzOptionFilePath_some(payload.release()));
}

inline void OptionFilePath::delete_() {
    AzOptionFilePath_delete(&inner_);
}

inline OptionFilePath OptionFilePath::clone() const {
    return OptionFilePath(AzOptionFilePath_clone(&inner_));
}

inline bool OptionFilePath::partialEq(const OptionFilePath& b) const {
    return AzOptionFilePath_partialEq(&inner_, b.ptr());
}

inline String OptionFilePath::toDbgString() const {
    return String(AzOptionFilePath_toDbgString(&inner_));
}

inline OptionPendingTextEdit OptionPendingTextEdit::none() {
    return OptionPendingTextEdit(AzOptionPendingTextEdit_none());
}

inline OptionPendingTextEdit OptionPendingTextEdit::some(PendingTextEdit payload) {
    return OptionPendingTextEdit(AzOptionPendingTextEdit_some(payload.release()));
}

inline void OptionPendingTextEdit::delete_() {
    AzOptionPendingTextEdit_delete(&inner_);
}

inline OptionPendingTextEdit OptionPendingTextEdit::clone() const {
    return OptionPendingTextEdit(AzOptionPendingTextEdit_clone(&inner_));
}

inline String OptionPendingTextEdit::toDbgString() const {
    return String(AzOptionPendingTextEdit_toDbgString(&inner_));
}

inline OptionMimeTypeHint OptionMimeTypeHint::none() {
    return OptionMimeTypeHint(AzOptionMimeTypeHint_none());
}

inline OptionMimeTypeHint OptionMimeTypeHint::some(MimeTypeHint payload) {
    return OptionMimeTypeHint(AzOptionMimeTypeHint_some(payload.release()));
}

inline void OptionMimeTypeHint::delete_() {
    AzOptionMimeTypeHint_delete(&inner_);
}

inline OptionMimeTypeHint OptionMimeTypeHint::clone() const {
    return OptionMimeTypeHint(AzOptionMimeTypeHint_clone(&inner_));
}

inline bool OptionMimeTypeHint::partialEq(const OptionMimeTypeHint& b) const {
    return AzOptionMimeTypeHint_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionMimeTypeHint::hash() const {
    return AzOptionMimeTypeHint_hash(&inner_);
}

inline uint8_t OptionMimeTypeHint::partialCmp(const OptionMimeTypeHint& b) const {
    return AzOptionMimeTypeHint_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionMimeTypeHint::cmp(const OptionMimeTypeHint& b) const {
    return AzOptionMimeTypeHint_cmp(&inner_, b.ptr());
}

inline String OptionMimeTypeHint::toDbgString() const {
    return String(AzOptionMimeTypeHint_toDbgString(&inner_));
}

inline OptionAccessibilityAction OptionAccessibilityAction::none() {
    return OptionAccessibilityAction(AzOptionAccessibilityAction_none());
}

inline OptionAccessibilityAction OptionAccessibilityAction::some(AzAccessibilityAction payload) {
    return OptionAccessibilityAction(AzOptionAccessibilityAction_some(payload));
}

inline void OptionAccessibilityAction::delete_() {
    AzOptionAccessibilityAction_delete(&inner_);
}

inline OptionAccessibilityAction OptionAccessibilityAction::clone() const {
    return OptionAccessibilityAction(AzOptionAccessibilityAction_clone(&inner_));
}

inline bool OptionAccessibilityAction::partialEq(const OptionAccessibilityAction& b) const {
    return AzOptionAccessibilityAction_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionAccessibilityAction::hash() const {
    return AzOptionAccessibilityAction_hash(&inner_);
}

inline uint8_t OptionAccessibilityAction::partialCmp(const OptionAccessibilityAction& b) const {
    return AzOptionAccessibilityAction_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionAccessibilityAction::cmp(const OptionAccessibilityAction& b) const {
    return AzOptionAccessibilityAction_cmp(&inner_, b.ptr());
}

inline String OptionAccessibilityAction::toDbgString() const {
    return String(AzOptionAccessibilityAction_toDbgString(&inner_));
}

inline OptionDirEntry OptionDirEntry::none() {
    return OptionDirEntry(AzOptionDirEntry_none());
}

inline OptionDirEntry OptionDirEntry::some(DirEntry payload) {
    return OptionDirEntry(AzOptionDirEntry_some(payload.release()));
}

inline void OptionDirEntry::delete_() {
    AzOptionDirEntry_delete(&inner_);
}

inline OptionDirEntry OptionDirEntry::clone() const {
    return OptionDirEntry(AzOptionDirEntry_clone(&inner_));
}

inline String OptionDirEntry::toDbgString() const {
    return String(AzOptionDirEntry_toDbgString(&inner_));
}

inline OptionNamedFont OptionNamedFont::none() {
    return OptionNamedFont(AzOptionNamedFont_none());
}

inline OptionNamedFont OptionNamedFont::some(NamedFont payload) {
    return OptionNamedFont(AzOptionNamedFont_some(payload.release()));
}

inline void OptionNamedFont::delete_() {
    AzOptionNamedFont_delete(&inner_);
}

inline OptionNamedFont OptionNamedFont::clone() const {
    return OptionNamedFont(AzOptionNamedFont_clone(&inner_));
}

inline bool OptionNamedFont::partialEq(const OptionNamedFont& b) const {
    return AzOptionNamedFont_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionNamedFont::hash() const {
    return AzOptionNamedFont_hash(&inner_);
}

inline uint8_t OptionNamedFont::partialCmp(const OptionNamedFont& b) const {
    return AzOptionNamedFont_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionNamedFont::cmp(const OptionNamedFont& b) const {
    return AzOptionNamedFont_cmp(&inner_, b.ptr());
}

inline String OptionNamedFont::toDbgString() const {
    return String(AzOptionNamedFont_toDbgString(&inner_));
}

inline OptionStyleFilter OptionStyleFilter::none() {
    return OptionStyleFilter(AzOptionStyleFilter_none());
}

inline OptionStyleFilter OptionStyleFilter::some(AzStyleFilter payload) {
    return OptionStyleFilter(AzOptionStyleFilter_some(payload));
}

inline void OptionStyleFilter::delete_() {
    AzOptionStyleFilter_delete(&inner_);
}

inline OptionStyleFilter OptionStyleFilter::clone() const {
    return OptionStyleFilter(AzOptionStyleFilter_clone(&inner_));
}

inline bool OptionStyleFilter::partialEq(const OptionStyleFilter& b) const {
    return AzOptionStyleFilter_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionStyleFilter::hash() const {
    return AzOptionStyleFilter_hash(&inner_);
}

inline uint8_t OptionStyleFilter::partialCmp(const OptionStyleFilter& b) const {
    return AzOptionStyleFilter_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionStyleFilter::cmp(const OptionStyleFilter& b) const {
    return AzOptionStyleFilter_cmp(&inner_, b.ptr());
}

inline String OptionStyleFilter::toDbgString() const {
    return String(AzOptionStyleFilter_toDbgString(&inner_));
}

inline OptionHttpHeader OptionHttpHeader::none() {
    return OptionHttpHeader(AzOptionHttpHeader_none());
}

inline OptionHttpHeader OptionHttpHeader::some(HttpHeader payload) {
    return OptionHttpHeader(AzOptionHttpHeader_some(payload.release()));
}

inline void OptionHttpHeader::delete_() {
    AzOptionHttpHeader_delete(&inner_);
}

inline OptionHttpHeader OptionHttpHeader::clone() const {
    return OptionHttpHeader(AzOptionHttpHeader_clone(&inner_));
}

inline bool OptionHttpHeader::partialEq(const OptionHttpHeader& b) const {
    return AzOptionHttpHeader_partialEq(&inner_, b.ptr());
}

inline String OptionHttpHeader::toDbgString() const {
    return String(AzOptionHttpHeader_toDbgString(&inner_));
}

inline OptionCssRuleBlock OptionCssRuleBlock::none() {
    return OptionCssRuleBlock(AzOptionCssRuleBlock_none());
}

inline OptionCssRuleBlock OptionCssRuleBlock::some(CssRuleBlock payload) {
    return OptionCssRuleBlock(AzOptionCssRuleBlock_some(payload.release()));
}

inline void OptionCssRuleBlock::delete_() {
    AzOptionCssRuleBlock_delete(&inner_);
}

inline OptionCssRuleBlock OptionCssRuleBlock::clone() const {
    return OptionCssRuleBlock(AzOptionCssRuleBlock_clone(&inner_));
}

inline bool OptionCssRuleBlock::partialEq(const OptionCssRuleBlock& b) const {
    return AzOptionCssRuleBlock_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionCssRuleBlock::partialCmp(const OptionCssRuleBlock& b) const {
    return AzOptionCssRuleBlock_partialCmp(&inner_, b.ptr());
}

inline String OptionCssRuleBlock::toDbgString() const {
    return String(AzOptionCssRuleBlock_toDbgString(&inner_));
}

inline OptionCoreCallbackData OptionCoreCallbackData::none() {
    return OptionCoreCallbackData(AzOptionCoreCallbackData_none());
}

inline OptionCoreCallbackData OptionCoreCallbackData::some(CoreCallbackData payload) {
    return OptionCoreCallbackData(AzOptionCoreCallbackData_some(payload.release()));
}

inline void OptionCoreCallbackData::delete_() {
    AzOptionCoreCallbackData_delete(&inner_);
}

inline OptionCoreCallbackData OptionCoreCallbackData::clone() const {
    return OptionCoreCallbackData(AzOptionCoreCallbackData_clone(&inner_));
}

inline bool OptionCoreCallbackData::partialEq(const OptionCoreCallbackData& b) const {
    return AzOptionCoreCallbackData_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionCoreCallbackData::hash() const {
    return AzOptionCoreCallbackData_hash(&inner_);
}

inline uint8_t OptionCoreCallbackData::partialCmp(const OptionCoreCallbackData& b) const {
    return AzOptionCoreCallbackData_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionCoreCallbackData::cmp(const OptionCoreCallbackData& b) const {
    return AzOptionCoreCallbackData_cmp(&inner_, b.ptr());
}

inline String OptionCoreCallbackData::toDbgString() const {
    return String(AzOptionCoreCallbackData_toDbgString(&inner_));
}

inline OptionVertexAttribute OptionVertexAttribute::none() {
    return OptionVertexAttribute(AzOptionVertexAttribute_none());
}

inline OptionVertexAttribute OptionVertexAttribute::some(VertexAttribute payload) {
    return OptionVertexAttribute(AzOptionVertexAttribute_some(payload.release()));
}

inline void OptionVertexAttribute::delete_() {
    AzOptionVertexAttribute_delete(&inner_);
}

inline OptionVertexAttribute OptionVertexAttribute::clone() const {
    return OptionVertexAttribute(AzOptionVertexAttribute_clone(&inner_));
}

inline bool OptionVertexAttribute::partialEq(const OptionVertexAttribute& b) const {
    return AzOptionVertexAttribute_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionVertexAttribute::hash() const {
    return AzOptionVertexAttribute_hash(&inner_);
}

inline uint8_t OptionVertexAttribute::partialCmp(const OptionVertexAttribute& b) const {
    return AzOptionVertexAttribute_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionVertexAttribute::cmp(const OptionVertexAttribute& b) const {
    return AzOptionVertexAttribute_cmp(&inner_, b.ptr());
}

inline String OptionVertexAttribute::toDbgString() const {
    return String(AzOptionVertexAttribute_toDbgString(&inner_));
}

inline OptionDebugMessage OptionDebugMessage::none() {
    return OptionDebugMessage(AzOptionDebugMessage_none());
}

inline OptionDebugMessage OptionDebugMessage::some(DebugMessage payload) {
    return OptionDebugMessage(AzOptionDebugMessage_some(payload.release()));
}

inline void OptionDebugMessage::delete_() {
    AzOptionDebugMessage_delete(&inner_);
}

inline OptionDebugMessage OptionDebugMessage::clone() const {
    return OptionDebugMessage(AzOptionDebugMessage_clone(&inner_));
}

inline bool OptionDebugMessage::partialEq(const OptionDebugMessage& b) const {
    return AzOptionDebugMessage_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionDebugMessage::hash() const {
    return AzOptionDebugMessage_hash(&inner_);
}

inline uint8_t OptionDebugMessage::partialCmp(const OptionDebugMessage& b) const {
    return AzOptionDebugMessage_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionDebugMessage::cmp(const OptionDebugMessage& b) const {
    return AzOptionDebugMessage_cmp(&inner_, b.ptr());
}

inline String OptionDebugMessage::toDbgString() const {
    return String(AzOptionDebugMessage_toDbgString(&inner_));
}

inline OptionListViewRow OptionListViewRow::none() {
    return OptionListViewRow(AzOptionListViewRow_none());
}

inline OptionListViewRow OptionListViewRow::some(ListViewRow payload) {
    return OptionListViewRow(AzOptionListViewRow_some(payload.release()));
}

inline void OptionListViewRow::delete_() {
    AzOptionListViewRow_delete(&inner_);
}

inline OptionListViewRow OptionListViewRow::clone() const {
    return OptionListViewRow(AzOptionListViewRow_clone(&inner_));
}

inline String OptionListViewRow::toDbgString() const {
    return String(AzOptionListViewRow_toDbgString(&inner_));
}

inline OptionIdOrClass OptionIdOrClass::none() {
    return OptionIdOrClass(AzOptionIdOrClass_none());
}

inline OptionIdOrClass OptionIdOrClass::some(AzIdOrClass payload) {
    return OptionIdOrClass(AzOptionIdOrClass_some(payload));
}

inline void OptionIdOrClass::delete_() {
    AzOptionIdOrClass_delete(&inner_);
}

inline OptionIdOrClass OptionIdOrClass::clone() const {
    return OptionIdOrClass(AzOptionIdOrClass_clone(&inner_));
}

inline bool OptionIdOrClass::partialEq(const OptionIdOrClass& b) const {
    return AzOptionIdOrClass_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionIdOrClass::hash() const {
    return AzOptionIdOrClass_hash(&inner_);
}

inline uint8_t OptionIdOrClass::partialCmp(const OptionIdOrClass& b) const {
    return AzOptionIdOrClass_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionIdOrClass::cmp(const OptionIdOrClass& b) const {
    return AzOptionIdOrClass_cmp(&inner_, b.ptr());
}

inline String OptionIdOrClass::toDbgString() const {
    return String(AzOptionIdOrClass_toDbgString(&inner_));
}

inline OptionStyleFontFamily OptionStyleFontFamily::none() {
    return OptionStyleFontFamily(AzOptionStyleFontFamily_none());
}

inline OptionStyleFontFamily OptionStyleFontFamily::some(AzStyleFontFamily payload) {
    return OptionStyleFontFamily(AzOptionStyleFontFamily_some(payload));
}

inline void OptionStyleFontFamily::delete_() {
    AzOptionStyleFontFamily_delete(&inner_);
}

inline OptionStyleFontFamily OptionStyleFontFamily::clone() const {
    return OptionStyleFontFamily(AzOptionStyleFontFamily_clone(&inner_));
}

inline bool OptionStyleFontFamily::partialEq(const OptionStyleFontFamily& b) const {
    return AzOptionStyleFontFamily_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionStyleFontFamily::hash() const {
    return AzOptionStyleFontFamily_hash(&inner_);
}

inline uint8_t OptionStyleFontFamily::partialCmp(const OptionStyleFontFamily& b) const {
    return AzOptionStyleFontFamily_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionStyleFontFamily::cmp(const OptionStyleFontFamily& b) const {
    return AzOptionStyleFontFamily_cmp(&inner_, b.ptr());
}

inline String OptionStyleFontFamily::toDbgString() const {
    return String(AzOptionStyleFontFamily_toDbgString(&inner_));
}

inline OptionStringPair OptionStringPair::none() {
    return OptionStringPair(AzOptionStringPair_none());
}

inline OptionStringPair OptionStringPair::some(StringPair payload) {
    return OptionStringPair(AzOptionStringPair_some(payload.release()));
}

inline void OptionStringPair::delete_() {
    AzOptionStringPair_delete(&inner_);
}

inline OptionStringPair OptionStringPair::clone() const {
    return OptionStringPair(AzOptionStringPair_clone(&inner_));
}

inline bool OptionStringPair::partialEq(const OptionStringPair& b) const {
    return AzOptionStringPair_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionStringPair::hash() const {
    return AzOptionStringPair_hash(&inner_);
}

inline uint8_t OptionStringPair::partialCmp(const OptionStringPair& b) const {
    return AzOptionStringPair_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionStringPair::cmp(const OptionStringPair& b) const {
    return AzOptionStringPair_cmp(&inner_, b.ptr());
}

inline String OptionStringPair::toDbgString() const {
    return String(AzOptionStringPair_toDbgString(&inner_));
}

inline OptionMimeTypeData OptionMimeTypeData::none() {
    return OptionMimeTypeData(AzOptionMimeTypeData_none());
}

inline OptionMimeTypeData OptionMimeTypeData::some(MimeTypeData payload) {
    return OptionMimeTypeData(AzOptionMimeTypeData_some(payload.release()));
}

inline void OptionMimeTypeData::delete_() {
    AzOptionMimeTypeData_delete(&inner_);
}

inline OptionMimeTypeData OptionMimeTypeData::clone() const {
    return OptionMimeTypeData(AzOptionMimeTypeData_clone(&inner_));
}

inline bool OptionMimeTypeData::partialEq(const OptionMimeTypeData& b) const {
    return AzOptionMimeTypeData_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionMimeTypeData::hash() const {
    return AzOptionMimeTypeData_hash(&inner_);
}

inline uint8_t OptionMimeTypeData::partialCmp(const OptionMimeTypeData& b) const {
    return AzOptionMimeTypeData_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionMimeTypeData::cmp(const OptionMimeTypeData& b) const {
    return AzOptionMimeTypeData_cmp(&inner_, b.ptr());
}

inline String OptionMimeTypeData::toDbgString() const {
    return String(AzOptionMimeTypeData_toDbgString(&inner_));
}

inline OptionThemeCondition OptionThemeCondition::none() {
    return OptionThemeCondition(AzOptionThemeCondition_none());
}

inline OptionThemeCondition OptionThemeCondition::some(AzThemeCondition payload) {
    return OptionThemeCondition(AzOptionThemeCondition_some(payload));
}

inline void OptionThemeCondition::delete_() {
    AzOptionThemeCondition_delete(&inner_);
}

inline OptionThemeCondition OptionThemeCondition::clone() const {
    return OptionThemeCondition(AzOptionThemeCondition_clone(&inner_));
}

inline bool OptionThemeCondition::partialEq(const OptionThemeCondition& b) const {
    return AzOptionThemeCondition_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionThemeCondition::hash() const {
    return AzOptionThemeCondition_hash(&inner_);
}

inline String OptionThemeCondition::toDbgString() const {
    return String(AzOptionThemeCondition_toDbgString(&inner_));
}

inline OptionGridAreaDefinition OptionGridAreaDefinition::none() {
    return OptionGridAreaDefinition(AzOptionGridAreaDefinition_none());
}

inline OptionGridAreaDefinition OptionGridAreaDefinition::some(GridAreaDefinition payload) {
    return OptionGridAreaDefinition(AzOptionGridAreaDefinition_some(payload.release()));
}

inline void OptionGridAreaDefinition::delete_() {
    AzOptionGridAreaDefinition_delete(&inner_);
}

inline OptionGridAreaDefinition OptionGridAreaDefinition::clone() const {
    return OptionGridAreaDefinition(AzOptionGridAreaDefinition_clone(&inner_));
}

inline bool OptionGridAreaDefinition::partialEq(const OptionGridAreaDefinition& b) const {
    return AzOptionGridAreaDefinition_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionGridAreaDefinition::hash() const {
    return AzOptionGridAreaDefinition_hash(&inner_);
}

inline uint8_t OptionGridAreaDefinition::partialCmp(const OptionGridAreaDefinition& b) const {
    return AzOptionGridAreaDefinition_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionGridAreaDefinition::cmp(const OptionGridAreaDefinition& b) const {
    return AzOptionGridAreaDefinition_cmp(&inner_, b.ptr());
}

inline OptionComponentLibrary OptionComponentLibrary::none() {
    return OptionComponentLibrary(AzOptionComponentLibrary_none());
}

inline OptionComponentLibrary OptionComponentLibrary::some(ComponentLibrary payload) {
    return OptionComponentLibrary(AzOptionComponentLibrary_some(payload.release()));
}

inline void OptionComponentLibrary::delete_() {
    AzOptionComponentLibrary_delete(&inner_);
}

inline OptionComponentLibrary OptionComponentLibrary::clone() const {
    return OptionComponentLibrary(AzOptionComponentLibrary_clone(&inner_));
}

inline String OptionComponentLibrary::toDbgString() const {
    return String(AzOptionComponentLibrary_toDbgString(&inner_));
}

inline OptionComponentDataModel OptionComponentDataModel::none() {
    return OptionComponentDataModel(AzOptionComponentDataModel_none());
}

inline OptionComponentDataModel OptionComponentDataModel::some(ComponentDataModel payload) {
    return OptionComponentDataModel(AzOptionComponentDataModel_some(payload.release()));
}

inline void OptionComponentDataModel::delete_() {
    AzOptionComponentDataModel_delete(&inner_);
}

inline OptionComponentDataModel OptionComponentDataModel::clone() const {
    return OptionComponentDataModel(AzOptionComponentDataModel_clone(&inner_));
}

inline String OptionComponentDataModel::toDbgString() const {
    return String(AzOptionComponentDataModel_toDbgString(&inner_));
}

inline OptionComponentEnumModel OptionComponentEnumModel::none() {
    return OptionComponentEnumModel(AzOptionComponentEnumModel_none());
}

inline OptionComponentEnumModel OptionComponentEnumModel::some(ComponentEnumModel payload) {
    return OptionComponentEnumModel(AzOptionComponentEnumModel_some(payload.release()));
}

inline void OptionComponentEnumModel::delete_() {
    AzOptionComponentEnumModel_delete(&inner_);
}

inline OptionComponentEnumModel OptionComponentEnumModel::clone() const {
    return OptionComponentEnumModel(AzOptionComponentEnumModel_clone(&inner_));
}

inline bool OptionComponentEnumModel::partialEq(const OptionComponentEnumModel& b) const {
    return AzOptionComponentEnumModel_partialEq(&inner_, b.ptr());
}

inline String OptionComponentEnumModel::toDbgString() const {
    return String(AzOptionComponentEnumModel_toDbgString(&inner_));
}

inline OptionComponentEnumVariant OptionComponentEnumVariant::none() {
    return OptionComponentEnumVariant(AzOptionComponentEnumVariant_none());
}

inline OptionComponentEnumVariant OptionComponentEnumVariant::some(ComponentEnumVariant payload) {
    return OptionComponentEnumVariant(AzOptionComponentEnumVariant_some(payload.release()));
}

inline void OptionComponentEnumVariant::delete_() {
    AzOptionComponentEnumVariant_delete(&inner_);
}

inline OptionComponentEnumVariant OptionComponentEnumVariant::clone() const {
    return OptionComponentEnumVariant(AzOptionComponentEnumVariant_clone(&inner_));
}

inline bool OptionComponentEnumVariant::partialEq(const OptionComponentEnumVariant& b) const {
    return AzOptionComponentEnumVariant_partialEq(&inner_, b.ptr());
}

inline String OptionComponentEnumVariant::toDbgString() const {
    return String(AzOptionComponentEnumVariant_toDbgString(&inner_));
}

inline OptionRibbonOnTabClick OptionRibbonOnTabClick::none() {
    return OptionRibbonOnTabClick(AzOptionRibbonOnTabClick_none());
}

inline OptionRibbonOnTabClick OptionRibbonOnTabClick::some(RibbonOnTabClick payload) {
    return OptionRibbonOnTabClick(AzOptionRibbonOnTabClick_some(payload.release()));
}

inline void OptionRibbonOnTabClick::delete_() {
    AzOptionRibbonOnTabClick_delete(&inner_);
}

inline OptionRibbonOnTabClick OptionRibbonOnTabClick::clone() const {
    return OptionRibbonOnTabClick(AzOptionRibbonOnTabClick_clone(&inner_));
}

inline bool OptionRibbonOnTabClick::partialEq(const OptionRibbonOnTabClick& b) const {
    return AzOptionRibbonOnTabClick_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionRibbonOnTabClick::hash() const {
    return AzOptionRibbonOnTabClick_hash(&inner_);
}

inline uint8_t OptionRibbonOnTabClick::partialCmp(const OptionRibbonOnTabClick& b) const {
    return AzOptionRibbonOnTabClick_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionRibbonOnTabClick::cmp(const OptionRibbonOnTabClick& b) const {
    return AzOptionRibbonOnTabClick_cmp(&inner_, b.ptr());
}

inline String OptionRibbonOnTabClick::toDbgString() const {
    return String(AzOptionRibbonOnTabClick_toDbgString(&inner_));
}

inline OptionTreeViewOnNodeClick OptionTreeViewOnNodeClick::none() {
    return OptionTreeViewOnNodeClick(AzOptionTreeViewOnNodeClick_none());
}

inline OptionTreeViewOnNodeClick OptionTreeViewOnNodeClick::some(TreeViewOnNodeClick payload) {
    return OptionTreeViewOnNodeClick(AzOptionTreeViewOnNodeClick_some(payload.release()));
}

inline void OptionTreeViewOnNodeClick::delete_() {
    AzOptionTreeViewOnNodeClick_delete(&inner_);
}

inline OptionTreeViewOnNodeClick OptionTreeViewOnNodeClick::clone() const {
    return OptionTreeViewOnNodeClick(AzOptionTreeViewOnNodeClick_clone(&inner_));
}

inline bool OptionTreeViewOnNodeClick::partialEq(const OptionTreeViewOnNodeClick& b) const {
    return AzOptionTreeViewOnNodeClick_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionTreeViewOnNodeClick::hash() const {
    return AzOptionTreeViewOnNodeClick_hash(&inner_);
}

inline uint8_t OptionTreeViewOnNodeClick::partialCmp(const OptionTreeViewOnNodeClick& b) const {
    return AzOptionTreeViewOnNodeClick_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionTreeViewOnNodeClick::cmp(const OptionTreeViewOnNodeClick& b) const {
    return AzOptionTreeViewOnNodeClick_cmp(&inner_, b.ptr());
}

inline String OptionTreeViewOnNodeClick::toDbgString() const {
    return String(AzOptionTreeViewOnNodeClick_toDbgString(&inner_));
}

inline OptionRibbonTab OptionRibbonTab::none() {
    return OptionRibbonTab(AzOptionRibbonTab_none());
}

inline OptionRibbonTab OptionRibbonTab::some(RibbonTab payload) {
    return OptionRibbonTab(AzOptionRibbonTab_some(payload.release()));
}

inline void OptionRibbonTab::delete_() {
    AzOptionRibbonTab_delete(&inner_);
}

inline OptionRibbonTab OptionRibbonTab::clone() const {
    return OptionRibbonTab(AzOptionRibbonTab_clone(&inner_));
}

inline String OptionRibbonTab::toDbgString() const {
    return String(AzOptionRibbonTab_toDbgString(&inner_));
}

inline OptionTreeViewNode OptionTreeViewNode::none() {
    return OptionTreeViewNode(AzOptionTreeViewNode_none());
}

inline OptionTreeViewNode OptionTreeViewNode::some(TreeViewNode payload) {
    return OptionTreeViewNode(AzOptionTreeViewNode_some(payload.release()));
}

inline void OptionTreeViewNode::delete_() {
    AzOptionTreeViewNode_delete(&inner_);
}

inline OptionTreeViewNode OptionTreeViewNode::clone() const {
    return OptionTreeViewNode(AzOptionTreeViewNode_clone(&inner_));
}

inline bool OptionTreeViewNode::partialEq(const OptionTreeViewNode& b) const {
    return AzOptionTreeViewNode_partialEq(&inner_, b.ptr());
}

inline String OptionTreeViewNode::toDbgString() const {
    return String(AzOptionTreeViewNode_toDbgString(&inner_));
}

inline OptionRoute OptionRoute::none() {
    return OptionRoute(AzOptionRoute_none());
}

inline OptionRoute OptionRoute::some(Route payload) {
    return OptionRoute(AzOptionRoute_some(payload.release()));
}

inline void OptionRoute::delete_() {
    AzOptionRoute_delete(&inner_);
}

inline OptionRoute OptionRoute::clone() const {
    return OptionRoute(AzOptionRoute_clone(&inner_));
}

inline bool OptionRoute::partialEq(const OptionRoute& b) const {
    return AzOptionRoute_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionRoute::hash() const {
    return AzOptionRoute_hash(&inner_);
}

inline uint8_t OptionRoute::partialCmp(const OptionRoute& b) const {
    return AzOptionRoute_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionRoute::cmp(const OptionRoute& b) const {
    return AzOptionRoute_cmp(&inner_, b.ptr());
}

inline String OptionRoute::toDbgString() const {
    return String(AzOptionRoute_toDbgString(&inner_));
}

inline OptionRouteMatch OptionRouteMatch::none() {
    return OptionRouteMatch(AzOptionRouteMatch_none());
}

inline OptionRouteMatch OptionRouteMatch::some(RouteMatch payload) {
    return OptionRouteMatch(AzOptionRouteMatch_some(payload.release()));
}

inline void OptionRouteMatch::delete_() {
    AzOptionRouteMatch_delete(&inner_);
}

inline OptionRouteMatch OptionRouteMatch::clone() const {
    return OptionRouteMatch(AzOptionRouteMatch_clone(&inner_));
}

inline bool OptionRouteMatch::partialEq(const OptionRouteMatch& b) const {
    return AzOptionRouteMatch_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionRouteMatch::hash() const {
    return AzOptionRouteMatch_hash(&inner_);
}

inline uint8_t OptionRouteMatch::partialCmp(const OptionRouteMatch& b) const {
    return AzOptionRouteMatch_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionRouteMatch::cmp(const OptionRouteMatch& b) const {
    return AzOptionRouteMatch_cmp(&inner_, b.ptr());
}

inline String OptionRouteMatch::toDbgString() const {
    return String(AzOptionRouteMatch_toDbgString(&inner_));
}

inline OptionFileTypeList OptionFileTypeList::none() {
    return OptionFileTypeList(AzOptionFileTypeList_none());
}

inline OptionFileTypeList OptionFileTypeList::some(FileTypeList payload) {
    return OptionFileTypeList(AzOptionFileTypeList_some(payload.release()));
}

inline void OptionFileTypeList::delete_() {
    AzOptionFileTypeList_delete(&inner_);
}

inline OptionFileTypeList OptionFileTypeList::clone() const {
    return OptionFileTypeList(AzOptionFileTypeList_clone(&inner_));
}

inline bool OptionFileTypeList::partialEq(const OptionFileTypeList& b) const {
    return AzOptionFileTypeList_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionFileTypeList::partialCmp(const OptionFileTypeList& b) const {
    return AzOptionFileTypeList_partialCmp(&inner_, b.ptr());
}

inline String OptionFileTypeList::toDbgString() const {
    return String(AzOptionFileTypeList_toDbgString(&inner_));
}

inline OptionKeyringResult OptionKeyringResult::none() {
    return OptionKeyringResult(AzOptionKeyringResult_none());
}

inline OptionKeyringResult OptionKeyringResult::some(AzKeyringResult payload) {
    return OptionKeyringResult(AzOptionKeyringResult_some(payload));
}

inline void OptionKeyringResult::delete_() {
    AzOptionKeyringResult_delete(&inner_);
}

inline OptionKeyringResult OptionKeyringResult::clone() const {
    return OptionKeyringResult(AzOptionKeyringResult_clone(&inner_));
}

inline bool OptionKeyringResult::partialEq(const OptionKeyringResult& b) const {
    return AzOptionKeyringResult_partialEq(&inner_, b.ptr());
}

inline String OptionKeyringResult::toDbgString() const {
    return String(AzOptionKeyringResult_toDbgString(&inner_));
}

inline OptionDbValue OptionDbValue::none() {
    return OptionDbValue(AzOptionDbValue_none());
}

inline OptionDbValue OptionDbValue::some(AzDbValue payload) {
    return OptionDbValue(AzOptionDbValue_some(payload));
}

inline void OptionDbValue::delete_() {
    AzOptionDbValue_delete(&inner_);
}

inline OptionDbValue OptionDbValue::clone() const {
    return OptionDbValue(AzOptionDbValue_clone(&inner_));
}

inline bool OptionDbValue::partialEq(const OptionDbValue& b) const {
    return AzOptionDbValue_partialEq(&inner_, b.ptr());
}

inline String OptionDbValue::toDbgString() const {
    return String(AzOptionDbValue_toDbgString(&inner_));
}

inline OptionOnVideoFrame OptionOnVideoFrame::none() {
    return OptionOnVideoFrame(AzOptionOnVideoFrame_none());
}

inline OptionOnVideoFrame OptionOnVideoFrame::some(OnVideoFrame payload) {
    return OptionOnVideoFrame(AzOptionOnVideoFrame_some(payload.release()));
}

inline void OptionOnVideoFrame::delete_() {
    AzOptionOnVideoFrame_delete(&inner_);
}

inline OptionOnVideoFrame OptionOnVideoFrame::clone() const {
    return OptionOnVideoFrame(AzOptionOnVideoFrame_clone(&inner_));
}

inline bool OptionOnVideoFrame::partialEq(const OptionOnVideoFrame& b) const {
    return AzOptionOnVideoFrame_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionOnVideoFrame::hash() const {
    return AzOptionOnVideoFrame_hash(&inner_);
}

inline uint8_t OptionOnVideoFrame::partialCmp(const OptionOnVideoFrame& b) const {
    return AzOptionOnVideoFrame_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionOnVideoFrame::cmp(const OptionOnVideoFrame& b) const {
    return AzOptionOnVideoFrame_cmp(&inner_, b.ptr());
}

inline String OptionOnVideoFrame::toDbgString() const {
    return String(AzOptionOnVideoFrame_toDbgString(&inner_));
}

inline OptionMapViewportChanged OptionMapViewportChanged::none() {
    return OptionMapViewportChanged(AzOptionMapViewportChanged_none());
}

inline OptionMapViewportChanged OptionMapViewportChanged::some(MapViewportChanged payload) {
    return OptionMapViewportChanged(AzOptionMapViewportChanged_some(payload.release()));
}

inline void OptionMapViewportChanged::delete_() {
    AzOptionMapViewportChanged_delete(&inner_);
}

inline OptionMapViewportChanged OptionMapViewportChanged::clone() const {
    return OptionMapViewportChanged(AzOptionMapViewportChanged_clone(&inner_));
}

inline bool OptionMapViewportChanged::partialEq(const OptionMapViewportChanged& b) const {
    return AzOptionMapViewportChanged_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionMapViewportChanged::hash() const {
    return AzOptionMapViewportChanged_hash(&inner_);
}

inline uint8_t OptionMapViewportChanged::partialCmp(const OptionMapViewportChanged& b) const {
    return AzOptionMapViewportChanged_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionMapViewportChanged::cmp(const OptionMapViewportChanged& b) const {
    return AzOptionMapViewportChanged_cmp(&inner_, b.ptr());
}

inline String OptionMapViewportChanged::toDbgString() const {
    return String(AzOptionMapViewportChanged_toDbgString(&inner_));
}

inline OptionMapPinTap OptionMapPinTap::none() {
    return OptionMapPinTap(AzOptionMapPinTap_none());
}

inline OptionMapPinTap OptionMapPinTap::some(MapPinTap payload) {
    return OptionMapPinTap(AzOptionMapPinTap_some(payload.release()));
}

inline void OptionMapPinTap::delete_() {
    AzOptionMapPinTap_delete(&inner_);
}

inline OptionMapPinTap OptionMapPinTap::clone() const {
    return OptionMapPinTap(AzOptionMapPinTap_clone(&inner_));
}

inline bool OptionMapPinTap::partialEq(const OptionMapPinTap& b) const {
    return AzOptionMapPinTap_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionMapPinTap::hash() const {
    return AzOptionMapPinTap_hash(&inner_);
}

inline uint8_t OptionMapPinTap::partialCmp(const OptionMapPinTap& b) const {
    return AzOptionMapPinTap_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionMapPinTap::cmp(const OptionMapPinTap& b) const {
    return AzOptionMapPinTap_cmp(&inner_, b.ptr());
}

inline String OptionMapPinTap::toDbgString() const {
    return String(AzOptionMapPinTap_toDbgString(&inner_));
}

inline OptionOnAudioFrame OptionOnAudioFrame::none() {
    return OptionOnAudioFrame(AzOptionOnAudioFrame_none());
}

inline OptionOnAudioFrame OptionOnAudioFrame::some(OnAudioFrame payload) {
    return OptionOnAudioFrame(AzOptionOnAudioFrame_some(payload.release()));
}

inline void OptionOnAudioFrame::delete_() {
    AzOptionOnAudioFrame_delete(&inner_);
}

inline OptionOnAudioFrame OptionOnAudioFrame::clone() const {
    return OptionOnAudioFrame(AzOptionOnAudioFrame_clone(&inner_));
}

inline bool OptionOnAudioFrame::partialEq(const OptionOnAudioFrame& b) const {
    return AzOptionOnAudioFrame_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionOnAudioFrame::hash() const {
    return AzOptionOnAudioFrame_hash(&inner_);
}

inline uint8_t OptionOnAudioFrame::partialCmp(const OptionOnAudioFrame& b) const {
    return AzOptionOnAudioFrame_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionOnAudioFrame::cmp(const OptionOnAudioFrame& b) const {
    return AzOptionOnAudioFrame_cmp(&inner_, b.ptr());
}

inline String OptionOnAudioFrame::toDbgString() const {
    return String(AzOptionOnAudioFrame_toDbgString(&inner_));
}

inline OptionLoadedFont OptionLoadedFont::none() {
    return OptionLoadedFont(AzOptionLoadedFont_none());
}

inline OptionLoadedFont OptionLoadedFont::some(LoadedFont payload) {
    return OptionLoadedFont(AzOptionLoadedFont_some(payload.release()));
}

inline void OptionLoadedFont::delete_() {
    AzOptionLoadedFont_delete(&inner_);
}

inline OptionLoadedFont OptionLoadedFont::clone() const {
    return OptionLoadedFont(AzOptionLoadedFont_clone(&inner_));
}

inline bool OptionLoadedFont::partialEq(const OptionLoadedFont& b) const {
    return AzOptionLoadedFont_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionLoadedFont::hash() const {
    return AzOptionLoadedFont_hash(&inner_);
}

inline uint8_t OptionLoadedFont::partialCmp(const OptionLoadedFont& b) const {
    return AzOptionLoadedFont_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionLoadedFont::cmp(const OptionLoadedFont& b) const {
    return AzOptionLoadedFont_cmp(&inner_, b.ptr());
}

inline String OptionLoadedFont::toDbgString() const {
    return String(AzOptionLoadedFont_toDbgString(&inner_));
}

inline ResultRawImageDecodeImageError ResultRawImageDecodeImageError::ok(RawImage payload) {
    return ResultRawImageDecodeImageError(AzResultRawImageDecodeImageError_ok(payload.release()));
}

inline ResultRawImageDecodeImageError ResultRawImageDecodeImageError::err(AzDecodeImageError payload) {
    return ResultRawImageDecodeImageError(AzResultRawImageDecodeImageError_err(payload));
}

inline void ResultRawImageDecodeImageError::delete_() {
    AzResultRawImageDecodeImageError_delete(&inner_);
}

inline ResultRawImageDecodeImageError ResultRawImageDecodeImageError::clone() const {
    return ResultRawImageDecodeImageError(AzResultRawImageDecodeImageError_clone(&inner_));
}

inline String ResultRawImageDecodeImageError::toDbgString() const {
    return String(AzResultRawImageDecodeImageError_toDbgString(&inner_));
}

inline ResultEmptyStructFileError ResultEmptyStructFileError::ok(EmptyStruct payload) {
    return ResultEmptyStructFileError(AzResultEmptyStructFileError_ok(payload.release()));
}

inline ResultEmptyStructFileError ResultEmptyStructFileError::err(FileError payload) {
    return ResultEmptyStructFileError(AzResultEmptyStructFileError_err(payload.release()));
}

inline void ResultEmptyStructFileError::delete_() {
    AzResultEmptyStructFileError_delete(&inner_);
}

inline ResultEmptyStructFileError ResultEmptyStructFileError::clone() const {
    return ResultEmptyStructFileError(AzResultEmptyStructFileError_clone(&inner_));
}

inline String ResultEmptyStructFileError::toDbgString() const {
    return String(AzResultEmptyStructFileError_toDbgString(&inner_));
}

inline Resultu64FileError Resultu64FileError::ok(uint64_t payload) {
    return Resultu64FileError(AzResultu64FileError_ok(payload));
}

inline Resultu64FileError Resultu64FileError::err(FileError payload) {
    return Resultu64FileError(AzResultu64FileError_err(payload.release()));
}

inline void Resultu64FileError::delete_() {
    AzResultu64FileError_delete(&inner_);
}

inline Resultu64FileError Resultu64FileError::clone() const {
    return Resultu64FileError(AzResultu64FileError_clone(&inner_));
}

inline String Resultu64FileError::toDbgString() const {
    return String(AzResultu64FileError_toDbgString(&inner_));
}

inline ResultU8VecFileError ResultU8VecFileError::ok(U8Vec payload) {
    return ResultU8VecFileError(AzResultU8VecFileError_ok(payload.release()));
}

inline ResultU8VecFileError ResultU8VecFileError::err(FileError payload) {
    return ResultU8VecFileError(AzResultU8VecFileError_err(payload.release()));
}

inline void ResultU8VecFileError::delete_() {
    AzResultU8VecFileError_delete(&inner_);
}

inline ResultU8VecFileError ResultU8VecFileError::clone() const {
    return ResultU8VecFileError(AzResultU8VecFileError_clone(&inner_));
}

inline String ResultU8VecFileError::toDbgString() const {
    return String(AzResultU8VecFileError_toDbgString(&inner_));
}

inline ResultFileMetadataFileError ResultFileMetadataFileError::ok(FileMetadata payload) {
    return ResultFileMetadataFileError(AzResultFileMetadataFileError_ok(payload.release()));
}

inline ResultFileMetadataFileError ResultFileMetadataFileError::err(FileError payload) {
    return ResultFileMetadataFileError(AzResultFileMetadataFileError_err(payload.release()));
}

inline void ResultFileMetadataFileError::delete_() {
    AzResultFileMetadataFileError_delete(&inner_);
}

inline ResultFileMetadataFileError ResultFileMetadataFileError::clone() const {
    return ResultFileMetadataFileError(AzResultFileMetadataFileError_clone(&inner_));
}

inline String ResultFileMetadataFileError::toDbgString() const {
    return String(AzResultFileMetadataFileError_toDbgString(&inner_));
}

inline ResultStringFileError ResultStringFileError::ok(String payload) {
    return ResultStringFileError(AzResultStringFileError_ok(payload.release()));
}

inline ResultStringFileError ResultStringFileError::err(FileError payload) {
    return ResultStringFileError(AzResultStringFileError_err(payload.release()));
}

inline void ResultStringFileError::delete_() {
    AzResultStringFileError_delete(&inner_);
}

inline ResultStringFileError ResultStringFileError::clone() const {
    return ResultStringFileError(AzResultStringFileError_clone(&inner_));
}

inline String ResultStringFileError::toDbgString() const {
    return String(AzResultStringFileError_toDbgString(&inner_));
}

inline ResultDirEntryVecFileError ResultDirEntryVecFileError::ok(DirEntryVec payload) {
    return ResultDirEntryVecFileError(AzResultDirEntryVecFileError_ok(payload.release()));
}

inline ResultDirEntryVecFileError ResultDirEntryVecFileError::err(FileError payload) {
    return ResultDirEntryVecFileError(AzResultDirEntryVecFileError_err(payload.release()));
}

inline void ResultDirEntryVecFileError::delete_() {
    AzResultDirEntryVecFileError_delete(&inner_);
}

inline ResultDirEntryVecFileError ResultDirEntryVecFileError::clone() const {
    return ResultDirEntryVecFileError(AzResultDirEntryVecFileError_clone(&inner_));
}

inline String ResultDirEntryVecFileError::toDbgString() const {
    return String(AzResultDirEntryVecFileError_toDbgString(&inner_));
}

inline ResultFilePathFileError ResultFilePathFileError::ok(FilePath payload) {
    return ResultFilePathFileError(AzResultFilePathFileError_ok(payload.release()));
}

inline ResultFilePathFileError ResultFilePathFileError::err(FileError payload) {
    return ResultFilePathFileError(AzResultFilePathFileError_err(payload.release()));
}

inline void ResultFilePathFileError::delete_() {
    AzResultFilePathFileError_delete(&inner_);
}

inline ResultFilePathFileError ResultFilePathFileError::clone() const {
    return ResultFilePathFileError(AzResultFilePathFileError_clone(&inner_));
}

inline String ResultFilePathFileError::toDbgString() const {
    return String(AzResultFilePathFileError_toDbgString(&inner_));
}

inline ResultUrlUrlParseError ResultUrlUrlParseError::ok(Url payload) {
    return ResultUrlUrlParseError(AzResultUrlUrlParseError_ok(payload.release()));
}

inline ResultUrlUrlParseError ResultUrlUrlParseError::err(UrlParseError payload) {
    return ResultUrlUrlParseError(AzResultUrlUrlParseError_err(payload.release()));
}

inline void ResultUrlUrlParseError::delete_() {
    AzResultUrlUrlParseError_delete(&inner_);
}

inline ResultUrlUrlParseError ResultUrlUrlParseError::clone() const {
    return ResultUrlUrlParseError(AzResultUrlUrlParseError_clone(&inner_));
}

inline String ResultUrlUrlParseError::toDbgString() const {
    return String(AzResultUrlUrlParseError_toDbgString(&inner_));
}

inline OptionTimer OptionTimer::none() {
    return OptionTimer(AzOptionTimer_none());
}

inline OptionTimer OptionTimer::some(Timer payload) {
    return OptionTimer(AzOptionTimer_some(payload.release()));
}

inline void OptionTimer::delete_() {
    AzOptionTimer_delete(&inner_);
}

inline OptionTimer OptionTimer::clone() const {
    return OptionTimer(AzOptionTimer_clone(&inner_));
}

inline String OptionTimer::toDbgString() const {
    return String(AzOptionTimer_toDbgString(&inner_));
}

inline OptionDragState OptionDragState::none() {
    return OptionDragState(AzOptionDragState_none());
}

inline OptionDragState OptionDragState::some(DragState payload) {
    return OptionDragState(AzOptionDragState_some(payload.release()));
}

inline void OptionDragState::delete_() {
    AzOptionDragState_delete(&inner_);
}

inline OptionDragState OptionDragState::clone() const {
    return OptionDragState(AzOptionDragState_clone(&inner_));
}

inline bool OptionDragState::partialEq(const OptionDragState& b) const {
    return AzOptionDragState_partialEq(&inner_, b.ptr());
}

inline String OptionDragState::toDbgString() const {
    return String(AzOptionDragState_toDbgString(&inner_));
}

inline OptionJson OptionJson::none() {
    return OptionJson(AzOptionJson_none());
}

inline OptionJson OptionJson::some(Json payload) {
    return OptionJson(AzOptionJson_some(payload.release()));
}

inline void OptionJson::delete_() {
    AzOptionJson_delete(&inner_);
}

inline OptionJson OptionJson::clone() const {
    return OptionJson(AzOptionJson_clone(&inner_));
}

inline bool OptionJson::partialEq(const OptionJson& b) const {
    return AzOptionJson_partialEq(&inner_, b.ptr());
}

inline String OptionJson::toDbgString() const {
    return String(AzOptionJson_toDbgString(&inner_));
}

inline OptionFmtArg OptionFmtArg::none() {
    return OptionFmtArg(AzOptionFmtArg_none());
}

inline OptionFmtArg OptionFmtArg::some(FmtArg payload) {
    return OptionFmtArg(AzOptionFmtArg_some(payload.release()));
}

inline void OptionFmtArg::delete_() {
    AzOptionFmtArg_delete(&inner_);
}

inline OptionFmtArg OptionFmtArg::clone() const {
    return OptionFmtArg(AzOptionFmtArg_clone(&inner_));
}

inline bool OptionFmtArg::partialEq(const OptionFmtArg& b) const {
    return AzOptionFmtArg_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionFmtArg::partialCmp(const OptionFmtArg& b) const {
    return AzOptionFmtArg_partialCmp(&inner_, b.ptr());
}

inline String OptionFmtArg::toDbgString() const {
    return String(AzOptionFmtArg_toDbgString(&inner_));
}

inline OptionMonitor OptionMonitor::none() {
    return OptionMonitor(AzOptionMonitor_none());
}

inline OptionMonitor OptionMonitor::some(Monitor payload) {
    return OptionMonitor(AzOptionMonitor_some(payload.release()));
}

inline void OptionMonitor::delete_() {
    AzOptionMonitor_delete(&inner_);
}

inline OptionMonitor OptionMonitor::clone() const {
    return OptionMonitor(AzOptionMonitor_clone(&inner_));
}

inline bool OptionMonitor::partialEq(const OptionMonitor& b) const {
    return AzOptionMonitor_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionMonitor::partialCmp(const OptionMonitor& b) const {
    return AzOptionMonitor_partialCmp(&inner_, b.ptr());
}

inline String OptionMonitor::toDbgString() const {
    return String(AzOptionMonitor_toDbgString(&inner_));
}

inline OptionStyleBackgroundContent OptionStyleBackgroundContent::none() {
    return OptionStyleBackgroundContent(AzOptionStyleBackgroundContent_none());
}

inline OptionStyleBackgroundContent OptionStyleBackgroundContent::some(AzStyleBackgroundContent payload) {
    return OptionStyleBackgroundContent(AzOptionStyleBackgroundContent_some(payload));
}

inline void OptionStyleBackgroundContent::delete_() {
    AzOptionStyleBackgroundContent_delete(&inner_);
}

inline OptionStyleBackgroundContent OptionStyleBackgroundContent::clone() const {
    return OptionStyleBackgroundContent(AzOptionStyleBackgroundContent_clone(&inner_));
}

inline bool OptionStyleBackgroundContent::partialEq(const OptionStyleBackgroundContent& b) const {
    return AzOptionStyleBackgroundContent_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionStyleBackgroundContent::hash() const {
    return AzOptionStyleBackgroundContent_hash(&inner_);
}

inline uint8_t OptionStyleBackgroundContent::partialCmp(const OptionStyleBackgroundContent& b) const {
    return AzOptionStyleBackgroundContent_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionStyleBackgroundContent::cmp(const OptionStyleBackgroundContent& b) const {
    return AzOptionStyleBackgroundContent_cmp(&inner_, b.ptr());
}

inline String OptionStyleBackgroundContent::toDbgString() const {
    return String(AzOptionStyleBackgroundContent_toDbgString(&inner_));
}

inline OptionStyledTextRun OptionStyledTextRun::none() {
    return OptionStyledTextRun(AzOptionStyledTextRun_none());
}

inline OptionStyledTextRun OptionStyledTextRun::some(StyledTextRun payload) {
    return OptionStyledTextRun(AzOptionStyledTextRun_some(payload.release()));
}

inline void OptionStyledTextRun::delete_() {
    AzOptionStyledTextRun_delete(&inner_);
}

inline OptionStyledTextRun OptionStyledTextRun::clone() const {
    return OptionStyledTextRun(AzOptionStyledTextRun_clone(&inner_));
}

inline bool OptionStyledTextRun::partialEq(const OptionStyledTextRun& b) const {
    return AzOptionStyledTextRun_partialEq(&inner_, b.ptr());
}

inline String OptionStyledTextRun::toDbgString() const {
    return String(AzOptionStyledTextRun_toDbgString(&inner_));
}

inline OptionDynamicSelector OptionDynamicSelector::none() {
    return OptionDynamicSelector(AzOptionDynamicSelector_none());
}

inline OptionDynamicSelector OptionDynamicSelector::some(AzDynamicSelector payload) {
    return OptionDynamicSelector(AzOptionDynamicSelector_some(payload));
}

inline void OptionDynamicSelector::delete_() {
    AzOptionDynamicSelector_delete(&inner_);
}

inline OptionDynamicSelector OptionDynamicSelector::clone() const {
    return OptionDynamicSelector(AzOptionDynamicSelector_clone(&inner_));
}

inline bool OptionDynamicSelector::partialEq(const OptionDynamicSelector& b) const {
    return AzOptionDynamicSelector_partialEq(&inner_, b.ptr());
}

inline String OptionDynamicSelector::toDbgString() const {
    return String(AzOptionDynamicSelector_toDbgString(&inner_));
}

inline OptionAttributeType OptionAttributeType::none() {
    return OptionAttributeType(AzOptionAttributeType_none());
}

inline OptionAttributeType OptionAttributeType::some(AzAttributeType payload) {
    return OptionAttributeType(AzOptionAttributeType_some(payload));
}

inline void OptionAttributeType::delete_() {
    AzOptionAttributeType_delete(&inner_);
}

inline OptionAttributeType OptionAttributeType::clone() const {
    return OptionAttributeType(AzOptionAttributeType_clone(&inner_));
}

inline bool OptionAttributeType::partialEq(const OptionAttributeType& b) const {
    return AzOptionAttributeType_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionAttributeType::hash() const {
    return AzOptionAttributeType_hash(&inner_);
}

inline uint8_t OptionAttributeType::partialCmp(const OptionAttributeType& b) const {
    return AzOptionAttributeType_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionAttributeType::cmp(const OptionAttributeType& b) const {
    return AzOptionAttributeType_cmp(&inner_, b.ptr());
}

inline String OptionAttributeType::toDbgString() const {
    return String(AzOptionAttributeType_toDbgString(&inner_));
}

inline OptionComponentDef OptionComponentDef::none() {
    return OptionComponentDef(AzOptionComponentDef_none());
}

inline OptionComponentDef OptionComponentDef::some(ComponentDef payload) {
    return OptionComponentDef(AzOptionComponentDef_some(payload.release()));
}

inline void OptionComponentDef::delete_() {
    AzOptionComponentDef_delete(&inner_);
}

inline OptionComponentDef OptionComponentDef::clone() const {
    return OptionComponentDef(AzOptionComponentDef_clone(&inner_));
}

inline OptionComponentDefaultValue OptionComponentDefaultValue::none() {
    return OptionComponentDefaultValue(AzOptionComponentDefaultValue_none());
}

inline OptionComponentDefaultValue OptionComponentDefaultValue::some(AzComponentDefaultValue payload) {
    return OptionComponentDefaultValue(AzOptionComponentDefaultValue_some(payload));
}

inline void OptionComponentDefaultValue::delete_() {
    AzOptionComponentDefaultValue_delete(&inner_);
}

inline OptionComponentDefaultValue OptionComponentDefaultValue::clone() const {
    return OptionComponentDefaultValue(AzOptionComponentDefaultValue_clone(&inner_));
}

inline bool OptionComponentDefaultValue::partialEq(const OptionComponentDefaultValue& b) const {
    return AzOptionComponentDefaultValue_partialEq(&inner_, b.ptr());
}

inline String OptionComponentDefaultValue::toDbgString() const {
    return String(AzOptionComponentDefaultValue_toDbgString(&inner_));
}

inline OptionComponentFieldOverride OptionComponentFieldOverride::none() {
    return OptionComponentFieldOverride(AzOptionComponentFieldOverride_none());
}

inline OptionComponentFieldOverride OptionComponentFieldOverride::some(ComponentFieldOverride payload) {
    return OptionComponentFieldOverride(AzOptionComponentFieldOverride_some(payload.release()));
}

inline void OptionComponentFieldOverride::delete_() {
    AzOptionComponentFieldOverride_delete(&inner_);
}

inline OptionComponentFieldOverride OptionComponentFieldOverride::clone() const {
    return OptionComponentFieldOverride(AzOptionComponentFieldOverride_clone(&inner_));
}

inline bool OptionComponentFieldOverride::partialEq(const OptionComponentFieldOverride& b) const {
    return AzOptionComponentFieldOverride_partialEq(&inner_, b.ptr());
}

inline String OptionComponentFieldOverride::toDbgString() const {
    return String(AzOptionComponentFieldOverride_toDbgString(&inner_));
}

inline ResultHttpResponseHttpError ResultHttpResponseHttpError::ok(HttpResponse payload) {
    return ResultHttpResponseHttpError(AzResultHttpResponseHttpError_ok(payload.release()));
}

inline ResultHttpResponseHttpError ResultHttpResponseHttpError::err(AzHttpError payload) {
    return ResultHttpResponseHttpError(AzResultHttpResponseHttpError_err(payload));
}

inline void ResultHttpResponseHttpError::delete_() {
    AzResultHttpResponseHttpError_delete(&inner_);
}

inline ResultHttpResponseHttpError ResultHttpResponseHttpError::clone() const {
    return ResultHttpResponseHttpError(AzResultHttpResponseHttpError_clone(&inner_));
}

inline String ResultHttpResponseHttpError::toDbgString() const {
    return String(AzResultHttpResponseHttpError_toDbgString(&inner_));
}

inline ResultU8VecHttpError ResultU8VecHttpError::ok(U8Vec payload) {
    return ResultU8VecHttpError(AzResultU8VecHttpError_ok(payload.release()));
}

inline ResultU8VecHttpError ResultU8VecHttpError::err(AzHttpError payload) {
    return ResultU8VecHttpError(AzResultU8VecHttpError_err(payload));
}

inline void ResultU8VecHttpError::delete_() {
    AzResultU8VecHttpError_delete(&inner_);
}

inline ResultU8VecHttpError ResultU8VecHttpError::clone() const {
    return ResultU8VecHttpError(AzResultU8VecHttpError_clone(&inner_));
}

inline String ResultU8VecHttpError::toDbgString() const {
    return String(AzResultU8VecHttpError_toDbgString(&inner_));
}

inline ResultJsonJsonParseError ResultJsonJsonParseError::ok(Json payload) {
    return ResultJsonJsonParseError(AzResultJsonJsonParseError_ok(payload.release()));
}

inline ResultJsonJsonParseError ResultJsonJsonParseError::err(JsonParseError payload) {
    return ResultJsonJsonParseError(AzResultJsonJsonParseError_err(payload.release()));
}

inline void ResultJsonJsonParseError::delete_() {
    AzResultJsonJsonParseError_delete(&inner_);
}

inline ResultJsonJsonParseError ResultJsonJsonParseError::clone() const {
    return ResultJsonJsonParseError(AzResultJsonJsonParseError_clone(&inner_));
}

inline String ResultJsonJsonParseError::toDbgString() const {
    return String(AzResultJsonJsonParseError_toDbgString(&inner_));
}

inline OptionExternalResource OptionExternalResource::none() {
    return OptionExternalResource(AzOptionExternalResource_none());
}

inline OptionExternalResource OptionExternalResource::some(ExternalResource payload) {
    return OptionExternalResource(AzOptionExternalResource_some(payload.release()));
}

inline void OptionExternalResource::delete_() {
    AzOptionExternalResource_delete(&inner_);
}

inline OptionExternalResource OptionExternalResource::clone() const {
    return OptionExternalResource(AzOptionExternalResource_clone(&inner_));
}

inline bool OptionExternalResource::partialEq(const OptionExternalResource& b) const {
    return AzOptionExternalResource_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionExternalResource::hash() const {
    return AzOptionExternalResource_hash(&inner_);
}

inline uint8_t OptionExternalResource::partialCmp(const OptionExternalResource& b) const {
    return AzOptionExternalResource_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionExternalResource::cmp(const OptionExternalResource& b) const {
    return AzOptionExternalResource_cmp(&inner_, b.ptr());
}

inline String OptionExternalResource::toDbgString() const {
    return String(AzOptionExternalResource_toDbgString(&inner_));
}

inline OptionJsonKeyValue OptionJsonKeyValue::none() {
    return OptionJsonKeyValue(AzOptionJsonKeyValue_none());
}

inline OptionJsonKeyValue OptionJsonKeyValue::some(JsonKeyValue payload) {
    return OptionJsonKeyValue(AzOptionJsonKeyValue_some(payload.release()));
}

inline void OptionJsonKeyValue::delete_() {
    AzOptionJsonKeyValue_delete(&inner_);
}

inline OptionJsonKeyValue OptionJsonKeyValue::clone() const {
    return OptionJsonKeyValue(AzOptionJsonKeyValue_clone(&inner_));
}

inline bool OptionJsonKeyValue::partialEq(const OptionJsonKeyValue& b) const {
    return AzOptionJsonKeyValue_partialEq(&inner_, b.ptr());
}

inline String OptionJsonKeyValue::toDbgString() const {
    return String(AzOptionJsonKeyValue_toDbgString(&inner_));
}

inline OptionXmlNodeChild OptionXmlNodeChild::none() {
    return OptionXmlNodeChild(AzOptionXmlNodeChild_none());
}

inline OptionXmlNodeChild OptionXmlNodeChild::some(AzXmlNodeChild payload) {
    return OptionXmlNodeChild(AzOptionXmlNodeChild_some(payload));
}

inline void OptionXmlNodeChild::delete_() {
    AzOptionXmlNodeChild_delete(&inner_);
}

inline OptionXmlNodeChild OptionXmlNodeChild::clone() const {
    return OptionXmlNodeChild(AzOptionXmlNodeChild_clone(&inner_));
}

inline bool OptionXmlNodeChild::partialEq(const OptionXmlNodeChild& b) const {
    return AzOptionXmlNodeChild_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionXmlNodeChild::hash() const {
    return AzOptionXmlNodeChild_hash(&inner_);
}

inline uint8_t OptionXmlNodeChild::partialCmp(const OptionXmlNodeChild& b) const {
    return AzOptionXmlNodeChild_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionXmlNodeChild::cmp(const OptionXmlNodeChild& b) const {
    return AzOptionXmlNodeChild_cmp(&inner_, b.ptr());
}

inline String OptionXmlNodeChild::toDbgString() const {
    return String(AzOptionXmlNodeChild_toDbgString(&inner_));
}

inline OptionCssPathSelector OptionCssPathSelector::none() {
    return OptionCssPathSelector(AzOptionCssPathSelector_none());
}

inline OptionCssPathSelector OptionCssPathSelector::some(AzCssPathSelector payload) {
    return OptionCssPathSelector(AzOptionCssPathSelector_some(payload));
}

inline void OptionCssPathSelector::delete_() {
    AzOptionCssPathSelector_delete(&inner_);
}

inline OptionCssPathSelector OptionCssPathSelector::clone() const {
    return OptionCssPathSelector(AzOptionCssPathSelector_clone(&inner_));
}

inline bool OptionCssPathSelector::partialEq(const OptionCssPathSelector& b) const {
    return AzOptionCssPathSelector_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionCssPathSelector::hash() const {
    return AzOptionCssPathSelector_hash(&inner_);
}

inline uint8_t OptionCssPathSelector::partialCmp(const OptionCssPathSelector& b) const {
    return AzOptionCssPathSelector_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionCssPathSelector::cmp(const OptionCssPathSelector& b) const {
    return AzOptionCssPathSelector_cmp(&inner_, b.ptr());
}

inline String OptionCssPathSelector::toDbgString() const {
    return String(AzOptionCssPathSelector_toDbgString(&inner_));
}

inline OptionNodeData OptionNodeData::none() {
    return OptionNodeData(AzOptionNodeData_none());
}

inline OptionNodeData OptionNodeData::some(NodeData payload) {
    return OptionNodeData(AzOptionNodeData_some(payload.release()));
}

inline void OptionNodeData::delete_() {
    AzOptionNodeData_delete(&inner_);
}

inline bool OptionNodeData::partialEq(const OptionNodeData& b) const {
    return AzOptionNodeData_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionNodeData::partialCmp(const OptionNodeData& b) const {
    return AzOptionNodeData_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionNodeData::cmp(const OptionNodeData& b) const {
    return AzOptionNodeData_cmp(&inner_, b.ptr());
}

inline String OptionNodeData::toDbgString() const {
    return String(AzOptionNodeData_toDbgString(&inner_));
}

inline OptionCssMockEnvironment OptionCssMockEnvironment::none() {
    return OptionCssMockEnvironment(AzOptionCssMockEnvironment_none());
}

inline OptionCssMockEnvironment OptionCssMockEnvironment::some(CssMockEnvironment payload) {
    return OptionCssMockEnvironment(AzOptionCssMockEnvironment_some(payload.release()));
}

inline void OptionCssMockEnvironment::delete_() {
    AzOptionCssMockEnvironment_delete(&inner_);
}

inline OptionCssMockEnvironment OptionCssMockEnvironment::clone() const {
    return OptionCssMockEnvironment(AzOptionCssMockEnvironment_clone(&inner_));
}

inline String OptionCssMockEnvironment::toDbgString() const {
    return String(AzOptionCssMockEnvironment_toDbgString(&inner_));
}

inline OptionComponentCallbackArg OptionComponentCallbackArg::none() {
    return OptionComponentCallbackArg(AzOptionComponentCallbackArg_none());
}

inline OptionComponentCallbackArg OptionComponentCallbackArg::some(ComponentCallbackArg payload) {
    return OptionComponentCallbackArg(AzOptionComponentCallbackArg_some(payload.release()));
}

inline void OptionComponentCallbackArg::delete_() {
    AzOptionComponentCallbackArg_delete(&inner_);
}

inline OptionComponentCallbackArg OptionComponentCallbackArg::clone() const {
    return OptionComponentCallbackArg(AzOptionComponentCallbackArg_clone(&inner_));
}

inline bool OptionComponentCallbackArg::partialEq(const OptionComponentCallbackArg& b) const {
    return AzOptionComponentCallbackArg_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionComponentCallbackArg::hash() const {
    return AzOptionComponentCallbackArg_hash(&inner_);
}

inline uint8_t OptionComponentCallbackArg::partialCmp(const OptionComponentCallbackArg& b) const {
    return AzOptionComponentCallbackArg_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionComponentCallbackArg::cmp(const OptionComponentCallbackArg& b) const {
    return AzOptionComponentCallbackArg_cmp(&inner_, b.ptr());
}

inline String OptionComponentCallbackArg::toDbgString() const {
    return String(AzOptionComponentCallbackArg_toDbgString(&inner_));
}

inline OptionDom OptionDom::none() {
    return OptionDom(AzOptionDom_none());
}

inline OptionDom OptionDom::some(Dom payload) {
    return OptionDom(AzOptionDom_some(payload.release()));
}

inline void OptionDom::delete_() {
    AzOptionDom_delete(&inner_);
}

inline OptionDom OptionDom::clone() const {
    return OptionDom(AzOptionDom_clone(&inner_));
}

inline bool OptionDom::partialEq(const OptionDom& b) const {
    return AzOptionDom_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionDom::hash() const {
    return AzOptionDom_hash(&inner_);
}

inline uint8_t OptionDom::partialCmp(const OptionDom& b) const {
    return AzOptionDom_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionDom::cmp(const OptionDom& b) const {
    return AzOptionDom_cmp(&inner_, b.ptr());
}

inline String OptionDom::toDbgString() const {
    return String(AzOptionDom_toDbgString(&inner_));
}

inline OptionMenuItem OptionMenuItem::none() {
    return OptionMenuItem(AzOptionMenuItem_none());
}

inline OptionMenuItem OptionMenuItem::some(AzMenuItem payload) {
    return OptionMenuItem(AzOptionMenuItem_some(payload));
}

inline void OptionMenuItem::delete_() {
    AzOptionMenuItem_delete(&inner_);
}

inline OptionMenuItem OptionMenuItem::clone() const {
    return OptionMenuItem(AzOptionMenuItem_clone(&inner_));
}

inline bool OptionMenuItem::partialEq(const OptionMenuItem& b) const {
    return AzOptionMenuItem_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionMenuItem::hash() const {
    return AzOptionMenuItem_hash(&inner_);
}

inline uint8_t OptionMenuItem::partialCmp(const OptionMenuItem& b) const {
    return AzOptionMenuItem_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionMenuItem::cmp(const OptionMenuItem& b) const {
    return AzOptionMenuItem_cmp(&inner_, b.ptr());
}

inline String OptionMenuItem::toDbgString() const {
    return String(AzOptionMenuItem_toDbgString(&inner_));
}

inline OptionComponentDataField OptionComponentDataField::none() {
    return OptionComponentDataField(AzOptionComponentDataField_none());
}

inline OptionComponentDataField OptionComponentDataField::some(ComponentDataField payload) {
    return OptionComponentDataField(AzOptionComponentDataField_some(payload.release()));
}

inline void OptionComponentDataField::delete_() {
    AzOptionComponentDataField_delete(&inner_);
}

inline OptionComponentDataField OptionComponentDataField::clone() const {
    return OptionComponentDataField(AzOptionComponentDataField_clone(&inner_));
}

inline bool OptionComponentDataField::partialEq(const OptionComponentDataField& b) const {
    return AzOptionComponentDataField_partialEq(&inner_, b.ptr());
}

inline String OptionComponentDataField::toDbgString() const {
    return String(AzOptionComponentDataField_toDbgString(&inner_));
}

inline OptionCssProperty OptionCssProperty::none() {
    return OptionCssProperty(AzOptionCssProperty_none());
}

inline OptionCssProperty OptionCssProperty::some(AzCssProperty payload) {
    return OptionCssProperty(AzOptionCssProperty_some(payload));
}

inline void OptionCssProperty::delete_() {
    AzOptionCssProperty_delete(&inner_);
}

inline OptionCssProperty OptionCssProperty::clone() const {
    return OptionCssProperty(AzOptionCssProperty_clone(&inner_));
}

inline bool OptionCssProperty::partialEq(const OptionCssProperty& b) const {
    return AzOptionCssProperty_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionCssProperty::hash() const {
    return AzOptionCssProperty_hash(&inner_);
}

inline uint8_t OptionCssProperty::partialCmp(const OptionCssProperty& b) const {
    return AzOptionCssProperty_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionCssProperty::cmp(const OptionCssProperty& b) const {
    return AzOptionCssProperty_cmp(&inner_, b.ptr());
}

inline String OptionCssProperty::toDbgString() const {
    return String(AzOptionCssProperty_toDbgString(&inner_));
}

inline OptionUndoableOperation OptionUndoableOperation::none() {
    return OptionUndoableOperation(AzOptionUndoableOperation_none());
}

inline OptionUndoableOperation OptionUndoableOperation::some(UndoableOperation payload) {
    return OptionUndoableOperation(AzOptionUndoableOperation_some(payload.release()));
}

inline void OptionUndoableOperation::delete_() {
    AzOptionUndoableOperation_delete(&inner_);
}

inline OptionUndoableOperation OptionUndoableOperation::clone() const {
    return OptionUndoableOperation(AzOptionUndoableOperation_clone(&inner_));
}

inline String OptionUndoableOperation::toDbgString() const {
    return String(AzOptionUndoableOperation_toDbgString(&inner_));
}

inline OptionRibbonSection OptionRibbonSection::none() {
    return OptionRibbonSection(AzOptionRibbonSection_none());
}

inline OptionRibbonSection OptionRibbonSection::some(RibbonSection payload) {
    return OptionRibbonSection(AzOptionRibbonSection_some(payload.release()));
}

inline void OptionRibbonSection::delete_() {
    AzOptionRibbonSection_delete(&inner_);
}

inline OptionRibbonSection OptionRibbonSection::clone() const {
    return OptionRibbonSection(AzOptionRibbonSection_clone(&inner_));
}

inline String OptionRibbonSection::toDbgString() const {
    return String(AzOptionRibbonSection_toDbgString(&inner_));
}

inline OptionCssPropertyWithConditions OptionCssPropertyWithConditions::none() {
    return OptionCssPropertyWithConditions(AzOptionCssPropertyWithConditions_none());
}

inline OptionCssPropertyWithConditions OptionCssPropertyWithConditions::some(CssPropertyWithConditions payload) {
    return OptionCssPropertyWithConditions(AzOptionCssPropertyWithConditions_some(payload.release()));
}

inline void OptionCssPropertyWithConditions::delete_() {
    AzOptionCssPropertyWithConditions_delete(&inner_);
}

inline OptionCssPropertyWithConditions OptionCssPropertyWithConditions::clone() const {
    return OptionCssPropertyWithConditions(AzOptionCssPropertyWithConditions_clone(&inner_));
}

inline bool OptionCssPropertyWithConditions::partialEq(const OptionCssPropertyWithConditions& b) const {
    return AzOptionCssPropertyWithConditions_partialEq(&inner_, b.ptr());
}

inline uint8_t OptionCssPropertyWithConditions::partialCmp(const OptionCssPropertyWithConditions& b) const {
    return AzOptionCssPropertyWithConditions_partialCmp(&inner_, b.ptr());
}

inline String OptionCssPropertyWithConditions::toDbgString() const {
    return String(AzOptionCssPropertyWithConditions_toDbgString(&inner_));
}

inline ResultSvgSvgParseError ResultSvgSvgParseError::ok(Svg payload) {
    return ResultSvgSvgParseError(AzResultSvgSvgParseError_ok(payload.release()));
}

inline ResultSvgSvgParseError ResultSvgSvgParseError::err(AzSvgParseError payload) {
    return ResultSvgSvgParseError(AzResultSvgSvgParseError_err(payload));
}

inline void ResultSvgSvgParseError::delete_() {
    AzResultSvgSvgParseError_delete(&inner_);
}

inline ResultSvgSvgParseError ResultSvgSvgParseError::clone() const {
    return ResultSvgSvgParseError(AzResultSvgSvgParseError_clone(&inner_));
}

inline String ResultSvgSvgParseError::toDbgString() const {
    return String(AzResultSvgSvgParseError_toDbgString(&inner_));
}

inline ResultParsedSvgSvgParseError ResultParsedSvgSvgParseError::ok(ParsedSvg payload) {
    return ResultParsedSvgSvgParseError(AzResultParsedSvgSvgParseError_ok(payload.release()));
}

inline ResultParsedSvgSvgParseError ResultParsedSvgSvgParseError::err(AzSvgParseError payload) {
    return ResultParsedSvgSvgParseError(AzResultParsedSvgSvgParseError_err(payload));
}

inline void ResultParsedSvgSvgParseError::delete_() {
    AzResultParsedSvgSvgParseError_delete(&inner_);
}

inline ResultParsedSvgSvgParseError ResultParsedSvgSvgParseError::clone() const {
    return ResultParsedSvgSvgParseError(AzResultParsedSvgSvgParseError_clone(&inner_));
}

inline String ResultParsedSvgSvgParseError::toDbgString() const {
    return String(AzResultParsedSvgSvgParseError_toDbgString(&inner_));
}

inline OptionCssDeclaration OptionCssDeclaration::none() {
    return OptionCssDeclaration(AzOptionCssDeclaration_none());
}

inline OptionCssDeclaration OptionCssDeclaration::some(AzCssDeclaration payload) {
    return OptionCssDeclaration(AzOptionCssDeclaration_some(payload));
}

inline void OptionCssDeclaration::delete_() {
    AzOptionCssDeclaration_delete(&inner_);
}

inline OptionCssDeclaration OptionCssDeclaration::clone() const {
    return OptionCssDeclaration(AzOptionCssDeclaration_clone(&inner_));
}

inline bool OptionCssDeclaration::partialEq(const OptionCssDeclaration& b) const {
    return AzOptionCssDeclaration_partialEq(&inner_, b.ptr());
}

inline uint64_t OptionCssDeclaration::hash() const {
    return AzOptionCssDeclaration_hash(&inner_);
}

inline uint8_t OptionCssDeclaration::partialCmp(const OptionCssDeclaration& b) const {
    return AzOptionCssDeclaration_partialCmp(&inner_, b.ptr());
}

inline uint8_t OptionCssDeclaration::cmp(const OptionCssDeclaration& b) const {
    return AzOptionCssDeclaration_cmp(&inner_, b.ptr());
}

inline String OptionCssDeclaration::toDbgString() const {
    return String(AzOptionCssDeclaration_toDbgString(&inner_));
}

inline ResultStyledDomRenderDomError ResultStyledDomRenderDomError::ok(StyledDom payload) {
    return ResultStyledDomRenderDomError(AzResultStyledDomRenderDomError_ok(payload.release()));
}

inline ResultStyledDomRenderDomError ResultStyledDomRenderDomError::err(AzRenderDomError payload) {
    return ResultStyledDomRenderDomError(AzResultStyledDomRenderDomError_err(payload));
}

inline void ResultStyledDomRenderDomError::delete_() {
    AzResultStyledDomRenderDomError_delete(&inner_);
}

inline ResultStyledDomRenderDomError ResultStyledDomRenderDomError::clone() const {
    return ResultStyledDomRenderDomError(AzResultStyledDomRenderDomError_clone(&inner_));
}

inline String ResultStyledDomRenderDomError::toDbgString() const {
    return String(AzResultStyledDomRenderDomError_toDbgString(&inner_));
}

inline ResultStringCompileError ResultStringCompileError::ok(String payload) {
    return ResultStringCompileError(AzResultStringCompileError_ok(payload.release()));
}

inline ResultStringCompileError ResultStringCompileError::err(AzCompileError payload) {
    return ResultStringCompileError(AzResultStringCompileError_err(payload));
}

inline void ResultStringCompileError::delete_() {
    AzResultStringCompileError_delete(&inner_);
}

inline ResultStringCompileError ResultStringCompileError::clone() const {
    return ResultStringCompileError(AzResultStringCompileError_clone(&inner_));
}

inline String ResultStringCompileError::toDbgString() const {
    return String(AzResultStringCompileError_toDbgString(&inner_));
}

} // namespace azul

// Structured-binding specializations: every ResultXxx wrapper destructures
// to (std::optional<Ok>, std::optional<Err>).
namespace azul {
template<size_t I> auto get(ResultU8VecEncodeImageError&& r) {
    static_assert(I < 2, "ResultU8VecEncodeImageError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzU8Vec>(std::move(r).inner().Ok.payload) : std::optional<AzU8Vec>{};
    } else {
        return r.isErr() ? std::optional<AzEncodeImageError>(std::move(r).inner().Err.payload) : std::optional<AzEncodeImageError>{};
    }
}
template<size_t I> auto get(ResultRefAnyString&& r) {
    static_assert(I < 2, "ResultRefAnyString only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzRefAny>(std::move(r).inner().Ok.payload) : std::optional<AzRefAny>{};
    } else {
        return r.isErr() ? std::optional<AzString>(std::move(r).inner().Err.payload) : std::optional<AzString>{};
    }
}
template<size_t I> auto get(ResultU8VecString&& r) {
    static_assert(I < 2, "ResultU8VecString only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzU8Vec>(std::move(r).inner().Ok.payload) : std::optional<AzU8Vec>{};
    } else {
        return r.isErr() ? std::optional<AzString>(std::move(r).inner().Err.payload) : std::optional<AzString>{};
    }
}
template<size_t I> auto get(ResultStringString&& r) {
    static_assert(I < 2, "ResultStringString only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzString>(std::move(r).inner().Ok.payload) : std::optional<AzString>{};
    } else {
        return r.isErr() ? std::optional<AzString>(std::move(r).inner().Err.payload) : std::optional<AzString>{};
    }
}
template<size_t I> auto get(ResultRawImageDecodeImageError&& r) {
    static_assert(I < 2, "ResultRawImageDecodeImageError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzRawImage>(std::move(r).inner().Ok.payload) : std::optional<AzRawImage>{};
    } else {
        return r.isErr() ? std::optional<AzDecodeImageError>(std::move(r).inner().Err.payload) : std::optional<AzDecodeImageError>{};
    }
}
template<size_t I> auto get(ResultEmptyStructFileError&& r) {
    static_assert(I < 2, "ResultEmptyStructFileError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzEmptyStruct>(std::move(r).inner().Ok.payload) : std::optional<AzEmptyStruct>{};
    } else {
        return r.isErr() ? std::optional<AzFileError>(std::move(r).inner().Err.payload) : std::optional<AzFileError>{};
    }
}
template<size_t I> auto get(Resultu64FileError&& r) {
    static_assert(I < 2, "Resultu64FileError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<uint64_t>(std::move(r).inner().Ok.payload) : std::optional<uint64_t>{};
    } else {
        return r.isErr() ? std::optional<AzFileError>(std::move(r).inner().Err.payload) : std::optional<AzFileError>{};
    }
}
template<size_t I> auto get(ResultU8VecFileError&& r) {
    static_assert(I < 2, "ResultU8VecFileError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzU8Vec>(std::move(r).inner().Ok.payload) : std::optional<AzU8Vec>{};
    } else {
        return r.isErr() ? std::optional<AzFileError>(std::move(r).inner().Err.payload) : std::optional<AzFileError>{};
    }
}
template<size_t I> auto get(ResultFileMetadataFileError&& r) {
    static_assert(I < 2, "ResultFileMetadataFileError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzFileMetadata>(std::move(r).inner().Ok.payload) : std::optional<AzFileMetadata>{};
    } else {
        return r.isErr() ? std::optional<AzFileError>(std::move(r).inner().Err.payload) : std::optional<AzFileError>{};
    }
}
template<size_t I> auto get(ResultStringFileError&& r) {
    static_assert(I < 2, "ResultStringFileError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzString>(std::move(r).inner().Ok.payload) : std::optional<AzString>{};
    } else {
        return r.isErr() ? std::optional<AzFileError>(std::move(r).inner().Err.payload) : std::optional<AzFileError>{};
    }
}
template<size_t I> auto get(ResultDirEntryVecFileError&& r) {
    static_assert(I < 2, "ResultDirEntryVecFileError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzDirEntryVec>(std::move(r).inner().Ok.payload) : std::optional<AzDirEntryVec>{};
    } else {
        return r.isErr() ? std::optional<AzFileError>(std::move(r).inner().Err.payload) : std::optional<AzFileError>{};
    }
}
template<size_t I> auto get(ResultFilePathFileError&& r) {
    static_assert(I < 2, "ResultFilePathFileError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzFilePath>(std::move(r).inner().Ok.payload) : std::optional<AzFilePath>{};
    } else {
        return r.isErr() ? std::optional<AzFileError>(std::move(r).inner().Err.payload) : std::optional<AzFileError>{};
    }
}
template<size_t I> auto get(ResultUrlUrlParseError&& r) {
    static_assert(I < 2, "ResultUrlUrlParseError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzUrl>(std::move(r).inner().Ok.payload) : std::optional<AzUrl>{};
    } else {
        return r.isErr() ? std::optional<AzUrlParseError>(std::move(r).inner().Err.payload) : std::optional<AzUrlParseError>{};
    }
}
template<size_t I> auto get(ResultHttpResponseHttpError&& r) {
    static_assert(I < 2, "ResultHttpResponseHttpError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzHttpResponse>(std::move(r).inner().Ok.payload) : std::optional<AzHttpResponse>{};
    } else {
        return r.isErr() ? std::optional<AzHttpError>(std::move(r).inner().Err.payload) : std::optional<AzHttpError>{};
    }
}
template<size_t I> auto get(ResultU8VecHttpError&& r) {
    static_assert(I < 2, "ResultU8VecHttpError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzU8Vec>(std::move(r).inner().Ok.payload) : std::optional<AzU8Vec>{};
    } else {
        return r.isErr() ? std::optional<AzHttpError>(std::move(r).inner().Err.payload) : std::optional<AzHttpError>{};
    }
}
template<size_t I> auto get(ResultJsonJsonParseError&& r) {
    static_assert(I < 2, "ResultJsonJsonParseError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzJson>(std::move(r).inner().Ok.payload) : std::optional<AzJson>{};
    } else {
        return r.isErr() ? std::optional<AzJsonParseError>(std::move(r).inner().Err.payload) : std::optional<AzJsonParseError>{};
    }
}
template<size_t I> auto get(ResultSvgSvgParseError&& r) {
    static_assert(I < 2, "ResultSvgSvgParseError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzSvg>(std::move(r).inner().Ok.payload) : std::optional<AzSvg>{};
    } else {
        return r.isErr() ? std::optional<AzSvgParseError>(std::move(r).inner().Err.payload) : std::optional<AzSvgParseError>{};
    }
}
template<size_t I> auto get(ResultParsedSvgSvgParseError&& r) {
    static_assert(I < 2, "ResultParsedSvgSvgParseError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzParsedSvg>(std::move(r).inner().Ok.payload) : std::optional<AzParsedSvg>{};
    } else {
        return r.isErr() ? std::optional<AzSvgParseError>(std::move(r).inner().Err.payload) : std::optional<AzSvgParseError>{};
    }
}
template<size_t I> auto get(ResultStyledDomRenderDomError&& r) {
    static_assert(I < 2, "ResultStyledDomRenderDomError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzStyledDom>(std::move(r).inner().Ok.payload) : std::optional<AzStyledDom>{};
    } else {
        return r.isErr() ? std::optional<AzRenderDomError>(std::move(r).inner().Err.payload) : std::optional<AzRenderDomError>{};
    }
}
template<size_t I> auto get(ResultStringCompileError&& r) {
    static_assert(I < 2, "ResultStringCompileError only has 2 elements (ok, err)");
    if constexpr (I == 0) {
        return r.isOk() ? std::optional<AzString>(std::move(r).inner().Ok.payload) : std::optional<AzString>{};
    } else {
        return r.isErr() ? std::optional<AzCompileError>(std::move(r).inner().Err.payload) : std::optional<AzCompileError>{};
    }
}
} // namespace azul

template<> struct std::tuple_size<azul::ResultU8VecEncodeImageError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultU8VecEncodeImageError> { using type = std::optional<AzU8Vec>; };
template<> struct std::tuple_element<1, azul::ResultU8VecEncodeImageError> { using type = std::optional<AzEncodeImageError>; };
template<> struct std::tuple_size<azul::ResultRefAnyString> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultRefAnyString> { using type = std::optional<AzRefAny>; };
template<> struct std::tuple_element<1, azul::ResultRefAnyString> { using type = std::optional<AzString>; };
template<> struct std::tuple_size<azul::ResultU8VecString> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultU8VecString> { using type = std::optional<AzU8Vec>; };
template<> struct std::tuple_element<1, azul::ResultU8VecString> { using type = std::optional<AzString>; };
template<> struct std::tuple_size<azul::ResultStringString> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultStringString> { using type = std::optional<AzString>; };
template<> struct std::tuple_element<1, azul::ResultStringString> { using type = std::optional<AzString>; };
template<> struct std::tuple_size<azul::ResultRawImageDecodeImageError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultRawImageDecodeImageError> { using type = std::optional<AzRawImage>; };
template<> struct std::tuple_element<1, azul::ResultRawImageDecodeImageError> { using type = std::optional<AzDecodeImageError>; };
template<> struct std::tuple_size<azul::ResultEmptyStructFileError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultEmptyStructFileError> { using type = std::optional<AzEmptyStruct>; };
template<> struct std::tuple_element<1, azul::ResultEmptyStructFileError> { using type = std::optional<AzFileError>; };
template<> struct std::tuple_size<azul::Resultu64FileError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::Resultu64FileError> { using type = std::optional<uint64_t>; };
template<> struct std::tuple_element<1, azul::Resultu64FileError> { using type = std::optional<AzFileError>; };
template<> struct std::tuple_size<azul::ResultU8VecFileError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultU8VecFileError> { using type = std::optional<AzU8Vec>; };
template<> struct std::tuple_element<1, azul::ResultU8VecFileError> { using type = std::optional<AzFileError>; };
template<> struct std::tuple_size<azul::ResultFileMetadataFileError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultFileMetadataFileError> { using type = std::optional<AzFileMetadata>; };
template<> struct std::tuple_element<1, azul::ResultFileMetadataFileError> { using type = std::optional<AzFileError>; };
template<> struct std::tuple_size<azul::ResultStringFileError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultStringFileError> { using type = std::optional<AzString>; };
template<> struct std::tuple_element<1, azul::ResultStringFileError> { using type = std::optional<AzFileError>; };
template<> struct std::tuple_size<azul::ResultDirEntryVecFileError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultDirEntryVecFileError> { using type = std::optional<AzDirEntryVec>; };
template<> struct std::tuple_element<1, azul::ResultDirEntryVecFileError> { using type = std::optional<AzFileError>; };
template<> struct std::tuple_size<azul::ResultFilePathFileError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultFilePathFileError> { using type = std::optional<AzFilePath>; };
template<> struct std::tuple_element<1, azul::ResultFilePathFileError> { using type = std::optional<AzFileError>; };
template<> struct std::tuple_size<azul::ResultUrlUrlParseError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultUrlUrlParseError> { using type = std::optional<AzUrl>; };
template<> struct std::tuple_element<1, azul::ResultUrlUrlParseError> { using type = std::optional<AzUrlParseError>; };
template<> struct std::tuple_size<azul::ResultHttpResponseHttpError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultHttpResponseHttpError> { using type = std::optional<AzHttpResponse>; };
template<> struct std::tuple_element<1, azul::ResultHttpResponseHttpError> { using type = std::optional<AzHttpError>; };
template<> struct std::tuple_size<azul::ResultU8VecHttpError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultU8VecHttpError> { using type = std::optional<AzU8Vec>; };
template<> struct std::tuple_element<1, azul::ResultU8VecHttpError> { using type = std::optional<AzHttpError>; };
template<> struct std::tuple_size<azul::ResultJsonJsonParseError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultJsonJsonParseError> { using type = std::optional<AzJson>; };
template<> struct std::tuple_element<1, azul::ResultJsonJsonParseError> { using type = std::optional<AzJsonParseError>; };
template<> struct std::tuple_size<azul::ResultSvgSvgParseError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultSvgSvgParseError> { using type = std::optional<AzSvg>; };
template<> struct std::tuple_element<1, azul::ResultSvgSvgParseError> { using type = std::optional<AzSvgParseError>; };
template<> struct std::tuple_size<azul::ResultParsedSvgSvgParseError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultParsedSvgSvgParseError> { using type = std::optional<AzParsedSvg>; };
template<> struct std::tuple_element<1, azul::ResultParsedSvgSvgParseError> { using type = std::optional<AzSvgParseError>; };
template<> struct std::tuple_size<azul::ResultStyledDomRenderDomError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultStyledDomRenderDomError> { using type = std::optional<AzStyledDom>; };
template<> struct std::tuple_element<1, azul::ResultStyledDomRenderDomError> { using type = std::optional<AzRenderDomError>; };
template<> struct std::tuple_size<azul::ResultStringCompileError> : std::integral_constant<size_t, 2> {};
template<> struct std::tuple_element<0, azul::ResultStringCompileError> { using type = std::optional<AzString>; };
template<> struct std::tuple_element<1, azul::ResultStringCompileError> { using type = std::optional<AzCompileError>; };

#endif // AZUL_CPP20_HPP