// =============================================================================
// Azul C++03 API Wrapper
// =============================================================================
//
// Compile with: g++ -std=c++03 -o myapp myapp.cpp -lazul
//
// This header provides C++ wrapper classes for the Azul C API.
// All classes use RAII for memory management.
//
// C++03 MOVE EMULATION (Colvin-Gibbons Trick)
// ============================================
//
// C++03 lacks move semantics, which normally prevents returning non-copyable
// RAII objects by value. This header uses the "Colvin-Gibbons trick" to work
// around this limitation.
//
// How it works:
// - Each non-copyable class has a nested 'Proxy' struct
// - When returning by value, the object converts to Proxy (releasing ownership)
// - The receiving object constructs from Proxy (acquiring ownership)
// - Direct copy construction transfers ownership (like std::auto_ptr)
//
// WARNING: These objects CANNOT be safely stored in C++03 STL containers!
//
// =============================================================================

#ifndef AZUL_CPP03_HPP
#define AZUL_CPP03_HPP

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

#include <stdint.h>
#include <stddef.h>
#include <string.h>

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((const uint8_t*)s, 0, strlen(s));
}

// =============================================================================
// AZ_REFLECT Macro - Runtime Type Information for user types
// =============================================================================

#define AZ_REFLECT(structName) \
    AZ_REFLECT_FULL(structName, 0, 0)

#define AZ_REFLECT_JSON(structName, toJsonFn, fromJsonFn) \
    AZ_REFLECT_FULL(structName, (uintptr_t)(toJsonFn), (uintptr_t)(fromJsonFn))

#define AZ_REFLECT_FULL(structName, serializeFn, deserializeFn) \
    static const uint64_t structName##_type_id_storage = 0; \
    static uint64_t structName##_type_id() { return (uint64_t)(&structName##_type_id_storage); } \
    static void structName##_destructor(void* ptr) { delete (structName*)ptr; } \
    static azul::RefAny structName##_upcast(structName model) { \
        structName* heap = new structName(model); \
        AzGlVoidPtrConst ptr; ptr.ptr = heap; \
        AzString name = az_string_from_literal(#structName); \
        return azul::RefAny(AzRefAny_newC(ptr, sizeof(structName), \
            sizeof(structName), structName##_type_id(), name, structName##_destructor, serializeFn, deserializeFn)); \
    } \
    static structName const* structName##_downcast_ref(azul::RefAny& data) { \
        if (!AzRefAny_isType(&data.inner(), structName##_type_id())) return 0; \
        return (structName const*)(AzRefAny_getDataPtr(&data.inner())); \
    } \
    static structName* structName##_downcast_mut(azul::RefAny& data) { \
        if (!AzRefAny_isType(&data.inner(), structName##_type_id())) return 0; \
        return (structName*)(AzRefAny_getDataPtr(&data.inner())); \
    }

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;

// Wrapper class declarations

class MonitorId {
private:
    AzMonitorId inner_;

public:
    MonitorId(AzMonitorId inner) : inner_(inner) {}
    MonitorId(const MonitorId& other) : inner_(other.inner_) {}
    MonitorId& operator=(const MonitorId& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WasmWindowOptions {
private:
    AzWasmWindowOptions inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class IconKey {
private:
    AzIconKey inner_;

public:
    IconKey(AzIconKey inner) : inner_(inner) {}
    IconKey(const IconKey& other) : inner_(other.inner_) {}
    IconKey& operator=(const IconKey& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MacWindowOptions {
private:
    AzMacWindowOptions inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class IOSHandle {
private:
    AzIOSHandle inner_;

public:
    IOSHandle(AzIOSHandle inner) : inner_(inner) {}
    IOSHandle(const IOSHandle& other) : inner_(other.inner_) {}
    IOSHandle& operator=(const IOSHandle& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MacOSHandle {
private:
    AzMacOSHandle inner_;

public:
    MacOSHandle(AzMacOSHandle inner) : inner_(inner) {}
    MacOSHandle(const MacOSHandle& other) : inner_(other.inner_) {}
    MacOSHandle& operator=(const MacOSHandle& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class XcbHandle {
private:
    AzXcbHandle inner_;

public:
    XcbHandle(AzXcbHandle inner) : inner_(inner) {}
    XcbHandle(const XcbHandle& other) : inner_(other.inner_) {}
    XcbHandle& operator=(const XcbHandle& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class XlibHandle {
private:
    AzXlibHandle inner_;

public:
    XlibHandle(AzXlibHandle inner) : inner_(inner) {}
    XlibHandle(const XlibHandle& other) : inner_(other.inner_) {}
    XlibHandle& operator=(const XlibHandle& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WaylandHandle {
private:
    AzWaylandHandle inner_;

public:
    WaylandHandle(AzWaylandHandle inner) : inner_(inner) {}
    WaylandHandle(const WaylandHandle& other) : inner_(other.inner_) {}
    WaylandHandle& operator=(const WaylandHandle& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WindowsHandle {
private:
    AzWindowsHandle inner_;

public:
    WindowsHandle(AzWindowsHandle inner) : inner_(inner) {}
    WindowsHandle(const WindowsHandle& other) : inner_(other.inner_) {}
    WindowsHandle& operator=(const WindowsHandle& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WebHandle {
private:
    AzWebHandle inner_;

public:
    WebHandle(AzWebHandle inner) : inner_(inner) {}
    WebHandle(const WebHandle& other) : inner_(other.inner_) {}
    WebHandle& operator=(const WebHandle& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AndroidHandle {
private:
    AzAndroidHandle inner_;

public:
    AndroidHandle(AzAndroidHandle inner) : inner_(inner) {}
    AndroidHandle(const AndroidHandle& other) : inner_(other.inner_) {}
    AndroidHandle& operator=(const AndroidHandle& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class IconProviderHandle {
public:
    struct Proxy { AzIconProviderHandle inner; Proxy(AzIconProviderHandle p) : inner(p) {} };

private:
    mutable AzIconProviderHandle inner_;

public:
    explicit IconProviderHandle(AzIconProviderHandle inner) : inner_(inner) {}
    IconProviderHandle(const IconProviderHandle& other) : inner_(other.inner_) { memset(const_cast<AzIconProviderHandle*>(&other.inner_), 0, sizeof(other.inner_)); }
    IconProviderHandle& operator=(const IconProviderHandle& other) {
        AzIconProviderHandle_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzIconProviderHandle*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    IconProviderHandle(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    IconProviderHandle& operator=(Proxy p) {
        AzIconProviderHandle_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~IconProviderHandle() { AzIconProviderHandle_delete(&inner_); }

    static IconProviderHandle create();
    static IconProviderHandle with_resolver(AzIconResolverCallbackType resolver);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VideoModeVecSlice {
private:
    AzVideoModeVecSlice inner_;

public:
    VideoModeVecSlice(AzVideoModeVecSlice inner) : inner_(inner) {}
    VideoModeVecSlice(const VideoModeVecSlice& other) : inner_(other.inner_) {}
    VideoModeVecSlice& operator=(const VideoModeVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MonitorVecSlice {
private:
    AzMonitorVecSlice inner_;

public:
    MonitorVecSlice(AzMonitorVecSlice inner) : inner_(inner) {}
    MonitorVecSlice(const MonitorVecSlice& other) : inner_(other.inner_) {}
    MonitorVecSlice& operator=(const MonitorVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MimeTypeDataVecSlice {
private:
    AzMimeTypeDataVecSlice inner_;

public:
    MimeTypeDataVecSlice(AzMimeTypeDataVecSlice inner) : inner_(inner) {}
    MimeTypeDataVecSlice(const MimeTypeDataVecSlice& other) : inner_(other.inner_) {}
    MimeTypeDataVecSlice& operator=(const MimeTypeDataVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TouchPointVecSlice {
private:
    AzTouchPointVecSlice inner_;

public:
    TouchPointVecSlice(AzTouchPointVecSlice inner) : inner_(inner) {}
    TouchPointVecSlice(const TouchPointVecSlice& other) : inner_(other.inner_) {}
    TouchPointVecSlice& operator=(const TouchPointVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AudioSink {
public:
    struct Proxy { AzAudioSink inner; Proxy(AzAudioSink p) : inner(p) {} };

private:
    mutable AzAudioSink inner_;

public:
    explicit AudioSink(AzAudioSink inner) : inner_(inner) {}
    AudioSink(const AudioSink& other) : inner_(other.inner_) { memset(const_cast<AzAudioSink*>(&other.inner_), 0, sizeof(other.inner_)); }
    AudioSink& operator=(const AudioSink& other) {
        AzAudioSink_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzAudioSink*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    AudioSink(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    AudioSink& operator=(Proxy p) {
        AzAudioSink_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~AudioSink() { AzAudioSink_delete(&inner_); }

    static AudioSink open(AudioConfig config);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class HttpHeaderVecSlice {
private:
    AzHttpHeaderVecSlice inner_;

public:
    HttpHeaderVecSlice(AzHttpHeaderVecSlice inner) : inner_(inner) {}
    HttpHeaderVecSlice(const HttpHeaderVecSlice& other) : inner_(other.inner_) {}
    HttpHeaderVecSlice& operator=(const HttpHeaderVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MsgBox {
private:
    AzMsgBox inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FileDialog {
private:
    AzFileDialog inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ColorPickerDialog {
private:
    AzColorPickerDialog inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RefCount {
public:
    struct Proxy { AzRefCount inner; Proxy(AzRefCount p) : inner(p) {} };

private:
    mutable AzRefCount inner_;

public:
    explicit RefCount(AzRefCount inner) : inner_(inner) {}
    RefCount(const RefCount& other) : inner_(other.inner_) { memset(const_cast<AzRefCount*>(&other.inner_), 0, sizeof(other.inner_)); }
    RefCount& operator=(const RefCount& other) {
        AzRefCount_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRefCount*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RefCount(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RefCount& operator=(Proxy p) {
        AzRefCount_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GraphemeClusterId {
private:
    AzGraphemeClusterId inner_;

public:
    GraphemeClusterId(AzGraphemeClusterId inner) : inner_(inner) {}
    GraphemeClusterId(const GraphemeClusterId& other) : inner_(other.inner_) {}
    GraphemeClusterId& operator=(const GraphemeClusterId& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class PenTilt {
private:
    AzPenTilt inner_;

public:
    PenTilt(AzPenTilt inner) : inner_(inner) {}
    PenTilt(const PenTilt& other) : inner_(other.inner_) {}
    PenTilt& operator=(const PenTilt& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NodeFlags {
private:
    AzNodeFlags inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DomId {
private:
    AzDomId inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NodeHierarchyItemId {
private:
    AzNodeHierarchyItemId inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NodeHierarchyItem {
private:
    AzNodeHierarchyItem inner_;

public:
    NodeHierarchyItem(AzNodeHierarchyItem inner) : inner_(inner) {}
    NodeHierarchyItem(const NodeHierarchyItem& other) : inner_(other.inner_) {}
    NodeHierarchyItem& operator=(const NodeHierarchyItem& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TagId {
private:
    AzTagId inner_;

public:
    TagId(AzTagId inner) : inner_(inner) {}
    TagId(const TagId& other) : inner_(other.inner_) {}
    TagId& operator=(const TagId& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DebugState {
private:
    AzDebugState inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GeolocationProbeConfig {
private:
    AzGeolocationProbeConfig inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LocationFix {
private:
    AzLocationFix inner_;

public:
    LocationFix(AzLocationFix inner) : inner_(inner) {}
    LocationFix(const LocationFix& other) : inner_(other.inner_) {}
    LocationFix& operator=(const LocationFix& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NodeId {
private:
    AzNodeId inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SelectionId {
private:
    AzSelectionId inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextInputSelectionRange {
public:
    struct Proxy { AzTextInputSelectionRange inner; Proxy(AzTextInputSelectionRange p) : inner(p) {} };

private:
    mutable AzTextInputSelectionRange inner_;

public:
    explicit TextInputSelectionRange(AzTextInputSelectionRange inner) : inner_(inner) {}
    TextInputSelectionRange(const TextInputSelectionRange& other) : inner_(other.inner_) { memset(const_cast<AzTextInputSelectionRange*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextInputSelectionRange& operator=(const TextInputSelectionRange& other) {
        AzTextInputSelectionRange_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextInputSelectionRange*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextInputSelectionRange(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextInputSelectionRange& operator=(Proxy p) {
        AzTextInputSelectionRange_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextSelectionStartEnd {
public:
    struct Proxy { AzTextSelectionStartEnd inner; Proxy(AzTextSelectionStartEnd p) : inner(p) {} };

private:
    mutable AzTextSelectionStartEnd inner_;

public:
    explicit TextSelectionStartEnd(AzTextSelectionStartEnd inner) : inner_(inner) {}
    TextSelectionStartEnd(const TextSelectionStartEnd& other) : inner_(other.inner_) { memset(const_cast<AzTextSelectionStartEnd*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextSelectionStartEnd& operator=(const TextSelectionStartEnd& other) {
        AzTextSelectionStartEnd_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextSelectionStartEnd*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextSelectionStartEnd(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextSelectionStartEnd& operator=(Proxy p) {
        AzTextSelectionStartEnd_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NodeDataVecSlice {
private:
    AzNodeDataVecSlice inner_;

public:
    NodeDataVecSlice(AzNodeDataVecSlice inner) : inner_(inner) {}
    NodeDataVecSlice(const NodeDataVecSlice& other) : inner_(other.inner_) {}
    NodeDataVecSlice& operator=(const NodeDataVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NodeHierarchyItemVecSlice {
private:
    AzNodeHierarchyItemVecSlice inner_;

public:
    NodeHierarchyItemVecSlice(AzNodeHierarchyItemVecSlice inner) : inner_(inner) {}
    NodeHierarchyItemVecSlice(const NodeHierarchyItemVecSlice& other) : inner_(other.inner_) {}
    NodeHierarchyItemVecSlice& operator=(const NodeHierarchyItemVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DomIdVecSlice {
private:
    AzDomIdVecSlice inner_;

public:
    DomIdVecSlice(AzDomIdVecSlice inner) : inner_(inner) {}
    DomIdVecSlice(const DomIdVecSlice& other) : inner_(other.inner_) {}
    DomIdVecSlice& operator=(const DomIdVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TagIdToNodeIdMappingVecSlice {
private:
    AzTagIdToNodeIdMappingVecSlice inner_;

public:
    TagIdToNodeIdMappingVecSlice(AzTagIdToNodeIdMappingVecSlice inner) : inner_(inner) {}
    TagIdToNodeIdMappingVecSlice(const TagIdToNodeIdMappingVecSlice& other) : inner_(other.inner_) {}
    TagIdToNodeIdMappingVecSlice& operator=(const TagIdToNodeIdMappingVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VertexAttributeVecSlice {
private:
    AzVertexAttributeVecSlice inner_;

public:
    VertexAttributeVecSlice(AzVertexAttributeVecSlice inner) : inner_(inner) {}
    VertexAttributeVecSlice(const VertexAttributeVecSlice& other) : inner_(other.inner_) {}
    VertexAttributeVecSlice& operator=(const VertexAttributeVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NodeHierarchyItemIdVecSlice {
private:
    AzNodeHierarchyItemIdVecSlice inner_;

public:
    NodeHierarchyItemIdVecSlice(AzNodeHierarchyItemIdVecSlice inner) : inner_(inner) {}
    NodeHierarchyItemIdVecSlice(const NodeHierarchyItemIdVecSlice& other) : inner_(other.inner_) {}
    NodeHierarchyItemIdVecSlice& operator=(const NodeHierarchyItemIdVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class IdOrClassVecSlice {
private:
    AzIdOrClassVecSlice inner_;

public:
    IdOrClassVecSlice(AzIdOrClassVecSlice inner) : inner_(inner) {}
    IdOrClassVecSlice(const IdOrClassVecSlice& other) : inner_(other.inner_) {}
    IdOrClassVecSlice& operator=(const IdOrClassVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SelectionRangeVecSlice {
private:
    AzSelectionRangeVecSlice inner_;

public:
    SelectionRangeVecSlice(AzSelectionRangeVecSlice inner) : inner_(inner) {}
    SelectionRangeVecSlice(const SelectionRangeVecSlice& other) : inner_(other.inner_) {}
    SelectionRangeVecSlice& operator=(const SelectionRangeVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SelectionVecSlice {
private:
    AzSelectionVecSlice inner_;

public:
    SelectionVecSlice(AzSelectionVecSlice inner) : inner_(inner) {}
    SelectionVecSlice(const SelectionVecSlice& other) : inner_(other.inner_) {}
    SelectionVecSlice& operator=(const SelectionVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DomVecSlice {
private:
    AzDomVecSlice inner_;

public:
    DomVecSlice(AzDomVecSlice inner) : inner_(inner) {}
    DomVecSlice(const DomVecSlice& other) : inner_(other.inner_) {}
    DomVecSlice& operator=(const DomVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AttributeTypeVecSlice {
private:
    AzAttributeTypeVecSlice inner_;

public:
    AttributeTypeVecSlice(AzAttributeTypeVecSlice inner) : inner_(inner) {}
    AttributeTypeVecSlice(const AttributeTypeVecSlice& other) : inner_(other.inner_) {}
    AttributeTypeVecSlice& operator=(const AttributeTypeVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AccessibilityActionVecSlice {
private:
    AzAccessibilityActionVecSlice inner_;

public:
    AccessibilityActionVecSlice(AzAccessibilityActionVecSlice inner) : inner_(inner) {}
    AccessibilityActionVecSlice(const AccessibilityActionVecSlice& other) : inner_(other.inner_) {}
    AccessibilityActionVecSlice& operator=(const AccessibilityActionVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CoreCallbackDataVecSlice {
private:
    AzCoreCallbackDataVecSlice inner_;

public:
    CoreCallbackDataVecSlice(AzCoreCallbackDataVecSlice inner) : inner_(inner) {}
    CoreCallbackDataVecSlice(const CoreCallbackDataVecSlice& other) : inner_(other.inner_) {}
    CoreCallbackDataVecSlice& operator=(const CoreCallbackDataVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ParentWithNodeDepthVecSlice {
private:
    AzParentWithNodeDepthVecSlice inner_;

public:
    ParentWithNodeDepthVecSlice(AzParentWithNodeDepthVecSlice inner) : inner_(inner) {}
    ParentWithNodeDepthVecSlice(const ParentWithNodeDepthVecSlice& other) : inner_(other.inner_) {}
    ParentWithNodeDepthVecSlice& operator=(const ParentWithNodeDepthVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class XmlNodeChildVecSlice {
private:
    AzXmlNodeChildVecSlice inner_;

public:
    XmlNodeChildVecSlice(AzXmlNodeChildVecSlice inner) : inner_(inner) {}
    XmlNodeChildVecSlice(const XmlNodeChildVecSlice& other) : inner_(other.inner_) {}
    XmlNodeChildVecSlice& operator=(const XmlNodeChildVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AccessibilitySettings {
public:
    struct Proxy { AzAccessibilitySettings inner; Proxy(AzAccessibilitySettings p) : inner(p) {} };

private:
    mutable AzAccessibilitySettings inner_;

public:
    explicit AccessibilitySettings(AzAccessibilitySettings inner) : inner_(inner) {}
    AccessibilitySettings(const AccessibilitySettings& other) : inner_(other.inner_) { memset(const_cast<AzAccessibilitySettings*>(&other.inner_), 0, sizeof(other.inner_)); }
    AccessibilitySettings& operator=(const AccessibilitySettings& other) {
        AzAccessibilitySettings_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzAccessibilitySettings*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    AccessibilitySettings(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    AccessibilitySettings& operator=(Proxy p) {
        AzAccessibilitySettings_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~AccessibilitySettings() { AzAccessibilitySettings_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class InputMetrics {
private:
    AzInputMetrics inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DragDelta {
private:
    AzDragDelta inner_;

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

    static DragDelta create(float dx, float dy);
    static DragDelta zero();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MenuItemVecSlice {
private:
    AzMenuItemVecSlice inner_;

public:
    MenuItemVecSlice(AzMenuItemVecSlice inner) : inner_(inner) {}
    MenuItemVecSlice(const MenuItemVecSlice& other) : inner_(other.inner_) {}
    MenuItemVecSlice& operator=(const MenuItemVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssNthChildPattern {
private:
    AzCssNthChildPattern inner_;

public:
    CssNthChildPattern(AzCssNthChildPattern inner) : inner_(inner) {}
    CssNthChildPattern(const CssNthChildPattern& other) : inner_(other.inner_) {}
    CssNthChildPattern& operator=(const CssNthChildPattern& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ColorU {
private:
    AzColorU inner_;

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

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

class FloatValue {
private:
    AzFloatValue inner_;

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

    static FloatValue create(float value);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutSize {
private:
    AzLayoutSize inner_;

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

    static LayoutSize create(ptrdiff_t width, ptrdiff_t height);
    static LayoutSize zero();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleLineClamp {
private:
    AzStyleLineClamp inner_;

public:
    StyleLineClamp(AzStyleLineClamp inner) : inner_(inner) {}
    StyleLineClamp(const StyleLineClamp& other) : inner_(other.inner_) {}
    StyleLineClamp& operator=(const StyleLineClamp& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Orphans {
private:
    AzOrphans inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Widows {
private:
    AzWidows inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleHangingPunctuation {
private:
    AzStyleHangingPunctuation inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class XmlTextPos {
public:
    struct Proxy { AzXmlTextPos inner; Proxy(AzXmlTextPos p) : inner(p) {} };

private:
    mutable AzXmlTextPos inner_;

public:
    explicit XmlTextPos(AzXmlTextPos inner) : inner_(inner) {}
    XmlTextPos(const XmlTextPos& other) : inner_(other.inner_) { memset(const_cast<AzXmlTextPos*>(&other.inner_), 0, sizeof(other.inner_)); }
    XmlTextPos& operator=(const XmlTextPos& other) {
        AzXmlTextPos_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzXmlTextPos*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    XmlTextPos(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    XmlTextPos& operator=(Proxy p) {
        AzXmlTextPos_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LogicalSize {
private:
    AzLogicalSize inner_;

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

    static LogicalSize create(float width, float height);
    static LogicalSize zero();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyledNodeState {
private:
    AzStyledNodeState inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssPropertyCachePtr {
public:
    struct Proxy { AzCssPropertyCachePtr inner; Proxy(AzCssPropertyCachePtr p) : inner(p) {} };

private:
    mutable AzCssPropertyCachePtr inner_;

public:
    explicit CssPropertyCachePtr(AzCssPropertyCachePtr inner) : inner_(inner) {}
    CssPropertyCachePtr(const CssPropertyCachePtr& other) : inner_(other.inner_) { memset(const_cast<AzCssPropertyCachePtr*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssPropertyCachePtr& operator=(const CssPropertyCachePtr& other) {
        AzCssPropertyCachePtr_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssPropertyCachePtr*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssPropertyCachePtr(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssPropertyCachePtr& operator=(Proxy p) {
        AzCssPropertyCachePtr_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgRenderTransform {
private:
    AzSvgRenderTransform inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LogicalPosition {
private:
    AzLogicalPosition inner_;

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

    static LogicalPosition create(float x, float y);
    static LogicalPosition zero();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ScreenPosition {
private:
    AzScreenPosition inner_;

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

    static ScreenPosition create(float x, float y);
    static ScreenPosition zero();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CursorNodePosition {
private:
    AzCursorNodePosition inner_;

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

    static CursorNodePosition create(float x, float y);
    static CursorNodePosition zero();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GridMinMax {
public:
    struct Proxy { AzGridMinMax inner; Proxy(AzGridMinMax p) : inner(p) {} };

private:
    mutable AzGridMinMax inner_;

public:
    explicit GridMinMax(AzGridMinMax inner) : inner_(inner) {}
    GridMinMax(const GridMinMax& other) : inner_(other.inner_) { memset(const_cast<AzGridMinMax*>(&other.inner_), 0, sizeof(other.inner_)); }
    GridMinMax& operator=(const GridMinMax& other) {
        AzGridMinMax_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGridMinMax*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GridMinMax(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GridMinMax& operator=(Proxy p) {
        AzGridMinMax_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ShapePoint {
private:
    AzShapePoint inner_;

public:
    ShapePoint(AzShapePoint inner) : inner_(inner) {}
    ShapePoint(const ShapePoint& other) : inner_(other.inner_) {}
    ShapePoint& operator=(const ShapePoint& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutRectVecSlice {
private:
    AzLayoutRectVecSlice inner_;

public:
    LayoutRectVecSlice(AzLayoutRectVecSlice inner) : inner_(inner) {}
    LayoutRectVecSlice(const LayoutRectVecSlice& other) : inner_(other.inner_) {}
    LayoutRectVecSlice& operator=(const LayoutRectVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutPoint {
private:
    AzLayoutPoint inner_;

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

    static LayoutPoint create(ptrdiff_t x, ptrdiff_t y);
    static LayoutPoint zero();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LinuxDecorationsState {
private:
    AzLinuxDecorationsState inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CascadeInfo {
private:
    AzCascadeInfo inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GridTrackSizingVecSlice {
private:
    AzGridTrackSizingVecSlice inner_;

public:
    GridTrackSizingVecSlice(AzGridTrackSizingVecSlice inner) : inner_(inner) {}
    GridTrackSizingVecSlice(const GridTrackSizingVecSlice& other) : inner_(other.inner_) {}
    GridTrackSizingVecSlice& operator=(const GridTrackSizingVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ContentGroupVecSlice {
private:
    AzContentGroupVecSlice inner_;

public:
    ContentGroupVecSlice(AzContentGroupVecSlice inner) : inner_(inner) {}
    ContentGroupVecSlice(const ContentGroupVecSlice& other) : inner_(other.inner_) {}
    ContentGroupVecSlice& operator=(const ContentGroupVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyledTextRunVecSlice {
private:
    AzStyledTextRunVecSlice inner_;

public:
    StyledTextRunVecSlice(AzStyledTextRunVecSlice inner) : inner_(inner) {}
    StyledTextRunVecSlice(const StyledTextRunVecSlice& other) : inner_(other.inner_) {}
    StyledTextRunVecSlice& operator=(const StyledTextRunVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssRuleBlockVecSlice {
private:
    AzCssRuleBlockVecSlice inner_;

public:
    CssRuleBlockVecSlice(AzCssRuleBlockVecSlice inner) : inner_(inner) {}
    CssRuleBlockVecSlice(const CssRuleBlockVecSlice& other) : inner_(other.inner_) {}
    CssRuleBlockVecSlice& operator=(const CssRuleBlockVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CascadeInfoVecSlice {
private:
    AzCascadeInfoVecSlice inner_;

public:
    CascadeInfoVecSlice(AzCascadeInfoVecSlice inner) : inner_(inner) {}
    CascadeInfoVecSlice(const CascadeInfoVecSlice& other) : inner_(other.inner_) {}
    CascadeInfoVecSlice& operator=(const CascadeInfoVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NormalizedRadialColorStopVecSlice {
private:
    AzNormalizedRadialColorStopVecSlice inner_;

public:
    NormalizedRadialColorStopVecSlice(AzNormalizedRadialColorStopVecSlice inner) : inner_(inner) {}
    NormalizedRadialColorStopVecSlice(const NormalizedRadialColorStopVecSlice& other) : inner_(other.inner_) {}
    NormalizedRadialColorStopVecSlice& operator=(const NormalizedRadialColorStopVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleFontFamilyVecSlice {
private:
    AzStyleFontFamilyVecSlice inner_;

public:
    StyleFontFamilyVecSlice(AzStyleFontFamilyVecSlice inner) : inner_(inner) {}
    StyleFontFamilyVecSlice(const StyleFontFamilyVecSlice& other) : inner_(other.inner_) {}
    StyleFontFamilyVecSlice& operator=(const StyleFontFamilyVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleFilterVecSlice {
private:
    AzStyleFilterVecSlice inner_;

public:
    StyleFilterVecSlice(AzStyleFilterVecSlice inner) : inner_(inner) {}
    StyleFilterVecSlice(const StyleFilterVecSlice& other) : inner_(other.inner_) {}
    StyleFilterVecSlice& operator=(const StyleFilterVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBackgroundSizeVecSlice {
private:
    AzStyleBackgroundSizeVecSlice inner_;

public:
    StyleBackgroundSizeVecSlice(AzStyleBackgroundSizeVecSlice inner) : inner_(inner) {}
    StyleBackgroundSizeVecSlice(const StyleBackgroundSizeVecSlice& other) : inner_(other.inner_) {}
    StyleBackgroundSizeVecSlice& operator=(const StyleBackgroundSizeVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBackgroundContentVecSlice {
private:
    AzStyleBackgroundContentVecSlice inner_;

public:
    StyleBackgroundContentVecSlice(AzStyleBackgroundContentVecSlice inner) : inner_(inner) {}
    StyleBackgroundContentVecSlice(const StyleBackgroundContentVecSlice& other) : inner_(other.inner_) {}
    StyleBackgroundContentVecSlice& operator=(const StyleBackgroundContentVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssDeclarationVecSlice {
private:
    AzCssDeclarationVecSlice inner_;

public:
    CssDeclarationVecSlice(AzCssDeclarationVecSlice inner) : inner_(inner) {}
    CssDeclarationVecSlice(const CssDeclarationVecSlice& other) : inner_(other.inner_) {}
    CssDeclarationVecSlice& operator=(const CssDeclarationVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBackgroundPositionVecSlice {
private:
    AzStyleBackgroundPositionVecSlice inner_;

public:
    StyleBackgroundPositionVecSlice(AzStyleBackgroundPositionVecSlice inner) : inner_(inner) {}
    StyleBackgroundPositionVecSlice(const StyleBackgroundPositionVecSlice& other) : inner_(other.inner_) {}
    StyleBackgroundPositionVecSlice& operator=(const StyleBackgroundPositionVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NormalizedLinearColorStopVecSlice {
private:
    AzNormalizedLinearColorStopVecSlice inner_;

public:
    NormalizedLinearColorStopVecSlice(AzNormalizedLinearColorStopVecSlice inner) : inner_(inner) {}
    NormalizedLinearColorStopVecSlice(const NormalizedLinearColorStopVecSlice& other) : inner_(other.inner_) {}
    NormalizedLinearColorStopVecSlice& operator=(const NormalizedLinearColorStopVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssPropertyWithConditionsVecSlice {
private:
    AzCssPropertyWithConditionsVecSlice inner_;

public:
    CssPropertyWithConditionsVecSlice(AzCssPropertyWithConditionsVecSlice inner) : inner_(inner) {}
    CssPropertyWithConditionsVecSlice(const CssPropertyWithConditionsVecSlice& other) : inner_(other.inner_) {}
    CssPropertyWithConditionsVecSlice& operator=(const CssPropertyWithConditionsVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssVecSlice {
private:
    AzCssVecSlice inner_;

public:
    CssVecSlice(AzCssVecSlice inner) : inner_(inner) {}
    CssVecSlice(const CssVecSlice& other) : inner_(other.inner_) {}
    CssVecSlice& operator=(const CssVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTransformVecSlice {
private:
    AzStyleTransformVecSlice inner_;

public:
    StyleTransformVecSlice(AzStyleTransformVecSlice inner) : inner_(inner) {}
    StyleTransformVecSlice(const StyleTransformVecSlice& other) : inner_(other.inner_) {}
    StyleTransformVecSlice& operator=(const StyleTransformVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyledNodeVecSlice {
private:
    AzStyledNodeVecSlice inner_;

public:
    StyledNodeVecSlice(AzStyledNodeVecSlice inner) : inner_(inner) {}
    StyledNodeVecSlice(const StyledNodeVecSlice& other) : inner_(other.inner_) {}
    StyledNodeVecSlice& operator=(const StyledNodeVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ShapePointVecSlice {
private:
    AzShapePointVecSlice inner_;

public:
    ShapePointVecSlice(AzShapePointVecSlice inner) : inner_(inner) {}
    ShapePointVecSlice(const ShapePointVecSlice& other) : inner_(other.inner_) {}
    ShapePointVecSlice& operator=(const ShapePointVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NamedFontVecSlice {
private:
    AzNamedFontVecSlice inner_;

public:
    NamedFontVecSlice(AzNamedFontVecSlice inner) : inner_(inner) {}
    NamedFontVecSlice(const NamedFontVecSlice& other) : inner_(other.inner_) {}
    NamedFontVecSlice& operator=(const NamedFontVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GridAreaDefinitionVecSlice {
private:
    AzGridAreaDefinitionVecSlice inner_;

public:
    GridAreaDefinitionVecSlice(AzGridAreaDefinitionVecSlice inner) : inner_(inner) {}
    GridAreaDefinitionVecSlice(const GridAreaDefinitionVecSlice& other) : inner_(other.inner_) {}
    GridAreaDefinitionVecSlice& operator=(const GridAreaDefinitionVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgTransform {
private:
    AzSvgTransform inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ScrollbarFadeDuration {
private:
    AzScrollbarFadeDuration inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ScrollbarFadeDelay {
private:
    AzScrollbarFadeDelay inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class U16VecSlice {
private:
    AzU16VecSlice inner_;

public:
    U16VecSlice(AzU16VecSlice inner) : inner_(inner) {}
    U16VecSlice(const U16VecSlice& other) : inner_(other.inner_) {}
    U16VecSlice& operator=(const U16VecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AudioMetrics {
private:
    AzAudioMetrics inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ScrollPhysics {
public:
    struct Proxy { AzScrollPhysics inner; Proxy(AzScrollPhysics p) : inner(p) {} };

private:
    mutable AzScrollPhysics inner_;

public:
    explicit ScrollPhysics(AzScrollPhysics inner) : inner_(inner) {}
    ScrollPhysics(const ScrollPhysics& other) : inner_(other.inner_) { memset(const_cast<AzScrollPhysics*>(&other.inner_), 0, sizeof(other.inner_)); }
    ScrollPhysics& operator=(const ScrollPhysics& other) {
        AzScrollPhysics_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzScrollPhysics*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ScrollPhysics(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ScrollPhysics& operator=(Proxy p) {
        AzScrollPhysics_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ScrollPhysics() { AzScrollPhysics_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CalcAstItemVecSlice {
private:
    AzCalcAstItemVecSlice inner_;

public:
    CalcAstItemVecSlice(AzCalcAstItemVecSlice inner) : inner_(inner) {}
    CalcAstItemVecSlice(const CalcAstItemVecSlice& other) : inner_(other.inner_) {}
    CalcAstItemVecSlice& operator=(const CalcAstItemVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MinMaxRange {
private:
    AzMinMaxRange inner_;

public:
    MinMaxRange(AzMinMaxRange inner) : inner_(inner) {}
    MinMaxRange(const MinMaxRange& other) : inner_(other.inner_) {}
    MinMaxRange& operator=(const MinMaxRange& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AspectRatioValue {
private:
    AzAspectRatioValue inner_;

public:
    AspectRatioValue(AzAspectRatioValue inner) : inner_(inner) {}
    AspectRatioValue(const AspectRatioValue& other) : inner_(other.inner_) {}
    AspectRatioValue& operator=(const AspectRatioValue& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class F32VecSlice {
private:
    AzF32VecSlice inner_;

public:
    F32VecSlice(AzF32VecSlice inner) : inner_(inner) {}
    F32VecSlice(const F32VecSlice& other) : inner_(other.inner_) {}
    F32VecSlice& operator=(const F32VecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class EmptyStruct {
private:
    AzEmptyStruct inner_;

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

    static EmptyStruct create();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class U32VecSlice {
private:
    AzU32VecSlice inner_;

public:
    U32VecSlice(AzU32VecSlice inner) : inner_(inner) {}
    U32VecSlice(const U32VecSlice& other) : inner_(other.inner_) {}
    U32VecSlice& operator=(const U32VecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DynamicSelectorVecSlice {
private:
    AzDynamicSelectorVecSlice inner_;

public:
    DynamicSelectorVecSlice(AzDynamicSelectorVecSlice inner) : inner_(inner) {}
    DynamicSelectorVecSlice(const DynamicSelectorVecSlice& other) : inner_(other.inner_) {}
    DynamicSelectorVecSlice& operator=(const DynamicSelectorVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class U8VecSlice {
private:
    AzU8VecSlice inner_;

public:
    U8VecSlice(AzU8VecSlice inner) : inner_(inner) {}
    U8VecSlice(const U8VecSlice& other) : inner_(other.inner_) {}
    U8VecSlice& operator=(const U8VecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MapTileId {
private:
    AzMapTileId inner_;

public:
    MapTileId(AzMapTileId inner) : inner_(inner) {}
    MapTileId(const MapTileId& other) : inner_(other.inner_) {}
    MapTileId& operator=(const MapTileId& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MapViewport {
private:
    AzMapViewport inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CheckBoxState {
public:
    struct Proxy { AzCheckBoxState inner; Proxy(AzCheckBoxState p) : inner(p) {} };

private:
    mutable AzCheckBoxState inner_;

public:
    explicit CheckBoxState(AzCheckBoxState inner) : inner_(inner) {}
    CheckBoxState(const CheckBoxState& other) : inner_(other.inner_) { memset(const_cast<AzCheckBoxState*>(&other.inner_), 0, sizeof(other.inner_)); }
    CheckBoxState& operator=(const CheckBoxState& other) {
        AzCheckBoxState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCheckBoxState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CheckBoxState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CheckBoxState& operator=(Proxy p) {
        AzCheckBoxState_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~CheckBoxState() { AzCheckBoxState_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NumberInputState {
public:
    struct Proxy { AzNumberInputState inner; Proxy(AzNumberInputState p) : inner(p) {} };

private:
    mutable AzNumberInputState inner_;

public:
    explicit NumberInputState(AzNumberInputState inner) : inner_(inner) {}
    NumberInputState(const NumberInputState& other) : inner_(other.inner_) { memset(const_cast<AzNumberInputState*>(&other.inner_), 0, sizeof(other.inner_)); }
    NumberInputState& operator=(const NumberInputState& other) {
        AzNumberInputState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNumberInputState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NumberInputState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NumberInputState& operator=(Proxy p) {
        AzNumberInputState_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~NumberInputState() { AzNumberInputState_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ProgressBarState {
public:
    struct Proxy { AzProgressBarState inner; Proxy(AzProgressBarState p) : inner(p) {} };

private:
    mutable AzProgressBarState inner_;

public:
    explicit ProgressBarState(AzProgressBarState inner) : inner_(inner) {}
    ProgressBarState(const ProgressBarState& other) : inner_(other.inner_) { memset(const_cast<AzProgressBarState*>(&other.inner_), 0, sizeof(other.inner_)); }
    ProgressBarState& operator=(const ProgressBarState& other) {
        AzProgressBarState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzProgressBarState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ProgressBarState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ProgressBarState& operator=(Proxy p) {
        AzProgressBarState_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TabHeaderState {
private:
    AzTabHeaderState inner_;

public:
    TabHeaderState(AzTabHeaderState inner) : inner_(inner) {}
    TabHeaderState(const TabHeaderState& other) : inner_(other.inner_) {}
    TabHeaderState& operator=(const TabHeaderState& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ListViewRowVecSlice {
private:
    AzListViewRowVecSlice inner_;

public:
    ListViewRowVecSlice(AzListViewRowVecSlice inner) : inner_(inner) {}
    ListViewRowVecSlice(const ListViewRowVecSlice& other) : inner_(other.inner_) {}
    ListViewRowVecSlice& operator=(const ListViewRowVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TitlebarButtons {
private:
    AzTitlebarButtons inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RibbonSectionVecSlice {
private:
    AzRibbonSectionVecSlice inner_;

public:
    RibbonSectionVecSlice(AzRibbonSectionVecSlice inner) : inner_(inner) {}
    RibbonSectionVecSlice(const RibbonSectionVecSlice& other) : inner_(other.inner_) {}
    RibbonSectionVecSlice& operator=(const RibbonSectionVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RibbonTabVecSlice {
private:
    AzRibbonTabVecSlice inner_;

public:
    RibbonTabVecSlice(AzRibbonTabVecSlice inner) : inner_(inner) {}
    RibbonTabVecSlice(const RibbonTabVecSlice& other) : inner_(other.inner_) {}
    RibbonTabVecSlice& operator=(const RibbonTabVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TreeViewNodeVecSlice {
private:
    AzTreeViewNodeVecSlice inner_;

public:
    TreeViewNodeVecSlice(AzTreeViewNodeVecSlice inner) : inner_(inner) {}
    TreeViewNodeVecSlice(const TreeViewNodeVecSlice& other) : inner_(other.inner_) {}
    TreeViewNodeVecSlice& operator=(const TreeViewNodeVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MapLatLon {
private:
    AzMapLatLon inner_;

public:
    MapLatLon(AzMapLatLon inner) : inner_(inner) {}
    MapLatLon(const MapLatLon& other) : inner_(other.inner_) {}
    MapLatLon& operator=(const MapLatLon& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GlVoidPtrConst {
public:
    struct Proxy { AzGlVoidPtrConst inner; Proxy(AzGlVoidPtrConst p) : inner(p) {} };

private:
    mutable AzGlVoidPtrConst inner_;

public:
    explicit GlVoidPtrConst(AzGlVoidPtrConst inner) : inner_(inner) {}
    GlVoidPtrConst(const GlVoidPtrConst& other) : inner_(other.inner_) { memset(const_cast<AzGlVoidPtrConst*>(&other.inner_), 0, sizeof(other.inner_)); }
    GlVoidPtrConst& operator=(const GlVoidPtrConst& other) {
        AzGlVoidPtrConst_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGlVoidPtrConst*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GlVoidPtrConst(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GlVoidPtrConst& operator=(Proxy p) {
        AzGlVoidPtrConst_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GlVoidPtrMut {
public:
    struct Proxy { AzGlVoidPtrMut inner; Proxy(AzGlVoidPtrMut p) : inner(p) {} };

private:
    mutable AzGlVoidPtrMut inner_;

public:
    explicit GlVoidPtrMut(AzGlVoidPtrMut inner) : inner_(inner) {}
    GlVoidPtrMut(const GlVoidPtrMut& other) : inner_(other.inner_) { memset(const_cast<AzGlVoidPtrMut*>(&other.inner_), 0, sizeof(other.inner_)); }
    GlVoidPtrMut& operator=(const GlVoidPtrMut& other) {
        AzGlVoidPtrMut_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGlVoidPtrMut*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GlVoidPtrMut(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GlVoidPtrMut& operator=(Proxy p) {
        AzGlVoidPtrMut_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextureFlags {
private:
    AzTextureFlags inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GLsyncPtr {
public:
    struct Proxy { AzGLsyncPtr inner; Proxy(AzGLsyncPtr p) : inner(p) {} };

private:
    mutable AzGLsyncPtr inner_;

public:
    explicit GLsyncPtr(AzGLsyncPtr inner) : inner_(inner) {}
    GLsyncPtr(const GLsyncPtr& other) : inner_(other.inner_) { memset(const_cast<AzGLsyncPtr*>(&other.inner_), 0, sizeof(other.inner_)); }
    GLsyncPtr& operator=(const GLsyncPtr& other) {
        AzGLsyncPtr_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGLsyncPtr*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GLsyncPtr(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GLsyncPtr& operator=(Proxy p) {
        AzGLsyncPtr_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgVertex {
private:
    AzSvgVertex inner_;

public:
    SvgVertex(AzSvgVertex inner) : inner_(inner) {}
    SvgVertex(const SvgVertex& other) : inner_(other.inner_) {}
    SvgVertex& operator=(const SvgVertex& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgVertexVecSlice {
private:
    AzSvgVertexVecSlice inner_;

public:
    SvgVertexVecSlice(AzSvgVertexVecSlice inner) : inner_(inner) {}
    SvgVertexVecSlice(const SvgVertexVecSlice& other) : inner_(other.inner_) {}
    SvgVertexVecSlice& operator=(const SvgVertexVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DebugMessageVecSlice {
private:
    AzDebugMessageVecSlice inner_;

public:
    DebugMessageVecSlice(AzDebugMessageVecSlice inner) : inner_(inner) {}
    DebugMessageVecSlice(const DebugMessageVecSlice& other) : inner_(other.inner_) {}
    DebugMessageVecSlice& operator=(const DebugMessageVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ImageRef {
public:
    struct Proxy { AzImageRef inner; Proxy(AzImageRef p) : inner(p) {} };

private:
    mutable AzImageRef inner_;

public:
    explicit ImageRef(AzImageRef inner) : inner_(inner) {}
    ImageRef(const ImageRef& other) : inner_(other.inner_) { memset(const_cast<AzImageRef*>(&other.inner_), 0, sizeof(other.inner_)); }
    ImageRef& operator=(const ImageRef& other) {
        AzImageRef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzImageRef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ImageRef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ImageRef& operator=(Proxy p) {
        AzImageRef_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ImageRef() { AzImageRef_delete(&inner_); }

    static ImageRef gl_texture(Texture texture);
    static ImageRef callback(CoreRenderImageCallback callback, RefAny data);
    static ImageRef new_gltexture(Texture texture);
    static ImageRef null_image(size_t width, size_t height, AzRawImageFormat format, U8VecRef tag);
    static OptionImageRef raw_image(RawImage data);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ImageDescriptorFlags {
private:
    AzImageDescriptorFlags inner_;

public:
    ImageDescriptorFlags(AzImageDescriptorFlags inner) : inner_(inner) {}
    ImageDescriptorFlags(const ImageDescriptorFlags& other) : inner_(other.inner_) {}
    ImageDescriptorFlags& operator=(const ImageDescriptorFlags& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ImageRefHash {
private:
    AzImageRefHash inner_;

public:
    ImageRefHash(AzImageRefHash inner) : inner_(inner) {}
    ImageRefHash(const ImageRefHash& other) : inner_(other.inner_) {}
    ImageRefHash& operator=(const ImageRefHash& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RouteVecSlice {
private:
    AzRouteVecSlice inner_;

public:
    RouteVecSlice(AzRouteVecSlice inner) : inner_(inner) {}
    RouteVecSlice(const RouteVecSlice& other) : inner_(other.inner_) {}
    RouteVecSlice& operator=(const RouteVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VideoEncoder {
public:
    struct Proxy { AzVideoEncoder inner; Proxy(AzVideoEncoder p) : inner(p) {} };

private:
    mutable AzVideoEncoder inner_;

public:
    explicit VideoEncoder(AzVideoEncoder inner) : inner_(inner) {}
    VideoEncoder(const VideoEncoder& other) : inner_(other.inner_) { memset(const_cast<AzVideoEncoder*>(&other.inner_), 0, sizeof(other.inner_)); }
    VideoEncoder& operator=(const VideoEncoder& other) {
        AzVideoEncoder_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVideoEncoder*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VideoEncoder(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VideoEncoder& operator=(Proxy p) {
        AzVideoEncoder_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~VideoEncoder() { AzVideoEncoder_delete(&inner_); }

    static VideoEncoder open(uint32_t width, uint32_t height, bool h265, uint32_t bitrate_kbps);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VideoDecoder {
public:
    struct Proxy { AzVideoDecoder inner; Proxy(AzVideoDecoder p) : inner(p) {} };

private:
    mutable AzVideoDecoder inner_;

public:
    explicit VideoDecoder(AzVideoDecoder inner) : inner_(inner) {}
    VideoDecoder(const VideoDecoder& other) : inner_(other.inner_) { memset(const_cast<AzVideoDecoder*>(&other.inner_), 0, sizeof(other.inner_)); }
    VideoDecoder& operator=(const VideoDecoder& other) {
        AzVideoDecoder_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVideoDecoder*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VideoDecoder(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VideoDecoder& operator=(Proxy p) {
        AzVideoDecoder_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~VideoDecoder() { AzVideoDecoder_delete(&inner_); }

    static VideoDecoder open(bool h265);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Panose {
private:
    AzPanose inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LoadedFontVecSlice {
private:
    AzLoadedFontVecSlice inner_;

public:
    LoadedFontVecSlice(AzLoadedFontVecSlice inner) : inner_(inner) {}
    LoadedFontVecSlice(const LoadedFontVecSlice& other) : inner_(other.inner_) {}
    LoadedFontVecSlice& operator=(const LoadedFontVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Svg {
public:
    struct Proxy { AzSvg inner; Proxy(AzSvg p) : inner(p) {} };

private:
    mutable AzSvg inner_;

public:
    explicit Svg(AzSvg inner) : inner_(inner) {}
    Svg(const Svg& other) : inner_(other.inner_) { memset(const_cast<AzSvg*>(&other.inner_), 0, sizeof(other.inner_)); }
    Svg& operator=(const Svg& other) {
        AzSvg_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSvg*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Svg(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Svg& operator=(Proxy p) {
        AzSvg_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Svg() { AzSvg_delete(&inner_); }
    static ResultSvgSvgParseError from_string(String svg_string, SvgParseOptions parse_options);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssPathSelectorVecSlice {
private:
    AzCssPathSelectorVecSlice inner_;

public:
    CssPathSelectorVecSlice(AzCssPathSelectorVecSlice inner) : inner_(inner) {}
    CssPathSelectorVecSlice(const CssPathSelectorVecSlice& other) : inner_(other.inner_) {}
    CssPathSelectorVecSlice& operator=(const CssPathSelectorVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgDashPattern {
private:
    AzSvgDashPattern inner_;

public:
    SvgDashPattern(AzSvgDashPattern inner) : inner_(inner) {}
    SvgDashPattern(const SvgDashPattern& other) : inner_(other.inner_) {}
    SvgDashPattern& operator=(const SvgDashPattern& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgVector {
private:
    AzSvgVector inner_;

public:
    SvgVector(AzSvgVector inner) : inner_(inner) {}
    SvgVector(const SvgVector& other) : inner_(other.inner_) {}
    SvgVector& operator=(const SvgVector& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgRect {
private:
    AzSvgRect inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgPoint {
private:
    AzSvgPoint inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgPathVecSlice {
private:
    AzSvgPathVecSlice inner_;

public:
    SvgPathVecSlice(AzSvgPathVecSlice inner) : inner_(inner) {}
    SvgPathVecSlice(const SvgPathVecSlice& other) : inner_(other.inner_) {}
    SvgPathVecSlice& operator=(const SvgPathVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgPathElementVecSlice {
private:
    AzSvgPathElementVecSlice inner_;

public:
    SvgPathElementVecSlice(AzSvgPathElementVecSlice inner) : inner_(inner) {}
    SvgPathElementVecSlice(const SvgPathElementVecSlice& other) : inner_(other.inner_) {}
    SvgPathElementVecSlice& operator=(const SvgPathElementVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SystemTickDiff {
private:
    AzSystemTickDiff inner_;

public:
    SystemTickDiff(AzSystemTickDiff inner) : inner_(inner) {}
    SystemTickDiff(const SystemTickDiff& other) : inner_(other.inner_) {}
    SystemTickDiff& operator=(const SystemTickDiff& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SystemTick {
private:
    AzSystemTick inner_;

public:
    SystemTick(AzSystemTick inner) : inner_(inner) {}
    SystemTick(const SystemTick& other) : inner_(other.inner_) {}
    SystemTick& operator=(const SystemTick& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SystemTimeDiff {
private:
    AzSystemTimeDiff inner_;

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

    static SystemTimeDiff from_secs(uint64_t secs);
    static SystemTimeDiff from_millis(uint64_t millis);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssDuration {
private:
    AzCssDuration inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class IcuTime {
private:
    AzIcuTime inner_;

public:
    IcuTime(AzIcuTime inner) : inner_(inner) {}
    IcuTime(const IcuTime& other) : inner_(other.inner_) {}
    IcuTime& operator=(const IcuTime& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StringPairVecSlice {
private:
    AzStringPairVecSlice inner_;

public:
    StringPairVecSlice(AzStringPairVecSlice inner) : inner_(inner) {}
    StringPairVecSlice(const StringPairVecSlice& other) : inner_(other.inner_) {}
    StringPairVecSlice& operator=(const StringPairVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StringVecSlice {
private:
    AzStringVecSlice inner_;

public:
    StringVecSlice(AzStringVecSlice inner) : inner_(inner) {}
    StringVecSlice(const StringVecSlice& other) : inner_(other.inner_) {}
    StringVecSlice& operator=(const StringVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GLbooleanVecRefMut {
public:
    struct Proxy { AzGLbooleanVecRefMut inner; Proxy(AzGLbooleanVecRefMut p) : inner(p) {} };

private:
    mutable AzGLbooleanVecRefMut inner_;

public:
    explicit GLbooleanVecRefMut(AzGLbooleanVecRefMut inner) : inner_(inner) {}
    GLbooleanVecRefMut(const GLbooleanVecRefMut& other) : inner_(other.inner_) { memset(const_cast<AzGLbooleanVecRefMut*>(&other.inner_), 0, sizeof(other.inner_)); }
    GLbooleanVecRefMut& operator=(const GLbooleanVecRefMut& other) {
        AzGLbooleanVecRefMut_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGLbooleanVecRefMut*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GLbooleanVecRefMut(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GLbooleanVecRefMut& operator=(Proxy p) {
        AzGLbooleanVecRefMut_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GLfloatVecRefMut {
public:
    struct Proxy { AzGLfloatVecRefMut inner; Proxy(AzGLfloatVecRefMut p) : inner(p) {} };

private:
    mutable AzGLfloatVecRefMut inner_;

public:
    explicit GLfloatVecRefMut(AzGLfloatVecRefMut inner) : inner_(inner) {}
    GLfloatVecRefMut(const GLfloatVecRefMut& other) : inner_(other.inner_) { memset(const_cast<AzGLfloatVecRefMut*>(&other.inner_), 0, sizeof(other.inner_)); }
    GLfloatVecRefMut& operator=(const GLfloatVecRefMut& other) {
        AzGLfloatVecRefMut_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGLfloatVecRefMut*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GLfloatVecRefMut(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GLfloatVecRefMut& operator=(Proxy p) {
        AzGLfloatVecRefMut_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class U8VecRefMut {
public:
    struct Proxy { AzU8VecRefMut inner; Proxy(AzU8VecRefMut p) : inner(p) {} };

private:
    mutable AzU8VecRefMut inner_;

public:
    explicit U8VecRefMut(AzU8VecRefMut inner) : inner_(inner) {}
    U8VecRefMut(const U8VecRefMut& other) : inner_(other.inner_) { memset(const_cast<AzU8VecRefMut*>(&other.inner_), 0, sizeof(other.inner_)); }
    U8VecRefMut& operator=(const U8VecRefMut& other) {
        AzU8VecRefMut_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzU8VecRefMut*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    U8VecRefMut(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    U8VecRefMut& operator=(Proxy p) {
        AzU8VecRefMut_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TessellatedSvgNodeVecRef {
public:
    struct Proxy { AzTessellatedSvgNodeVecRef inner; Proxy(AzTessellatedSvgNodeVecRef p) : inner(p) {} };

private:
    mutable AzTessellatedSvgNodeVecRef inner_;

public:
    explicit TessellatedSvgNodeVecRef(AzTessellatedSvgNodeVecRef inner) : inner_(inner) {}
    TessellatedSvgNodeVecRef(const TessellatedSvgNodeVecRef& other) : inner_(other.inner_) { memset(const_cast<AzTessellatedSvgNodeVecRef*>(&other.inner_), 0, sizeof(other.inner_)); }
    TessellatedSvgNodeVecRef& operator=(const TessellatedSvgNodeVecRef& other) {
        AzTessellatedSvgNodeVecRef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTessellatedSvgNodeVecRef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TessellatedSvgNodeVecRef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TessellatedSvgNodeVecRef& operator=(Proxy p) {
        AzTessellatedSvgNodeVecRef_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class F32VecRef {
public:
    struct Proxy { AzF32VecRef inner; Proxy(AzF32VecRef p) : inner(p) {} };

private:
    mutable AzF32VecRef inner_;

public:
    explicit F32VecRef(AzF32VecRef inner) : inner_(inner) {}
    F32VecRef(const F32VecRef& other) : inner_(other.inner_) { memset(const_cast<AzF32VecRef*>(&other.inner_), 0, sizeof(other.inner_)); }
    F32VecRef& operator=(const F32VecRef& other) {
        AzF32VecRef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzF32VecRef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    F32VecRef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    F32VecRef& operator=(Proxy p) {
        AzF32VecRef_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GLuintVecRef {
public:
    struct Proxy { AzGLuintVecRef inner; Proxy(AzGLuintVecRef p) : inner(p) {} };

private:
    mutable AzGLuintVecRef inner_;

public:
    explicit GLuintVecRef(AzGLuintVecRef inner) : inner_(inner) {}
    GLuintVecRef(const GLuintVecRef& other) : inner_(other.inner_) { memset(const_cast<AzGLuintVecRef*>(&other.inner_), 0, sizeof(other.inner_)); }
    GLuintVecRef& operator=(const GLuintVecRef& other) {
        AzGLuintVecRef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGLuintVecRef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GLuintVecRef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GLuintVecRef& operator=(Proxy p) {
        AzGLuintVecRef_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class I32VecRef {
public:
    struct Proxy { AzI32VecRef inner; Proxy(AzI32VecRef p) : inner(p) {} };

private:
    mutable AzI32VecRef inner_;

public:
    explicit I32VecRef(AzI32VecRef inner) : inner_(inner) {}
    I32VecRef(const I32VecRef& other) : inner_(other.inner_) { memset(const_cast<AzI32VecRef*>(&other.inner_), 0, sizeof(other.inner_)); }
    I32VecRef& operator=(const I32VecRef& other) {
        AzI32VecRef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzI32VecRef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    I32VecRef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    I32VecRef& operator=(Proxy p) {
        AzI32VecRef_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class U8VecRef {
public:
    struct Proxy { AzU8VecRef inner; Proxy(AzU8VecRef p) : inner(p) {} };

private:
    mutable AzU8VecRef inner_;

public:
    explicit U8VecRef(AzU8VecRef inner) : inner_(inner) {}
    U8VecRef(const U8VecRef& other) : inner_(other.inner_) { memset(const_cast<AzU8VecRef*>(&other.inner_), 0, sizeof(other.inner_)); }
    U8VecRef& operator=(const U8VecRef& other) {
        AzU8VecRef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzU8VecRef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    U8VecRef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    U8VecRef& operator=(Proxy p) {
        AzU8VecRef_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GLintVecRefMut {
public:
    struct Proxy { AzGLintVecRefMut inner; Proxy(AzGLintVecRefMut p) : inner(p) {} };

private:
    mutable AzGLintVecRefMut inner_;

public:
    explicit GLintVecRefMut(AzGLintVecRefMut inner) : inner_(inner) {}
    GLintVecRefMut(const GLintVecRefMut& other) : inner_(other.inner_) { memset(const_cast<AzGLintVecRefMut*>(&other.inner_), 0, sizeof(other.inner_)); }
    GLintVecRefMut& operator=(const GLintVecRefMut& other) {
        AzGLintVecRefMut_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGLintVecRefMut*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GLintVecRefMut(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GLintVecRefMut& operator=(Proxy p) {
        AzGLintVecRefMut_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GLenumVecRef {
public:
    struct Proxy { AzGLenumVecRef inner; Proxy(AzGLenumVecRef p) : inner(p) {} };

private:
    mutable AzGLenumVecRef inner_;

public:
    explicit GLenumVecRef(AzGLenumVecRef inner) : inner_(inner) {}
    GLenumVecRef(const GLenumVecRef& other) : inner_(other.inner_) { memset(const_cast<AzGLenumVecRef*>(&other.inner_), 0, sizeof(other.inner_)); }
    GLenumVecRef& operator=(const GLenumVecRef& other) {
        AzGLenumVecRef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGLenumVecRef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GLenumVecRef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GLenumVecRef& operator=(Proxy p) {
        AzGLenumVecRef_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GLint64VecRefMut {
public:
    struct Proxy { AzGLint64VecRefMut inner; Proxy(AzGLint64VecRefMut p) : inner(p) {} };

private:
    mutable AzGLint64VecRefMut inner_;

public:
    explicit GLint64VecRefMut(AzGLint64VecRefMut inner) : inner_(inner) {}
    GLint64VecRefMut(const GLint64VecRefMut& other) : inner_(other.inner_) { memset(const_cast<AzGLint64VecRefMut*>(&other.inner_), 0, sizeof(other.inner_)); }
    GLint64VecRefMut& operator=(const GLint64VecRefMut& other) {
        AzGLint64VecRefMut_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGLint64VecRefMut*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GLint64VecRefMut(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GLint64VecRefMut& operator=(Proxy p) {
        AzGLint64VecRefMut_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RefstrVecRef {
public:
    struct Proxy { AzRefstrVecRef inner; Proxy(AzRefstrVecRef p) : inner(p) {} };

private:
    mutable AzRefstrVecRef inner_;

public:
    explicit RefstrVecRef(AzRefstrVecRef inner) : inner_(inner) {}
    RefstrVecRef(const RefstrVecRef& other) : inner_(other.inner_) { memset(const_cast<AzRefstrVecRef*>(&other.inner_), 0, sizeof(other.inner_)); }
    RefstrVecRef& operator=(const RefstrVecRef& other) {
        AzRefstrVecRef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRefstrVecRef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RefstrVecRef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RefstrVecRef& operator=(Proxy p) {
        AzRefstrVecRef_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class HttpResponseTooLargeError {
public:
    struct Proxy { AzHttpResponseTooLargeError inner; Proxy(AzHttpResponseTooLargeError p) : inner(p) {} };

private:
    mutable AzHttpResponseTooLargeError inner_;

public:
    explicit HttpResponseTooLargeError(AzHttpResponseTooLargeError inner) : inner_(inner) {}
    HttpResponseTooLargeError(const HttpResponseTooLargeError& other) : inner_(other.inner_) { memset(const_cast<AzHttpResponseTooLargeError*>(&other.inner_), 0, sizeof(other.inner_)); }
    HttpResponseTooLargeError& operator=(const HttpResponseTooLargeError& other) {
        AzHttpResponseTooLargeError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzHttpResponseTooLargeError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    HttpResponseTooLargeError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    HttpResponseTooLargeError& operator=(Proxy p) {
        AzHttpResponseTooLargeError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ErrorLocation {
private:
    AzErrorLocation inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssSyntaxErrorPos {
private:
    AzCssSyntaxErrorPos inner_;

public:
    CssSyntaxErrorPos(AzCssSyntaxErrorPos inner) : inner_(inner) {}
    CssSyntaxErrorPos(const CssSyntaxErrorPos& other) : inner_(other.inner_) {}
    CssSyntaxErrorPos& operator=(const CssSyntaxErrorPos& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class App {
public:
    struct Proxy { AzApp inner; Proxy(AzApp p) : inner(p) {} };

private:
    mutable AzApp inner_;

public:
    explicit App(AzApp inner) : inner_(inner) {}
    App(const App& other) : inner_(other.inner_) { memset(const_cast<AzApp*>(&other.inner_), 0, sizeof(other.inner_)); }
    App& operator=(const App& other) {
        AzApp_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzApp*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    App(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    App& operator=(Proxy p) {
        AzApp_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~App() { AzApp_delete(&inner_); }

    static App create(RefAny initial_data, AppConfig app_config);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TimerId {
private:
    AzTimerId inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Thread {
public:
    struct Proxy { AzThread inner; Proxy(AzThread p) : inner(p) {} };

private:
    mutable AzThread inner_;

public:
    explicit Thread(AzThread inner) : inner_(inner) {}
    Thread(const Thread& other) : inner_(other.inner_) { memset(const_cast<AzThread*>(&other.inner_), 0, sizeof(other.inner_)); }
    Thread& operator=(const Thread& other) {
        AzThread_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzThread*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Thread(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Thread& operator=(Proxy p) {
        AzThread_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Thread() { AzThread_delete(&inner_); }

    static Thread create(RefAny thread_initialize_data, RefAny writeback_data, AzThreadCallbackType callback);
    static EmptyStruct sleep_ms(uint64_t milliseconds);
    static EmptyStruct sleep_us(uint64_t microseconds);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ThreadId {
private:
    AzThreadId inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TimerIdVecSlice {
private:
    AzTimerIdVecSlice inner_;

public:
    TimerIdVecSlice(AzTimerIdVecSlice inner) : inner_(inner) {}
    TimerIdVecSlice(const TimerIdVecSlice& other) : inner_(other.inner_) {}
    TimerIdVecSlice& operator=(const TimerIdVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ThreadIdVecSlice {
private:
    AzThreadIdVecSlice inner_;

public:
    ThreadIdVecSlice(AzThreadIdVecSlice inner) : inner_(inner) {}
    ThreadIdVecSlice(const ThreadIdVecSlice& other) : inner_(other.inner_) {}
    ThreadIdVecSlice& operator=(const ThreadIdVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ExternalResourceVecSlice {
private:
    AzExternalResourceVecSlice inner_;

public:
    ExternalResourceVecSlice(AzExternalResourceVecSlice inner) : inner_(inner) {}
    ExternalResourceVecSlice(const ExternalResourceVecSlice& other) : inner_(other.inner_) {}
    ExternalResourceVecSlice& operator=(const ExternalResourceVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DirEntryVecSlice {
private:
    AzDirEntryVecSlice inner_;

public:
    DirEntryVecSlice(AzDirEntryVecSlice inner) : inner_(inner) {}
    DirEntryVecSlice(const DirEntryVecSlice& other) : inner_(other.inner_) {}
    DirEntryVecSlice& operator=(const DirEntryVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FmtArgVecSlice {
private:
    AzFmtArgVecSlice inner_;

public:
    FmtArgVecSlice(AzFmtArgVecSlice inner) : inner_(inner) {}
    FmtArgVecSlice(const FmtArgVecSlice& other) : inner_(other.inner_) {}
    FmtArgVecSlice& operator=(const FmtArgVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class JsonKeyValueVecSlice {
private:
    AzJsonKeyValueVecSlice inner_;

public:
    JsonKeyValueVecSlice(AzJsonKeyValueVecSlice inner) : inner_(inner) {}
    JsonKeyValueVecSlice(const JsonKeyValueVecSlice& other) : inner_(other.inner_) {}
    JsonKeyValueVecSlice& operator=(const JsonKeyValueVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class JsonVecSlice {
private:
    AzJsonVecSlice inner_;

public:
    JsonVecSlice(AzJsonVecSlice inner) : inner_(inner) {}
    JsonVecSlice(const JsonVecSlice& other) : inner_(other.inner_) {}
    JsonVecSlice& operator=(const JsonVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Db {
public:
    struct Proxy { AzDb inner; Proxy(AzDb p) : inner(p) {} };

private:
    mutable AzDb inner_;

public:
    explicit Db(AzDb inner) : inner_(inner) {}
    Db(const Db& other) : inner_(other.inner_) { memset(const_cast<AzDb*>(&other.inner_), 0, sizeof(other.inner_)); }
    Db& operator=(const Db& other) {
        AzDb_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDb*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Db(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Db& operator=(Proxy p) {
        AzDb_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Db() { AzDb_delete(&inner_); }

    static Db open(String path);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Pdf {
private:
    AzPdf inner_;

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

    static Pdf new_();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GamepadId {
private:
    AzGamepadId inner_;

public:
    GamepadId(AzGamepadId inner) : inner_(inner) {}
    GamepadId(const GamepadId& other) : inner_(other.inner_) {}
    GamepadId& operator=(const GamepadId& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WacomPadState {
private:
    AzWacomPadState inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AudioConfig {
private:
    AzAudioConfig inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Udp {
public:
    struct Proxy { AzUdp inner; Proxy(AzUdp p) : inner(p) {} };

private:
    mutable AzUdp inner_;

public:
    explicit Udp(AzUdp inner) : inner_(inner) {}
    Udp(const Udp& other) : inner_(other.inner_) { memset(const_cast<AzUdp*>(&other.inner_), 0, sizeof(other.inner_)); }
    Udp& operator=(const Udp& other) {
        AzUdp_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzUdp*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Udp(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Udp& operator=(Proxy p) {
        AzUdp_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Udp() { AzUdp_delete(&inner_); }

    static Udp bind(String local_addr);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DbValueVecSlice {
private:
    AzDbValueVecSlice inner_;

public:
    DbValueVecSlice(AzDbValueVecSlice inner) : inner_(inner) {}
    DbValueVecSlice(const DbValueVecSlice& other) : inner_(other.inner_) {}
    DbValueVecSlice& operator=(const DbValueVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class IcuDate {
private:
    AzIcuDate inner_;

public:
    IcuDate(AzIcuDate inner) : inner_(inner) {}
    IcuDate(const IcuDate& other) : inner_(other.inner_) {}
    IcuDate& operator=(const IcuDate& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class IcuLocalizerHandle {
public:
    struct Proxy { AzIcuLocalizerHandle inner; Proxy(AzIcuLocalizerHandle p) : inner(p) {} };

private:
    mutable AzIcuLocalizerHandle inner_;

public:
    explicit IcuLocalizerHandle(AzIcuLocalizerHandle inner) : inner_(inner) {}
    IcuLocalizerHandle(const IcuLocalizerHandle& other) : inner_(other.inner_) { memset(const_cast<AzIcuLocalizerHandle*>(&other.inner_), 0, sizeof(other.inner_)); }
    IcuLocalizerHandle& operator=(const IcuLocalizerHandle& other) {
        AzIcuLocalizerHandle_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzIcuLocalizerHandle*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    IcuLocalizerHandle(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    IcuLocalizerHandle& operator=(Proxy p) {
        AzIcuLocalizerHandle_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~IcuLocalizerHandle() { AzIcuLocalizerHandle_delete(&inner_); }

    static IcuLocalizerHandle from_system_language(String language);
    static IcuLocalizerHandle create(String default_locale);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FluentLocalizerHandle {
public:
    struct Proxy { AzFluentLocalizerHandle inner; Proxy(AzFluentLocalizerHandle p) : inner(p) {} };

private:
    mutable AzFluentLocalizerHandle inner_;

public:
    explicit FluentLocalizerHandle(AzFluentLocalizerHandle inner) : inner_(inner) {}
    FluentLocalizerHandle(const FluentLocalizerHandle& other) : inner_(other.inner_) { memset(const_cast<AzFluentLocalizerHandle*>(&other.inner_), 0, sizeof(other.inner_)); }
    FluentLocalizerHandle& operator=(const FluentLocalizerHandle& other) {
        AzFluentLocalizerHandle_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFluentLocalizerHandle*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FluentLocalizerHandle(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FluentLocalizerHandle& operator=(Proxy p) {
        AzFluentLocalizerHandle_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~FluentLocalizerHandle() { AzFluentLocalizerHandle_delete(&inner_); }

    static FluentLocalizerHandle create(String default_locale);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentDataFieldVecSlice {
private:
    AzComponentDataFieldVecSlice inner_;

public:
    ComponentDataFieldVecSlice(AzComponentDataFieldVecSlice inner) : inner_(inner) {}
    ComponentDataFieldVecSlice(const ComponentDataFieldVecSlice& other) : inner_(other.inner_) {}
    ComponentDataFieldVecSlice& operator=(const ComponentDataFieldVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentLibraryVecSlice {
private:
    AzComponentLibraryVecSlice inner_;

public:
    ComponentLibraryVecSlice(AzComponentLibraryVecSlice inner) : inner_(inner) {}
    ComponentLibraryVecSlice(const ComponentLibraryVecSlice& other) : inner_(other.inner_) {}
    ComponentLibraryVecSlice& operator=(const ComponentLibraryVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentDefVecSlice {
private:
    AzComponentDefVecSlice inner_;

public:
    ComponentDefVecSlice(AzComponentDefVecSlice inner) : inner_(inner) {}
    ComponentDefVecSlice(const ComponentDefVecSlice& other) : inner_(other.inner_) {}
    ComponentDefVecSlice& operator=(const ComponentDefVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentDataModelVecSlice {
private:
    AzComponentDataModelVecSlice inner_;

public:
    ComponentDataModelVecSlice(AzComponentDataModelVecSlice inner) : inner_(inner) {}
    ComponentDataModelVecSlice(const ComponentDataModelVecSlice& other) : inner_(other.inner_) {}
    ComponentDataModelVecSlice& operator=(const ComponentDataModelVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentEnumVariantVecSlice {
private:
    AzComponentEnumVariantVecSlice inner_;

public:
    ComponentEnumVariantVecSlice(AzComponentEnumVariantVecSlice inner) : inner_(inner) {}
    ComponentEnumVariantVecSlice(const ComponentEnumVariantVecSlice& other) : inner_(other.inner_) {}
    ComponentEnumVariantVecSlice& operator=(const ComponentEnumVariantVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentFieldTypeBox {
public:
    struct Proxy { AzComponentFieldTypeBox inner; Proxy(AzComponentFieldTypeBox p) : inner(p) {} };

private:
    mutable AzComponentFieldTypeBox inner_;

public:
    explicit ComponentFieldTypeBox(AzComponentFieldTypeBox inner) : inner_(inner) {}
    ComponentFieldTypeBox(const ComponentFieldTypeBox& other) : inner_(other.inner_) { memset(const_cast<AzComponentFieldTypeBox*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentFieldTypeBox& operator=(const ComponentFieldTypeBox& other) {
        AzComponentFieldTypeBox_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentFieldTypeBox*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentFieldTypeBox(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentFieldTypeBox& operator=(Proxy p) {
        AzComponentFieldTypeBox_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentEnumModelVecSlice {
private:
    AzComponentEnumModelVecSlice inner_;

public:
    ComponentEnumModelVecSlice(AzComponentEnumModelVecSlice inner) : inner_(inner) {}
    ComponentEnumModelVecSlice(const ComponentEnumModelVecSlice& other) : inner_(other.inner_) {}
    ComponentEnumModelVecSlice& operator=(const ComponentEnumModelVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentFieldOverrideVecSlice {
private:
    AzComponentFieldOverrideVecSlice inner_;

public:
    ComponentFieldOverrideVecSlice(AzComponentFieldOverrideVecSlice inner) : inner_(inner) {}
    ComponentFieldOverrideVecSlice(const ComponentFieldOverrideVecSlice& other) : inner_(other.inner_) {}
    ComponentFieldOverrideVecSlice& operator=(const ComponentFieldOverrideVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentCallbackArgVecSlice {
private:
    AzComponentCallbackArgVecSlice inner_;

public:
    ComponentCallbackArgVecSlice(AzComponentCallbackArgVecSlice inner) : inner_(inner) {}
    ComponentCallbackArgVecSlice(const ComponentCallbackArgVecSlice& other) : inner_(other.inner_) {}
    ComponentCallbackArgVecSlice& operator=(const ComponentCallbackArgVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DpiScaleFactor {
private:
    AzDpiScaleFactor inner_;

public:
    DpiScaleFactor(AzDpiScaleFactor inner) : inner_(inner) {}
    DpiScaleFactor(const DpiScaleFactor& other) : inner_(other.inner_) {}
    DpiScaleFactor& operator=(const DpiScaleFactor& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WindowFlags {
private:
    AzWindowFlags inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VideoMode {
private:
    AzVideoMode inner_;

public:
    VideoMode(AzVideoMode inner) : inner_(inner) {}
    VideoMode(const VideoMode& other) : inner_(other.inner_) {}
    VideoMode& operator=(const VideoMode& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextCursor {
private:
    AzTextCursor inner_;

public:
    TextCursor(AzTextCursor inner) : inner_(inner) {}
    TextCursor(const TextCursor& other) : inner_(other.inner_) {}
    TextCursor& operator=(const TextCursor& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class XWindowTypeVecSlice {
private:
    AzXWindowTypeVecSlice inner_;

public:
    XWindowTypeVecSlice(AzXWindowTypeVecSlice inner) : inner_(inner) {}
    XWindowTypeVecSlice(const XWindowTypeVecSlice& other) : inner_(other.inner_) {}
    XWindowTypeVecSlice& operator=(const XWindowTypeVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TouchPoint {
private:
    AzTouchPoint inner_;

public:
    TouchPoint(AzTouchPoint inner) : inner_(inner) {}
    TouchPoint(const TouchPoint& other) : inner_(other.inner_) {}
    TouchPoint& operator=(const TouchPoint& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DetectedPinch {
private:
    AzDetectedPinch inner_;

public:
    DetectedPinch(AzDetectedPinch inner) : inner_(inner) {}
    DetectedPinch(const DetectedPinch& other) : inner_(other.inner_) {}
    DetectedPinch& operator=(const DetectedPinch& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TimerCallbackReturn {
private:
    AzTimerCallbackReturn inner_;

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

    static TimerCallbackReturn create(AzUpdate should_update, AzTerminateTimer should_terminate);
    static TimerCallbackReturn continue_unchanged();
    static TimerCallbackReturn continue_and_refresh_dom();
    static TimerCallbackReturn terminate_unchanged();
    static TimerCallbackReturn terminate_and_refresh_dom();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RefAny {
public:
    struct Proxy { AzRefAny inner; Proxy(AzRefAny p) : inner(p) {} };

private:
    mutable AzRefAny inner_;

public:
    explicit RefAny(AzRefAny inner) : inner_(inner) {}
    RefAny(const RefAny& other) : inner_(other.inner_) { memset(const_cast<AzRefAny*>(&other.inner_), 0, sizeof(other.inner_)); }
    RefAny& operator=(const RefAny& other) {
        AzRefAny_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRefAny*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RefAny(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RefAny& operator=(Proxy p) {
        AzRefAny_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~RefAny() { AzRefAny_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class PenState {
private:
    AzPenState inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ScrollState {
private:
    AzScrollState inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DomNodeId {
private:
    AzDomNodeId inner_;

public:
    DomNodeId(AzDomNodeId inner) : inner_(inner) {}
    DomNodeId(const DomNodeId& other) : inner_(other.inner_) {}
    DomNodeId& operator=(const DomNodeId& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ParentWithNodeDepth {
private:
    AzParentWithNodeDepth inner_;

public:
    ParentWithNodeDepth(AzParentWithNodeDepth inner) : inner_(inner) {}
    ParentWithNodeDepth(const ParentWithNodeDepth& other) : inner_(other.inner_) {}
    ParentWithNodeDepth& operator=(const ParentWithNodeDepth& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SelectionColor {
private:
    AzSelectionColor inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VirtualKeyCodeVecSlice {
private:
    AzVirtualKeyCodeVecSlice inner_;

public:
    VirtualKeyCodeVecSlice(AzVirtualKeyCodeVecSlice inner) : inner_(inner) {}
    VirtualKeyCodeVecSlice(const VirtualKeyCodeVecSlice& other) : inner_(other.inner_) {}
    VirtualKeyCodeVecSlice& operator=(const VirtualKeyCodeVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AccessibilityStateVecSlice {
private:
    AzAccessibilityStateVecSlice inner_;

public:
    AccessibilityStateVecSlice(AzAccessibilityStateVecSlice inner) : inner_(inner) {}
    AccessibilityStateVecSlice(const AccessibilityStateVecSlice& other) : inner_(other.inner_) {}
    AccessibilityStateVecSlice& operator=(const AccessibilityStateVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ScanCodeVecSlice {
private:
    AzScanCodeVecSlice inner_;

public:
    ScanCodeVecSlice(AzScanCodeVecSlice inner) : inner_(inner) {}
    ScanCodeVecSlice(const ScanCodeVecSlice& other) : inner_(other.inner_) {}
    ScanCodeVecSlice& operator=(const ScanCodeVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class PixelValue {
private:
    AzPixelValue inner_;

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

    static PixelValue zero();
    static PixelValue px(float value);
    static PixelValue em(float value);
    static PixelValue rem(float value);
    static PixelValue pt(float value);
    static PixelValue percent(float value);
    static PixelValue from_metric(AzSizeMetric metric, float value);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleColorMatrix {
public:
    struct Proxy { AzStyleColorMatrix inner; Proxy(AzStyleColorMatrix p) : inner(p) {} };

private:
    mutable AzStyleColorMatrix inner_;

public:
    explicit StyleColorMatrix(AzStyleColorMatrix inner) : inner_(inner) {}
    StyleColorMatrix(const StyleColorMatrix& other) : inner_(other.inner_) { memset(const_cast<AzStyleColorMatrix*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyleColorMatrix& operator=(const StyleColorMatrix& other) {
        AzStyleColorMatrix_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyleColorMatrix*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyleColorMatrix(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyleColorMatrix& operator=(Proxy p) {
        AzStyleColorMatrix_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutFlexGrow {
private:
    AzLayoutFlexGrow inner_;

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

    static LayoutFlexGrow create(float value);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutFlexShrink {
private:
    AzLayoutFlexShrink inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class PercentageValue {
private:
    AzPercentageValue inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AngleValue {
private:
    AzAngleValue inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DirectionCorners {
private:
    AzDirectionCorners inner_;

public:
    DirectionCorners(AzDirectionCorners inner) : inner_(inner) {}
    DirectionCorners(const DirectionCorners& other) : inner_(other.inner_) {}
    DirectionCorners& operator=(const DirectionCorners& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBorderBottomColor {
private:
    AzStyleBorderBottomColor inner_;

public:
    StyleBorderBottomColor(AzStyleBorderBottomColor inner) : inner_(inner) {}
    StyleBorderBottomColor(const StyleBorderBottomColor& other) : inner_(other.inner_) {}
    StyleBorderBottomColor& operator=(const StyleBorderBottomColor& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBorderBottomStyle {
private:
    AzStyleBorderBottomStyle inner_;

public:
    StyleBorderBottomStyle(AzStyleBorderBottomStyle inner) : inner_(inner) {}
    StyleBorderBottomStyle(const StyleBorderBottomStyle& other) : inner_(other.inner_) {}
    StyleBorderBottomStyle& operator=(const StyleBorderBottomStyle& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBorderLeftColor {
private:
    AzStyleBorderLeftColor inner_;

public:
    StyleBorderLeftColor(AzStyleBorderLeftColor inner) : inner_(inner) {}
    StyleBorderLeftColor(const StyleBorderLeftColor& other) : inner_(other.inner_) {}
    StyleBorderLeftColor& operator=(const StyleBorderLeftColor& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBorderLeftStyle {
private:
    AzStyleBorderLeftStyle inner_;

public:
    StyleBorderLeftStyle(AzStyleBorderLeftStyle inner) : inner_(inner) {}
    StyleBorderLeftStyle(const StyleBorderLeftStyle& other) : inner_(other.inner_) {}
    StyleBorderLeftStyle& operator=(const StyleBorderLeftStyle& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBorderRightColor {
private:
    AzStyleBorderRightColor inner_;

public:
    StyleBorderRightColor(AzStyleBorderRightColor inner) : inner_(inner) {}
    StyleBorderRightColor(const StyleBorderRightColor& other) : inner_(other.inner_) {}
    StyleBorderRightColor& operator=(const StyleBorderRightColor& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBorderRightStyle {
private:
    AzStyleBorderRightStyle inner_;

public:
    StyleBorderRightStyle(AzStyleBorderRightStyle inner) : inner_(inner) {}
    StyleBorderRightStyle(const StyleBorderRightStyle& other) : inner_(other.inner_) {}
    StyleBorderRightStyle& operator=(const StyleBorderRightStyle& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBorderTopColor {
private:
    AzStyleBorderTopColor inner_;

public:
    StyleBorderTopColor(AzStyleBorderTopColor inner) : inner_(inner) {}
    StyleBorderTopColor(const StyleBorderTopColor& other) : inner_(other.inner_) {}
    StyleBorderTopColor& operator=(const StyleBorderTopColor& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBorderTopStyle {
private:
    AzStyleBorderTopStyle inner_;

public:
    StyleBorderTopStyle(AzStyleBorderTopStyle inner) : inner_(inner) {}
    StyleBorderTopStyle(const StyleBorderTopStyle& other) : inner_(other.inner_) {}
    StyleBorderTopStyle& operator=(const StyleBorderTopStyle& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTransformMatrix2D {
private:
    AzStyleTransformMatrix2D inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTransformMatrix3D {
private:
    AzStyleTransformMatrix3D inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTransformScale2D {
private:
    AzStyleTransformScale2D inner_;

public:
    StyleTransformScale2D(AzStyleTransformScale2D inner) : inner_(inner) {}
    StyleTransformScale2D(const StyleTransformScale2D& other) : inner_(other.inner_) {}
    StyleTransformScale2D& operator=(const StyleTransformScale2D& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTransformScale3D {
private:
    AzStyleTransformScale3D inner_;

public:
    StyleTransformScale3D(AzStyleTransformScale3D inner) : inner_(inner) {}
    StyleTransformScale3D(const StyleTransformScale3D& other) : inner_(other.inner_) {}
    StyleTransformScale3D& operator=(const StyleTransformScale3D& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTextColor {
private:
    AzStyleTextColor inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SelectionBackgroundColor {
private:
    AzSelectionBackgroundColor inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ColumnRuleColor {
private:
    AzColumnRuleColor inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CaretAnimationDuration {
private:
    AzCaretAnimationDuration inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ColumnRuleStyle {
private:
    AzColumnRuleStyle inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ShapeImageThreshold {
private:
    AzShapeImageThreshold inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CaretColor {
private:
    AzCaretColor inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleExclusionMargin {
private:
    AzStyleExclusionMargin inner_;

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

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleInitialLetter {
private:
    AzStyleInitialLetter inner_;

public:
    StyleInitialLetter(AzStyleInitialLetter inner) : inner_(inner) {}
    StyleInitialLetter(const StyleInitialLetter& other) : inner_(other.inner_) {}
    StyleInitialLetter& operator=(const StyleInitialLetter& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ScrollbarColorCustom {
private:
    AzScrollbarColorCustom inner_;

public:
    ScrollbarColorCustom(AzScrollbarColorCustom inner) : inner_(inner) {}
    ScrollbarColorCustom(const ScrollbarColorCustom& other) : inner_(other.inner_) {}
    ScrollbarColorCustom& operator=(const ScrollbarColorCustom& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ShapeInset {
public:
    struct Proxy { AzShapeInset inner; Proxy(AzShapeInset p) : inner(p) {} };

private:
    mutable AzShapeInset inner_;

public:
    explicit ShapeInset(AzShapeInset inner) : inner_(inner) {}
    ShapeInset(const ShapeInset& other) : inner_(other.inner_) { memset(const_cast<AzShapeInset*>(&other.inner_), 0, sizeof(other.inner_)); }
    ShapeInset& operator=(const ShapeInset& other) {
        AzShapeInset_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzShapeInset*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ShapeInset(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ShapeInset& operator=(Proxy p) {
        AzShapeInset_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ShapeEllipse {
public:
    struct Proxy { AzShapeEllipse inner; Proxy(AzShapeEllipse p) : inner(p) {} };

private:
    mutable AzShapeEllipse inner_;

public:
    explicit ShapeEllipse(AzShapeEllipse inner) : inner_(inner) {}
    ShapeEllipse(const ShapeEllipse& other) : inner_(other.inner_) { memset(const_cast<AzShapeEllipse*>(&other.inner_), 0, sizeof(other.inner_)); }
    ShapeEllipse& operator=(const ShapeEllipse& other) {
        AzShapeEllipse_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzShapeEllipse*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ShapeEllipse(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ShapeEllipse& operator=(Proxy p) {
        AzShapeEllipse_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutRect {
private:
    AzLayoutRect inner_;

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

    static LayoutRect create(LayoutPoint origin, LayoutSize size);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyledNode {
public:
    struct Proxy { AzStyledNode inner; Proxy(AzStyledNode p) : inner(p) {} };

private:
    mutable AzStyledNode inner_;

public:
    explicit StyledNode(AzStyledNode inner) : inner_(inner) {}
    StyledNode(const StyledNode& other) : inner_(other.inner_) { memset(const_cast<AzStyledNode*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyledNode& operator=(const StyledNode& other) {
        AzStyledNode_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyledNode*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyledNode(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyledNode& operator=(Proxy p) {
        AzStyledNode_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~StyledNode() { AzStyledNode_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ArithmeticCoefficients {
public:
    struct Proxy { AzArithmeticCoefficients inner; Proxy(AzArithmeticCoefficients p) : inner(p) {} };

private:
    mutable AzArithmeticCoefficients inner_;

public:
    explicit ArithmeticCoefficients(AzArithmeticCoefficients inner) : inner_(inner) {}
    ArithmeticCoefficients(const ArithmeticCoefficients& other) : inner_(other.inner_) { memset(const_cast<AzArithmeticCoefficients*>(&other.inner_), 0, sizeof(other.inner_)); }
    ArithmeticCoefficients& operator=(const ArithmeticCoefficients& other) {
        AzArithmeticCoefficients_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzArithmeticCoefficients*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ArithmeticCoefficients(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ArithmeticCoefficients& operator=(Proxy p) {
        AzArithmeticCoefficients_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBackgroundRepeatVecSlice {
private:
    AzStyleBackgroundRepeatVecSlice inner_;

public:
    StyleBackgroundRepeatVecSlice(AzStyleBackgroundRepeatVecSlice inner) : inner_(inner) {}
    StyleBackgroundRepeatVecSlice(const StyleBackgroundRepeatVecSlice& other) : inner_(other.inner_) {}
    StyleBackgroundRepeatVecSlice& operator=(const StyleBackgroundRepeatVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ScrollbarPreferences {
private:
    AzScrollbarPreferences inner_;

public:
    ScrollbarPreferences(AzScrollbarPreferences inner) : inner_(inner) {}
    ScrollbarPreferences(const ScrollbarPreferences& other) : inner_(other.inner_) {}
    ScrollbarPreferences& operator=(const ScrollbarPreferences& other) { inner_ = other.inner_; return *this; }
    ~ScrollbarPreferences() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextRenderingHints {
private:
    AzTextRenderingHints inner_;

public:
    TextRenderingHints(AzTextRenderingHints inner) : inner_(inner) {}
    TextRenderingHints(const TextRenderingHints& other) : inner_(other.inner_) {}
    TextRenderingHints& operator=(const TextRenderingHints& other) { inner_ = other.inner_; return *this; }
    ~TextRenderingHints() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AnimationMetrics {
private:
    AzAnimationMetrics inner_;

public:
    AnimationMetrics(AzAnimationMetrics inner) : inner_(inner) {}
    AnimationMetrics(const AnimationMetrics& other) : inner_(other.inner_) {}
    AnimationMetrics& operator=(const AnimationMetrics& other) { inner_ = other.inner_; return *this; }
    ~AnimationMetrics() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssSyntaxInvalidAdvance {
private:
    AzCssSyntaxInvalidAdvance inner_;

public:
    CssSyntaxInvalidAdvance(AzCssSyntaxInvalidAdvance inner) : inner_(inner) {}
    CssSyntaxInvalidAdvance(const CssSyntaxInvalidAdvance& other) : inner_(other.inner_) {}
    CssSyntaxInvalidAdvance& operator=(const CssSyntaxInvalidAdvance& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgFillStyle {
private:
    AzSvgFillStyle inner_;

public:
    SvgFillStyle(AzSvgFillStyle inner) : inner_(inner) {}
    SvgFillStyle(const SvgFillStyle& other) : inner_(other.inner_) {}
    SvgFillStyle& operator=(const SvgFillStyle& other) { inner_ = other.inner_; return *this; }
    ~SvgFillStyle() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class OsVersion {
private:
    AzOsVersion inner_;

public:
    OsVersion(AzOsVersion inner) : inner_(inner) {}
    OsVersion(const OsVersion& other) : inner_(other.inner_) {}
    OsVersion& operator=(const OsVersion& other) { inner_ = other.inner_; return *this; }
    ~OsVersion() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VisualHints {
private:
    AzVisualHints inner_;

public:
    VisualHints(AzVisualHints inner) : inner_(inner) {}
    VisualHints(const VisualHints& other) : inner_(other.inner_) {}
    VisualHints& operator=(const VisualHints& other) { inner_ = other.inner_; return *this; }
    ~VisualHints() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleClipRect {
private:
    AzStyleClipRect inner_;

public:
    StyleClipRect(AzStyleClipRect inner) : inner_(inner) {}
    StyleClipRect(const StyleClipRect& other) : inner_(other.inner_) {}
    StyleClipRect& operator=(const StyleClipRect& other) { inner_ = other.inner_; return *this; }
    ~StyleClipRect() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DesktopEnvVersion {
private:
    AzDesktopEnvVersion inner_;

public:
    DesktopEnvVersion(AzDesktopEnvVersion inner) : inner_(inner) {}
    DesktopEnvVersion(const DesktopEnvVersion& other) : inner_(other.inner_) {}
    DesktopEnvVersion& operator=(const DesktopEnvVersion& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ColorInputState {
public:
    struct Proxy { AzColorInputState inner; Proxy(AzColorInputState p) : inner(p) {} };

private:
    mutable AzColorInputState inner_;

public:
    explicit ColorInputState(AzColorInputState inner) : inner_(inner) {}
    ColorInputState(const ColorInputState& other) : inner_(other.inner_) { memset(const_cast<AzColorInputState*>(&other.inner_), 0, sizeof(other.inner_)); }
    ColorInputState& operator=(const ColorInputState& other) {
        AzColorInputState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzColorInputState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ColorInputState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ColorInputState& operator=(Proxy p) {
        AzColorInputState_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ColorInputState() { AzColorInputState_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class OnTextInputReturn {
private:
    AzOnTextInputReturn inner_;

public:
    OnTextInputReturn(AzOnTextInputReturn inner) : inner_(inner) {}
    OnTextInputReturn(const OnTextInputReturn& other) : inner_(other.inner_) {}
    OnTextInputReturn& operator=(const OnTextInputReturn& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GlShaderPrecisionFormatReturn {
private:
    AzGlShaderPrecisionFormatReturn inner_;

public:
    GlShaderPrecisionFormatReturn(AzGlShaderPrecisionFormatReturn inner) : inner_(inner) {}
    GlShaderPrecisionFormatReturn(const GlShaderPrecisionFormatReturn& other) : inner_(other.inner_) {}
    GlShaderPrecisionFormatReturn& operator=(const GlShaderPrecisionFormatReturn& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GlContextPtr {
public:
    struct Proxy { AzGlContextPtr inner; Proxy(AzGlContextPtr p) : inner(p) {} };

private:
    mutable AzGlContextPtr inner_;

public:
    explicit GlContextPtr(AzGlContextPtr inner) : inner_(inner) {}
    GlContextPtr(const GlContextPtr& other) : inner_(other.inner_) { memset(const_cast<AzGlContextPtr*>(&other.inner_), 0, sizeof(other.inner_)); }
    GlContextPtr& operator=(const GlContextPtr& other) {
        AzGlContextPtr_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGlContextPtr*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GlContextPtr(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GlContextPtr& operator=(Proxy p) {
        AzGlContextPtr_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GLuintVecSlice {
private:
    AzGLuintVecSlice inner_;

public:
    GLuintVecSlice(AzGLuintVecSlice inner) : inner_(inner) {}
    GLuintVecSlice(const GLuintVecSlice& other) : inner_(other.inner_) {}
    GLuintVecSlice& operator=(const GLuintVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GLintVecSlice {
private:
    AzGLintVecSlice inner_;

public:
    GLintVecSlice(AzGLintVecSlice inner) : inner_(inner) {}
    GLintVecSlice(const GLintVecSlice& other) : inner_(other.inner_) {}
    GLintVecSlice& operator=(const GLintVecSlice& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ImageDescriptor {
private:
    AzImageDescriptor inner_;

public:
    ImageDescriptor(AzImageDescriptor inner) : inner_(inner) {}
    ImageDescriptor(const ImageDescriptor& other) : inner_(other.inner_) {}
    ImageDescriptor& operator=(const ImageDescriptor& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FontMetrics {
public:
    struct Proxy { AzFontMetrics inner; Proxy(AzFontMetrics p) : inner(p) {} };

private:
    mutable AzFontMetrics inner_;

public:
    explicit FontMetrics(AzFontMetrics inner) : inner_(inner) {}
    FontMetrics(const FontMetrics& other) : inner_(other.inner_) { memset(const_cast<AzFontMetrics*>(&other.inner_), 0, sizeof(other.inner_)); }
    FontMetrics& operator=(const FontMetrics& other) {
        AzFontMetrics_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFontMetrics*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FontMetrics(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FontMetrics& operator=(Proxy p) {
        AzFontMetrics_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~FontMetrics() { AzFontMetrics_delete(&inner_); }

    static FontMetrics zero();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FontRef {
public:
    struct Proxy { AzFontRef inner; Proxy(AzFontRef p) : inner(p) {} };

private:
    mutable AzFontRef inner_;

public:
    explicit FontRef(AzFontRef inner) : inner_(inner) {}
    FontRef(const FontRef& other) : inner_(other.inner_) { memset(const_cast<AzFontRef*>(&other.inner_), 0, sizeof(other.inner_)); }
    FontRef& operator=(const FontRef& other) {
        AzFontRef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFontRef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FontRef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FontRef& operator=(Proxy p) {
        AzFontRef_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~FontRef() { AzFontRef_delete(&inner_); }

    static FontRef create(const void* parsed, AzFontRefDestructorCallbackType destructor);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LogicalRect {
private:
    AzLogicalRect inner_;

public:
    LogicalRect(AzLogicalRect inner) : inner_(inner) {}
    LogicalRect(const LogicalRect& other) : inner_(other.inner_) {}
    LogicalRect& operator=(const LogicalRect& other) { inner_ = other.inner_; return *this; }
    ~LogicalRect() {}

    static LogicalRect create(LogicalPosition origin, LogicalSize size);
    static LogicalRect zero();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ShapeCircle {
public:
    struct Proxy { AzShapeCircle inner; Proxy(AzShapeCircle p) : inner(p) {} };

private:
    mutable AzShapeCircle inner_;

public:
    explicit ShapeCircle(AzShapeCircle inner) : inner_(inner) {}
    ShapeCircle(const ShapeCircle& other) : inner_(other.inner_) { memset(const_cast<AzShapeCircle*>(&other.inner_), 0, sizeof(other.inner_)); }
    ShapeCircle& operator=(const ShapeCircle& other) {
        AzShapeCircle_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzShapeCircle*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ShapeCircle(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ShapeCircle& operator=(Proxy p) {
        AzShapeCircle_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgLine {
private:
    AzSvgLine inner_;

public:
    SvgLine(AzSvgLine inner) : inner_(inner) {}
    SvgLine(const SvgLine& other) : inner_(other.inner_) {}
    SvgLine& operator=(const SvgLine& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgCubicCurve {
private:
    AzSvgCubicCurve inner_;

public:
    SvgCubicCurve(AzSvgCubicCurve inner) : inner_(inner) {}
    SvgCubicCurve(const SvgCubicCurve& other) : inner_(other.inner_) {}
    SvgCubicCurve& operator=(const SvgCubicCurve& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgQuadraticCurve {
private:
    AzSvgQuadraticCurve inner_;

public:
    SvgQuadraticCurve(AzSvgQuadraticCurve inner) : inner_(inner) {}
    SvgQuadraticCurve(const SvgQuadraticCurve& other) : inner_(other.inner_) {}
    SvgQuadraticCurve& operator=(const SvgQuadraticCurve& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GetSystemTimeCallback {
public:
    struct Proxy { AzGetSystemTimeCallback inner; Proxy(AzGetSystemTimeCallback p) : inner(p) {} };

private:
    mutable AzGetSystemTimeCallback inner_;

public:
    explicit GetSystemTimeCallback(AzGetSystemTimeCallback inner) : inner_(inner) {}
    GetSystemTimeCallback(const GetSystemTimeCallback& other) : inner_(other.inner_) { memset(const_cast<AzGetSystemTimeCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    GetSystemTimeCallback& operator=(const GetSystemTimeCallback& other) {
        AzGetSystemTimeCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGetSystemTimeCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GetSystemTimeCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GetSystemTimeCallback& operator=(Proxy p) {
        AzGetSystemTimeCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ScrollIntoViewOptions {
private:
    AzScrollIntoViewOptions inner_;

public:
    ScrollIntoViewOptions(AzScrollIntoViewOptions inner) : inner_(inner) {}
    ScrollIntoViewOptions(const ScrollIntoViewOptions& other) : inner_(other.inner_) {}
    ScrollIntoViewOptions& operator=(const ScrollIntoViewOptions& other) { inner_ = other.inner_; return *this; }
    ~ScrollIntoViewOptions() {}

    static ScrollIntoViewOptions nearest();
    static ScrollIntoViewOptions center();
    static ScrollIntoViewOptions start();
    static ScrollIntoViewOptions end();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NonXmlCharError {
public:
    struct Proxy { AzNonXmlCharError inner; Proxy(AzNonXmlCharError p) : inner(p) {} };

private:
    mutable AzNonXmlCharError inner_;

public:
    explicit NonXmlCharError(AzNonXmlCharError inner) : inner_(inner) {}
    NonXmlCharError(const NonXmlCharError& other) : inner_(other.inner_) { memset(const_cast<AzNonXmlCharError*>(&other.inner_), 0, sizeof(other.inner_)); }
    NonXmlCharError& operator=(const NonXmlCharError& other) {
        AzNonXmlCharError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNonXmlCharError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NonXmlCharError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NonXmlCharError& operator=(Proxy p) {
        AzNonXmlCharError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class InvalidCharError {
public:
    struct Proxy { AzInvalidCharError inner; Proxy(AzInvalidCharError p) : inner(p) {} };

private:
    mutable AzInvalidCharError inner_;

public:
    explicit InvalidCharError(AzInvalidCharError inner) : inner_(inner) {}
    InvalidCharError(const InvalidCharError& other) : inner_(other.inner_) { memset(const_cast<AzInvalidCharError*>(&other.inner_), 0, sizeof(other.inner_)); }
    InvalidCharError& operator=(const InvalidCharError& other) {
        AzInvalidCharError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzInvalidCharError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    InvalidCharError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    InvalidCharError& operator=(Proxy p) {
        AzInvalidCharError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class InvalidQuoteError {
public:
    struct Proxy { AzInvalidQuoteError inner; Proxy(AzInvalidQuoteError p) : inner(p) {} };

private:
    mutable AzInvalidQuoteError inner_;

public:
    explicit InvalidQuoteError(AzInvalidQuoteError inner) : inner_(inner) {}
    InvalidQuoteError(const InvalidQuoteError& other) : inner_(other.inner_) { memset(const_cast<AzInvalidQuoteError*>(&other.inner_), 0, sizeof(other.inner_)); }
    InvalidQuoteError& operator=(const InvalidQuoteError& other) {
        AzInvalidQuoteError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzInvalidQuoteError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    InvalidQuoteError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    InvalidQuoteError& operator=(Proxy p) {
        AzInvalidQuoteError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class InvalidSpaceError {
public:
    struct Proxy { AzInvalidSpaceError inner; Proxy(AzInvalidSpaceError p) : inner(p) {} };

private:
    mutable AzInvalidSpaceError inner_;

public:
    explicit InvalidSpaceError(AzInvalidSpaceError inner) : inner_(inner) {}
    InvalidSpaceError(const InvalidSpaceError& other) : inner_(other.inner_) { memset(const_cast<AzInvalidSpaceError*>(&other.inner_), 0, sizeof(other.inner_)); }
    InvalidSpaceError& operator=(const InvalidSpaceError& other) {
        AzInvalidSpaceError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzInvalidSpaceError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    InvalidSpaceError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    InvalidSpaceError& operator=(Proxy p) {
        AzInvalidSpaceError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ErrorLocationRange {
private:
    AzErrorLocationRange inner_;

public:
    ErrorLocationRange(AzErrorLocationRange inner) : inner_(inner) {}
    ErrorLocationRange(const ErrorLocationRange& other) : inner_(other.inner_) {}
    ErrorLocationRange& operator=(const ErrorLocationRange& other) { inner_ = other.inner_; return *this; }
    ~ErrorLocationRange() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RendererOptions {
private:
    AzRendererOptions inner_;

public:
    RendererOptions(AzRendererOptions inner) : inner_(inner) {}
    RendererOptions(const RendererOptions& other) : inner_(other.inner_) {}
    RendererOptions& operator=(const RendererOptions& other) { inner_ = other.inner_; return *this; }
    ~RendererOptions() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FileMetadata {
public:
    struct Proxy { AzFileMetadata inner; Proxy(AzFileMetadata p) : inner(p) {} };

private:
    mutable AzFileMetadata inner_;

public:
    explicit FileMetadata(AzFileMetadata inner) : inner_(inner) {}
    FileMetadata(const FileMetadata& other) : inner_(other.inner_) { memset(const_cast<AzFileMetadata*>(&other.inner_), 0, sizeof(other.inner_)); }
    FileMetadata& operator=(const FileMetadata& other) {
        AzFileMetadata_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFileMetadata*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FileMetadata(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FileMetadata& operator=(Proxy p) {
        AzFileMetadata_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SensorReading {
private:
    AzSensorReading inner_;

public:
    SensorReading(AzSensorReading inner) : inner_(inner) {}
    SensorReading(const SensorReading& other) : inner_(other.inner_) {}
    SensorReading& operator=(const SensorReading& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GamepadState {
private:
    AzGamepadState inner_;

public:
    GamepadState(AzGamepadState inner) : inner_(inner) {}
    GamepadState(const GamepadState& other) : inner_(other.inner_) {}
    GamepadState& operator=(const GamepadState& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CameraConfig {
private:
    AzCameraConfig inner_;

public:
    CameraConfig(AzCameraConfig inner) : inner_(inner) {}
    CameraConfig(const CameraConfig& other) : inner_(other.inner_) {}
    CameraConfig& operator=(const CameraConfig& other) { inner_ = other.inner_; return *this; }
    ~CameraConfig() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ScreenCaptureConfig {
private:
    AzScreenCaptureConfig inner_;

public:
    ScreenCaptureConfig(AzScreenCaptureConfig inner) : inner_(inner) {}
    ScreenCaptureConfig(const ScreenCaptureConfig& other) : inner_(other.inner_) {}
    ScreenCaptureConfig& operator=(const ScreenCaptureConfig& other) { inner_ = other.inner_; return *this; }
    ~ScreenCaptureConfig() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DetectedRotation {
private:
    AzDetectedRotation inner_;

public:
    DetectedRotation(AzDetectedRotation inner) : inner_(inner) {}
    DetectedRotation(const DetectedRotation& other) : inner_(other.inner_) {}
    DetectedRotation& operator=(const DetectedRotation& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DetectedLongPress {
private:
    AzDetectedLongPress inner_;

public:
    DetectedLongPress(AzDetectedLongPress inner) : inner_(inner) {}
    DetectedLongPress(const DetectedLongPress& other) : inner_(other.inner_) {}
    DetectedLongPress& operator=(const DetectedLongPress& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class IcuDateTime {
private:
    AzIcuDateTime inner_;

public:
    IcuDateTime(AzIcuDateTime inner) : inner_(inner) {}
    IcuDateTime(const IcuDateTime& other) : inner_(other.inner_) {}
    IcuDateTime& operator=(const IcuDateTime& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class HidpiAdjustedBounds {
private:
    AzHidpiAdjustedBounds inner_;

public:
    HidpiAdjustedBounds(AzHidpiAdjustedBounds inner) : inner_(inner) {}
    HidpiAdjustedBounds(const HidpiAdjustedBounds& other) : inner_(other.inner_) {}
    HidpiAdjustedBounds& operator=(const HidpiAdjustedBounds& other) { inner_ = other.inner_; return *this; }
    ~HidpiAdjustedBounds() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WindowSize {
private:
    AzWindowSize inner_;

public:
    WindowSize(AzWindowSize inner) : inner_(inner) {}
    WindowSize(const WindowSize& other) : inner_(other.inner_) {}
    WindowSize& operator=(const WindowSize& other) { inner_ = other.inner_; return *this; }
    ~WindowSize() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextOpMoveCursor {
public:
    struct Proxy { AzTextOpMoveCursor inner; Proxy(AzTextOpMoveCursor p) : inner(p) {} };

private:
    mutable AzTextOpMoveCursor inner_;

public:
    explicit TextOpMoveCursor(AzTextOpMoveCursor inner) : inner_(inner) {}
    TextOpMoveCursor(const TextOpMoveCursor& other) : inner_(other.inner_) { memset(const_cast<AzTextOpMoveCursor*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextOpMoveCursor& operator=(const TextOpMoveCursor& other) {
        AzTextOpMoveCursor_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextOpMoveCursor*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextOpMoveCursor(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextOpMoveCursor& operator=(Proxy p) {
        AzTextOpMoveCursor_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CallbackInfo {
private:
    AzCallbackInfo inner_;

public:
    CallbackInfo(AzCallbackInfo inner) : inner_(inner) {}
    CallbackInfo(const CallbackInfo& other) : inner_(other.inner_) {}
    CallbackInfo& operator=(const CallbackInfo& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TagIdToNodeIdMapping {
public:
    struct Proxy { AzTagIdToNodeIdMapping inner; Proxy(AzTagIdToNodeIdMapping p) : inner(p) {} };

private:
    mutable AzTagIdToNodeIdMapping inner_;

public:
    explicit TagIdToNodeIdMapping(AzTagIdToNodeIdMapping inner) : inner_(inner) {}
    TagIdToNodeIdMapping(const TagIdToNodeIdMapping& other) : inner_(other.inner_) { memset(const_cast<AzTagIdToNodeIdMapping*>(&other.inner_), 0, sizeof(other.inner_)); }
    TagIdToNodeIdMapping& operator=(const TagIdToNodeIdMapping& other) {
        AzTagIdToNodeIdMapping_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTagIdToNodeIdMapping*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TagIdToNodeIdMapping(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TagIdToNodeIdMapping& operator=(Proxy p) {
        AzTagIdToNodeIdMapping_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MouseState {
private:
    AzMouseState inner_;

public:
    MouseState(AzMouseState inner) : inner_(inner) {}
    MouseState(const MouseState& other) : inner_(other.inner_) {}
    MouseState& operator=(const MouseState& other) { inner_ = other.inner_; return *this; }
    ~MouseState() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SelectionRange {
private:
    AzSelectionRange inner_;

public:
    SelectionRange(AzSelectionRange inner) : inner_(inner) {}
    SelectionRange(const SelectionRange& other) : inner_(other.inner_) {}
    SelectionRange& operator=(const SelectionRange& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SelectionRadius {
private:
    AzSelectionRadius inner_;

public:
    SelectionRadius(AzSelectionRadius inner) : inner_(inner) {}
    SelectionRadius(const SelectionRadius& other) : inner_(other.inner_) {}
    SelectionRadius& operator=(const SelectionRadius& other) { inner_ = other.inner_; return *this; }
    ~SelectionRadius() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class PixelValueSize {
private:
    AzPixelValueSize inner_;

public:
    PixelValueSize(AzPixelValueSize inner) : inner_(inner) {}
    PixelValueSize(const PixelValueSize& other) : inner_(other.inner_) {}
    PixelValueSize& operator=(const PixelValueSize& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class PixelValueNoPercent {
private:
    AzPixelValueNoPercent inner_;

public:
    PixelValueNoPercent(AzPixelValueNoPercent inner) : inner_(inner) {}
    PixelValueNoPercent(const PixelValueNoPercent& other) : inner_(other.inner_) {}
    PixelValueNoPercent& operator=(const PixelValueNoPercent& other) { inner_ = other.inner_; return *this; }
    ~PixelValueNoPercent() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBlur {
public:
    struct Proxy { AzStyleBlur inner; Proxy(AzStyleBlur p) : inner(p) {} };

private:
    mutable AzStyleBlur inner_;

public:
    explicit StyleBlur(AzStyleBlur inner) : inner_(inner) {}
    StyleBlur(const StyleBlur& other) : inner_(other.inner_) { memset(const_cast<AzStyleBlur*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyleBlur& operator=(const StyleBlur& other) {
        AzStyleBlur_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyleBlur*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyleBlur(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyleBlur& operator=(Proxy p) {
        AzStyleBlur_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~StyleBlur() { AzStyleBlur_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleFilterOffset {
public:
    struct Proxy { AzStyleFilterOffset inner; Proxy(AzStyleFilterOffset p) : inner(p) {} };

private:
    mutable AzStyleFilterOffset inner_;

public:
    explicit StyleFilterOffset(AzStyleFilterOffset inner) : inner_(inner) {}
    StyleFilterOffset(const StyleFilterOffset& other) : inner_(other.inner_) { memset(const_cast<AzStyleFilterOffset*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyleFilterOffset& operator=(const StyleFilterOffset& other) {
        AzStyleFilterOffset_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyleFilterOffset*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyleFilterOffset(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyleFilterOffset& operator=(Proxy p) {
        AzStyleFilterOffset_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~StyleFilterOffset() { AzStyleFilterOffset_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutLeft {
private:
    AzLayoutLeft inner_;

public:
    LayoutLeft(AzLayoutLeft inner) : inner_(inner) {}
    LayoutLeft(const LayoutLeft& other) : inner_(other.inner_) {}
    LayoutLeft& operator=(const LayoutLeft& other) { inner_ = other.inner_; return *this; }
    ~LayoutLeft() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutMarginBottom {
private:
    AzLayoutMarginBottom inner_;

public:
    LayoutMarginBottom(AzLayoutMarginBottom inner) : inner_(inner) {}
    LayoutMarginBottom(const LayoutMarginBottom& other) : inner_(other.inner_) {}
    LayoutMarginBottom& operator=(const LayoutMarginBottom& other) { inner_ = other.inner_; return *this; }
    ~LayoutMarginBottom() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutMarginLeft {
private:
    AzLayoutMarginLeft inner_;

public:
    LayoutMarginLeft(AzLayoutMarginLeft inner) : inner_(inner) {}
    LayoutMarginLeft(const LayoutMarginLeft& other) : inner_(other.inner_) {}
    LayoutMarginLeft& operator=(const LayoutMarginLeft& other) { inner_ = other.inner_; return *this; }
    ~LayoutMarginLeft() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutMarginRight {
private:
    AzLayoutMarginRight inner_;

public:
    LayoutMarginRight(AzLayoutMarginRight inner) : inner_(inner) {}
    LayoutMarginRight(const LayoutMarginRight& other) : inner_(other.inner_) {}
    LayoutMarginRight& operator=(const LayoutMarginRight& other) { inner_ = other.inner_; return *this; }
    ~LayoutMarginRight() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutMarginTop {
private:
    AzLayoutMarginTop inner_;

public:
    LayoutMarginTop(AzLayoutMarginTop inner) : inner_(inner) {}
    LayoutMarginTop(const LayoutMarginTop& other) : inner_(other.inner_) {}
    LayoutMarginTop& operator=(const LayoutMarginTop& other) { inner_ = other.inner_; return *this; }
    ~LayoutMarginTop() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutMaxHeight {
private:
    AzLayoutMaxHeight inner_;

public:
    LayoutMaxHeight(AzLayoutMaxHeight inner) : inner_(inner) {}
    LayoutMaxHeight(const LayoutMaxHeight& other) : inner_(other.inner_) {}
    LayoutMaxHeight& operator=(const LayoutMaxHeight& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutMaxWidth {
private:
    AzLayoutMaxWidth inner_;

public:
    LayoutMaxWidth(AzLayoutMaxWidth inner) : inner_(inner) {}
    LayoutMaxWidth(const LayoutMaxWidth& other) : inner_(other.inner_) {}
    LayoutMaxWidth& operator=(const LayoutMaxWidth& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutMinHeight {
private:
    AzLayoutMinHeight inner_;

public:
    LayoutMinHeight(AzLayoutMinHeight inner) : inner_(inner) {}
    LayoutMinHeight(const LayoutMinHeight& other) : inner_(other.inner_) {}
    LayoutMinHeight& operator=(const LayoutMinHeight& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutMinWidth {
private:
    AzLayoutMinWidth inner_;

public:
    LayoutMinWidth(AzLayoutMinWidth inner) : inner_(inner) {}
    LayoutMinWidth(const LayoutMinWidth& other) : inner_(other.inner_) {}
    LayoutMinWidth& operator=(const LayoutMinWidth& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutPaddingBottom {
private:
    AzLayoutPaddingBottom inner_;

public:
    LayoutPaddingBottom(AzLayoutPaddingBottom inner) : inner_(inner) {}
    LayoutPaddingBottom(const LayoutPaddingBottom& other) : inner_(other.inner_) {}
    LayoutPaddingBottom& operator=(const LayoutPaddingBottom& other) { inner_ = other.inner_; return *this; }
    ~LayoutPaddingBottom() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutPaddingLeft {
private:
    AzLayoutPaddingLeft inner_;

public:
    LayoutPaddingLeft(AzLayoutPaddingLeft inner) : inner_(inner) {}
    LayoutPaddingLeft(const LayoutPaddingLeft& other) : inner_(other.inner_) {}
    LayoutPaddingLeft& operator=(const LayoutPaddingLeft& other) { inner_ = other.inner_; return *this; }
    ~LayoutPaddingLeft() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutPaddingRight {
private:
    AzLayoutPaddingRight inner_;

public:
    LayoutPaddingRight(AzLayoutPaddingRight inner) : inner_(inner) {}
    LayoutPaddingRight(const LayoutPaddingRight& other) : inner_(other.inner_) {}
    LayoutPaddingRight& operator=(const LayoutPaddingRight& other) { inner_ = other.inner_; return *this; }
    ~LayoutPaddingRight() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutPaddingTop {
private:
    AzLayoutPaddingTop inner_;

public:
    LayoutPaddingTop(AzLayoutPaddingTop inner) : inner_(inner) {}
    LayoutPaddingTop(const LayoutPaddingTop& other) : inner_(other.inner_) {}
    LayoutPaddingTop& operator=(const LayoutPaddingTop& other) { inner_ = other.inner_; return *this; }
    ~LayoutPaddingTop() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutRight {
private:
    AzLayoutRight inner_;

public:
    LayoutRight(AzLayoutRight inner) : inner_(inner) {}
    LayoutRight(const LayoutRight& other) : inner_(other.inner_) {}
    LayoutRight& operator=(const LayoutRight& other) { inner_ = other.inner_; return *this; }
    ~LayoutRight() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutTop {
private:
    AzLayoutTop inner_;

public:
    LayoutTop(AzLayoutTop inner) : inner_(inner) {}
    LayoutTop(const LayoutTop& other) : inner_(other.inner_) {}
    LayoutTop& operator=(const LayoutTop& other) { inner_ = other.inner_; return *this; }
    ~LayoutTop() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NormalizedLinearColorStop {
public:
    struct Proxy { AzNormalizedLinearColorStop inner; Proxy(AzNormalizedLinearColorStop p) : inner(p) {} };

private:
    mutable AzNormalizedLinearColorStop inner_;

public:
    explicit NormalizedLinearColorStop(AzNormalizedLinearColorStop inner) : inner_(inner) {}
    NormalizedLinearColorStop(const NormalizedLinearColorStop& other) : inner_(other.inner_) { memset(const_cast<AzNormalizedLinearColorStop*>(&other.inner_), 0, sizeof(other.inner_)); }
    NormalizedLinearColorStop& operator=(const NormalizedLinearColorStop& other) {
        AzNormalizedLinearColorStop_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNormalizedLinearColorStop*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NormalizedLinearColorStop(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NormalizedLinearColorStop& operator=(Proxy p) {
        AzNormalizedLinearColorStop_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NormalizedRadialColorStop {
public:
    struct Proxy { AzNormalizedRadialColorStop inner; Proxy(AzNormalizedRadialColorStop p) : inner(p) {} };

private:
    mutable AzNormalizedRadialColorStop inner_;

public:
    explicit NormalizedRadialColorStop(AzNormalizedRadialColorStop inner) : inner_(inner) {}
    NormalizedRadialColorStop(const NormalizedRadialColorStop& other) : inner_(other.inner_) { memset(const_cast<AzNormalizedRadialColorStop*>(&other.inner_), 0, sizeof(other.inner_)); }
    NormalizedRadialColorStop& operator=(const NormalizedRadialColorStop& other) {
        AzNormalizedRadialColorStop_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNormalizedRadialColorStop*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NormalizedRadialColorStop(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NormalizedRadialColorStop& operator=(Proxy p) {
        AzNormalizedRadialColorStop_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBorderBottomLeftRadius {
private:
    AzStyleBorderBottomLeftRadius inner_;

public:
    StyleBorderBottomLeftRadius(AzStyleBorderBottomLeftRadius inner) : inner_(inner) {}
    StyleBorderBottomLeftRadius(const StyleBorderBottomLeftRadius& other) : inner_(other.inner_) {}
    StyleBorderBottomLeftRadius& operator=(const StyleBorderBottomLeftRadius& other) { inner_ = other.inner_; return *this; }
    ~StyleBorderBottomLeftRadius() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBorderBottomRightRadius {
private:
    AzStyleBorderBottomRightRadius inner_;

public:
    StyleBorderBottomRightRadius(AzStyleBorderBottomRightRadius inner) : inner_(inner) {}
    StyleBorderBottomRightRadius(const StyleBorderBottomRightRadius& other) : inner_(other.inner_) {}
    StyleBorderBottomRightRadius& operator=(const StyleBorderBottomRightRadius& other) { inner_ = other.inner_; return *this; }
    ~StyleBorderBottomRightRadius() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutBorderBottomWidth {
private:
    AzLayoutBorderBottomWidth inner_;

public:
    LayoutBorderBottomWidth(AzLayoutBorderBottomWidth inner) : inner_(inner) {}
    LayoutBorderBottomWidth(const LayoutBorderBottomWidth& other) : inner_(other.inner_) {}
    LayoutBorderBottomWidth& operator=(const LayoutBorderBottomWidth& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutBorderLeftWidth {
private:
    AzLayoutBorderLeftWidth inner_;

public:
    LayoutBorderLeftWidth(AzLayoutBorderLeftWidth inner) : inner_(inner) {}
    LayoutBorderLeftWidth(const LayoutBorderLeftWidth& other) : inner_(other.inner_) {}
    LayoutBorderLeftWidth& operator=(const LayoutBorderLeftWidth& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutBorderRightWidth {
private:
    AzLayoutBorderRightWidth inner_;

public:
    LayoutBorderRightWidth(AzLayoutBorderRightWidth inner) : inner_(inner) {}
    LayoutBorderRightWidth(const LayoutBorderRightWidth& other) : inner_(other.inner_) {}
    LayoutBorderRightWidth& operator=(const LayoutBorderRightWidth& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBorderTopLeftRadius {
private:
    AzStyleBorderTopLeftRadius inner_;

public:
    StyleBorderTopLeftRadius(AzStyleBorderTopLeftRadius inner) : inner_(inner) {}
    StyleBorderTopLeftRadius(const StyleBorderTopLeftRadius& other) : inner_(other.inner_) {}
    StyleBorderTopLeftRadius& operator=(const StyleBorderTopLeftRadius& other) { inner_ = other.inner_; return *this; }
    ~StyleBorderTopLeftRadius() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBorderTopRightRadius {
private:
    AzStyleBorderTopRightRadius inner_;

public:
    StyleBorderTopRightRadius(AzStyleBorderTopRightRadius inner) : inner_(inner) {}
    StyleBorderTopRightRadius(const StyleBorderTopRightRadius& other) : inner_(other.inner_) {}
    StyleBorderTopRightRadius& operator=(const StyleBorderTopRightRadius& other) { inner_ = other.inner_; return *this; }
    ~StyleBorderTopRightRadius() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutBorderTopWidth {
private:
    AzLayoutBorderTopWidth inner_;

public:
    LayoutBorderTopWidth(AzLayoutBorderTopWidth inner) : inner_(inner) {}
    LayoutBorderTopWidth(const LayoutBorderTopWidth& other) : inner_(other.inner_) {}
    LayoutBorderTopWidth& operator=(const LayoutBorderTopWidth& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleFontSize {
private:
    AzStyleFontSize inner_;

public:
    StyleFontSize(AzStyleFontSize inner) : inner_(inner) {}
    StyleFontSize(const StyleFontSize& other) : inner_(other.inner_) {}
    StyleFontSize& operator=(const StyleFontSize& other) { inner_ = other.inner_; return *this; }
    ~StyleFontSize() {}

    static StyleFontSize px(float value);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleLetterSpacing {
private:
    AzStyleLetterSpacing inner_;

public:
    StyleLetterSpacing(AzStyleLetterSpacing inner) : inner_(inner) {}
    StyleLetterSpacing(const StyleLetterSpacing& other) : inner_(other.inner_) {}
    StyleLetterSpacing& operator=(const StyleLetterSpacing& other) { inner_ = other.inner_; return *this; }
    ~StyleLetterSpacing() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleLineHeight {
private:
    AzStyleLineHeight inner_;

public:
    StyleLineHeight(AzStyleLineHeight inner) : inner_(inner) {}
    StyleLineHeight(const StyleLineHeight& other) : inner_(other.inner_) {}
    StyleLineHeight& operator=(const StyleLineHeight& other) { inner_ = other.inner_; return *this; }
    ~StyleLineHeight() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleOpacity {
private:
    AzStyleOpacity inner_;

public:
    StyleOpacity(AzStyleOpacity inner) : inner_(inner) {}
    StyleOpacity(const StyleOpacity& other) : inner_(other.inner_) {}
    StyleOpacity& operator=(const StyleOpacity& other) { inner_ = other.inner_; return *this; }
    ~StyleOpacity() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTransformOrigin {
private:
    AzStyleTransformOrigin inner_;

public:
    StyleTransformOrigin(AzStyleTransformOrigin inner) : inner_(inner) {}
    StyleTransformOrigin(const StyleTransformOrigin& other) : inner_(other.inner_) {}
    StyleTransformOrigin& operator=(const StyleTransformOrigin& other) { inner_ = other.inner_; return *this; }
    ~StyleTransformOrigin() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTransformTranslate2D {
private:
    AzStyleTransformTranslate2D inner_;

public:
    StyleTransformTranslate2D(AzStyleTransformTranslate2D inner) : inner_(inner) {}
    StyleTransformTranslate2D(const StyleTransformTranslate2D& other) : inner_(other.inner_) {}
    StyleTransformTranslate2D& operator=(const StyleTransformTranslate2D& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTransformTranslate3D {
private:
    AzStyleTransformTranslate3D inner_;

public:
    StyleTransformTranslate3D(AzStyleTransformTranslate3D inner) : inner_(inner) {}
    StyleTransformTranslate3D(const StyleTransformTranslate3D& other) : inner_(other.inner_) {}
    StyleTransformTranslate3D& operator=(const StyleTransformTranslate3D& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTransformRotate3D {
private:
    AzStyleTransformRotate3D inner_;

public:
    StyleTransformRotate3D(AzStyleTransformRotate3D inner) : inner_(inner) {}
    StyleTransformRotate3D(const StyleTransformRotate3D& other) : inner_(other.inner_) {}
    StyleTransformRotate3D& operator=(const StyleTransformRotate3D& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTransformSkew2D {
private:
    AzStyleTransformSkew2D inner_;

public:
    StyleTransformSkew2D(AzStyleTransformSkew2D inner) : inner_(inner) {}
    StyleTransformSkew2D(const StyleTransformSkew2D& other) : inner_(other.inner_) {}
    StyleTransformSkew2D& operator=(const StyleTransformSkew2D& other) { 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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleWordSpacing {
private:
    AzStyleWordSpacing inner_;

public:
    StyleWordSpacing(AzStyleWordSpacing inner) : inner_(inner) {}
    StyleWordSpacing(const StyleWordSpacing& other) : inner_(other.inner_) {}
    StyleWordSpacing& operator=(const StyleWordSpacing& other) { inner_ = other.inner_; return *this; }
    ~StyleWordSpacing() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StylePerspectiveOrigin {
private:
    AzStylePerspectiveOrigin inner_;

public:
    StylePerspectiveOrigin(AzStylePerspectiveOrigin inner) : inner_(inner) {}
    StylePerspectiveOrigin(const StylePerspectiveOrigin& other) : inner_(other.inner_) {}
    StylePerspectiveOrigin& operator=(const StylePerspectiveOrigin& other) { inner_ = other.inner_; return *this; }
    ~StylePerspectiveOrigin() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutGap {
private:
    AzLayoutGap inner_;

public:
    LayoutGap(AzLayoutGap inner) : inner_(inner) {}
    LayoutGap(const LayoutGap& other) : inner_(other.inner_) {}
    LayoutGap& operator=(const LayoutGap& other) { inner_ = other.inner_; return *this; }
    ~LayoutGap() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ShapeMargin {
private:
    AzShapeMargin inner_;

public:
    ShapeMargin(AzShapeMargin inner) : inner_(inner) {}
    ShapeMargin(const ShapeMargin& other) : inner_(other.inner_) {}
    ShapeMargin& operator=(const ShapeMargin& other) { inner_ = other.inner_; return *this; }
    ~ShapeMargin() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ColumnRuleWidth {
private:
    AzColumnRuleWidth inner_;

public:
    ColumnRuleWidth(AzColumnRuleWidth inner) : inner_(inner) {}
    ColumnRuleWidth(const ColumnRuleWidth& other) : inner_(other.inner_) {}
    ColumnRuleWidth& operator=(const ColumnRuleWidth& other) { inner_ = other.inner_; return *this; }
    ~ColumnRuleWidth() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTextIndent {
private:
    AzStyleTextIndent inner_;

public:
    StyleTextIndent(AzStyleTextIndent inner) : inner_(inner) {}
    StyleTextIndent(const StyleTextIndent& other) : inner_(other.inner_) {}
    StyleTextIndent& operator=(const StyleTextIndent& other) { inner_ = other.inner_; return *this; }
    ~StyleTextIndent() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutBorderSpacing {
private:
    AzLayoutBorderSpacing inner_;

public:
    LayoutBorderSpacing(AzLayoutBorderSpacing inner) : inner_(inner) {}
    LayoutBorderSpacing(const LayoutBorderSpacing& other) : inner_(other.inner_) {}
    LayoutBorderSpacing& operator=(const LayoutBorderSpacing& other) { inner_ = other.inner_; return *this; }
    ~LayoutBorderSpacing() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutPaddingInlineStart {
private:
    AzLayoutPaddingInlineStart inner_;

public:
    LayoutPaddingInlineStart(AzLayoutPaddingInlineStart inner) : inner_(inner) {}
    LayoutPaddingInlineStart(const LayoutPaddingInlineStart& other) : inner_(other.inner_) {}
    LayoutPaddingInlineStart& operator=(const LayoutPaddingInlineStart& other) { inner_ = other.inner_; return *this; }
    ~LayoutPaddingInlineStart() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutColumnGap {
private:
    AzLayoutColumnGap inner_;

public:
    LayoutColumnGap(AzLayoutColumnGap inner) : inner_(inner) {}
    LayoutColumnGap(const LayoutColumnGap& other) : inner_(other.inner_) {}
    LayoutColumnGap& operator=(const LayoutColumnGap& other) { inner_ = other.inner_; return *this; }
    ~LayoutColumnGap() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutPaddingInlineEnd {
private:
    AzLayoutPaddingInlineEnd inner_;

public:
    LayoutPaddingInlineEnd(AzLayoutPaddingInlineEnd inner) : inner_(inner) {}
    LayoutPaddingInlineEnd(const LayoutPaddingInlineEnd& other) : inner_(other.inner_) {}
    LayoutPaddingInlineEnd& operator=(const LayoutPaddingInlineEnd& other) { inner_ = other.inner_; return *this; }
    ~LayoutPaddingInlineEnd() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutRowGap {
private:
    AzLayoutRowGap inner_;

public:
    LayoutRowGap(AzLayoutRowGap inner) : inner_(inner) {}
    LayoutRowGap(const LayoutRowGap& other) : inner_(other.inner_) {}
    LayoutRowGap& operator=(const LayoutRowGap& other) { inner_ = other.inner_; return *this; }
    ~LayoutRowGap() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutInsetBottom {
private:
    AzLayoutInsetBottom inner_;

public:
    LayoutInsetBottom(AzLayoutInsetBottom inner) : inner_(inner) {}
    LayoutInsetBottom(const LayoutInsetBottom& other) : inner_(other.inner_) {}
    LayoutInsetBottom& operator=(const LayoutInsetBottom& other) { inner_ = other.inner_; return *this; }
    ~LayoutInsetBottom() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SystemColors {
public:
    struct Proxy { AzSystemColors inner; Proxy(AzSystemColors p) : inner(p) {} };

private:
    mutable AzSystemColors inner_;

public:
    explicit SystemColors(AzSystemColors inner) : inner_(inner) {}
    SystemColors(const SystemColors& other) : inner_(other.inner_) { memset(const_cast<AzSystemColors*>(&other.inner_), 0, sizeof(other.inner_)); }
    SystemColors& operator=(const SystemColors& other) {
        AzSystemColors_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSystemColors*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SystemColors(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SystemColors& operator=(Proxy p) {
        AzSystemColors_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~SystemColors() { AzSystemColors_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CaretWidth {
private:
    AzCaretWidth inner_;

public:
    CaretWidth(AzCaretWidth inner) : inner_(inner) {}
    CaretWidth(const CaretWidth& other) : inner_(other.inner_) {}
    CaretWidth& operator=(const CaretWidth& other) { inner_ = other.inner_; return *this; }
    ~CaretWidth() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTabSize {
private:
    AzStyleTabSize inner_;

public:
    StyleTabSize(AzStyleTabSize inner) : inner_(inner) {}
    StyleTabSize(const StyleTabSize& other) : inner_(other.inner_) {}
    StyleTabSize& operator=(const StyleTabSize& other) { inner_ = other.inner_; return *this; }
    ~StyleTabSize() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleOverflowClipMargin {
private:
    AzStyleOverflowClipMargin inner_;

public:
    StyleOverflowClipMargin(AzStyleOverflowClipMargin inner) : inner_(inner) {}
    StyleOverflowClipMargin(const StyleOverflowClipMargin& other) : inner_(other.inner_) {}
    StyleOverflowClipMargin& operator=(const StyleOverflowClipMargin& other) { inner_ = other.inner_; return *this; }
    ~StyleOverflowClipMargin() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Texture {
public:
    struct Proxy { AzTexture inner; Proxy(AzTexture p) : inner(p) {} };

private:
    mutable AzTexture inner_;

public:
    explicit Texture(AzTexture inner) : inner_(inner) {}
    Texture(const Texture& other) : inner_(other.inner_) { memset(const_cast<AzTexture*>(&other.inner_), 0, sizeof(other.inner_)); }
    Texture& operator=(const Texture& other) {
        AzTexture_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTexture*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Texture(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Texture& operator=(Proxy p) {
        AzTexture_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Texture() { AzTexture_delete(&inner_); }

    static Texture create(AzGLuint texture_id, TextureFlags flags, AzPhysicalSizeU32 size, ColorU background_color, GlContextPtr gl_context, AzRawImageFormat format);
    static Texture allocate_rgba8(GlContextPtr gl_context, AzPhysicalSizeU32 size, ColorU background);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ImageMask {
public:
    struct Proxy { AzImageMask inner; Proxy(AzImageMask p) : inner(p) {} };

private:
    mutable AzImageMask inner_;

public:
    explicit ImageMask(AzImageMask inner) : inner_(inner) {}
    ImageMask(const ImageMask& other) : inner_(other.inner_) { memset(const_cast<AzImageMask*>(&other.inner_), 0, sizeof(other.inner_)); }
    ImageMask& operator=(const ImageMask& other) {
        AzImageMask_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzImageMask*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ImageMask(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ImageMask& operator=(Proxy p) {
        AzImageMask_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgStrokeStyle {
private:
    AzSvgStrokeStyle inner_;

public:
    SvgStrokeStyle(AzSvgStrokeStyle inner) : inner_(inner) {}
    SvgStrokeStyle(const SvgStrokeStyle& other) : inner_(other.inner_) {}
    SvgStrokeStyle& operator=(const SvgStrokeStyle& other) { inner_ = other.inner_; return *this; }
    ~SvgStrokeStyle() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class InstantPtr {
public:
    struct Proxy { AzInstantPtr inner; Proxy(AzInstantPtr p) : inner(p) {} };

private:
    mutable AzInstantPtr inner_;

public:
    explicit InstantPtr(AzInstantPtr inner) : inner_(inner) {}
    InstantPtr(const InstantPtr& other) : inner_(other.inner_) { memset(const_cast<AzInstantPtr*>(&other.inner_), 0, sizeof(other.inner_)); }
    InstantPtr& operator=(const InstantPtr& other) {
        AzInstantPtr_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzInstantPtr*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    InstantPtr(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    InstantPtr& operator=(Proxy p) {
        AzInstantPtr_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ListViewRowVec {
public:
    struct Proxy { AzListViewRowVec inner; Proxy(AzListViewRowVec p) : inner(p) {} };

private:
    mutable AzListViewRowVec inner_;

public:
    explicit ListViewRowVec(AzListViewRowVec inner) : inner_(inner) {}
    ListViewRowVec(const ListViewRowVec& other) : inner_(other.inner_) { memset(const_cast<AzListViewRowVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ListViewRowVec& operator=(const ListViewRowVec& other) {
        AzListViewRowVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzListViewRowVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ListViewRowVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ListViewRowVec& operator=(Proxy p) {
        AzListViewRowVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleFilterVec {
public:
    struct Proxy { AzStyleFilterVec inner; Proxy(AzStyleFilterVec p) : inner(p) {} };

private:
    mutable AzStyleFilterVec inner_;

public:
    explicit StyleFilterVec(AzStyleFilterVec inner) : inner_(inner) {}
    StyleFilterVec(const StyleFilterVec& other) : inner_(other.inner_) { memset(const_cast<AzStyleFilterVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyleFilterVec& operator=(const StyleFilterVec& other) {
        AzStyleFilterVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyleFilterVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyleFilterVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyleFilterVec& operator=(Proxy p) {
        AzStyleFilterVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AccessibilityStateVec {
public:
    struct Proxy { AzAccessibilityStateVec inner; Proxy(AzAccessibilityStateVec p) : inner(p) {} };

private:
    mutable AzAccessibilityStateVec inner_;

public:
    explicit AccessibilityStateVec(AzAccessibilityStateVec inner) : inner_(inner) {}
    AccessibilityStateVec(const AccessibilityStateVec& other) : inner_(other.inner_) { memset(const_cast<AzAccessibilityStateVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    AccessibilityStateVec& operator=(const AccessibilityStateVec& other) {
        AzAccessibilityStateVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzAccessibilityStateVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    AccessibilityStateVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    AccessibilityStateVec& operator=(Proxy p) {
        AzAccessibilityStateVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MenuItemVec {
public:
    struct Proxy { AzMenuItemVec inner; Proxy(AzMenuItemVec p) : inner(p) {} };

private:
    mutable AzMenuItemVec inner_;

public:
    explicit MenuItemVec(AzMenuItemVec inner) : inner_(inner) {}
    MenuItemVec(const MenuItemVec& other) : inner_(other.inner_) { memset(const_cast<AzMenuItemVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    MenuItemVec& operator=(const MenuItemVec& other) {
        AzMenuItemVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMenuItemVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MenuItemVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MenuItemVec& operator=(Proxy p) {
        AzMenuItemVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleFontFamilyVec {
public:
    struct Proxy { AzStyleFontFamilyVec inner; Proxy(AzStyleFontFamilyVec p) : inner(p) {} };

private:
    mutable AzStyleFontFamilyVec inner_;

public:
    explicit StyleFontFamilyVec(AzStyleFontFamilyVec inner) : inner_(inner) {}
    StyleFontFamilyVec(const StyleFontFamilyVec& other) : inner_(other.inner_) { memset(const_cast<AzStyleFontFamilyVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyleFontFamilyVec& operator=(const StyleFontFamilyVec& other) {
        AzStyleFontFamilyVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyleFontFamilyVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyleFontFamilyVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyleFontFamilyVec& operator=(Proxy p) {
        AzStyleFontFamilyVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DomVec {
public:
    struct Proxy { AzDomVec inner; Proxy(AzDomVec p) : inner(p) {} };

private:
    mutable AzDomVec inner_;

public:
    explicit DomVec(AzDomVec inner) : inner_(inner) {}
    DomVec(const DomVec& other) : inner_(other.inner_) { memset(const_cast<AzDomVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    DomVec& operator=(const DomVec& other) {
        AzDomVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDomVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DomVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DomVec& operator=(Proxy p) {
        AzDomVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class IdOrClassVec {
public:
    struct Proxy { AzIdOrClassVec inner; Proxy(AzIdOrClassVec p) : inner(p) {} };

private:
    mutable AzIdOrClassVec inner_;

public:
    explicit IdOrClassVec(AzIdOrClassVec inner) : inner_(inner) {}
    IdOrClassVec(const IdOrClassVec& other) : inner_(other.inner_) { memset(const_cast<AzIdOrClassVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    IdOrClassVec& operator=(const IdOrClassVec& other) {
        AzIdOrClassVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzIdOrClassVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    IdOrClassVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    IdOrClassVec& operator=(Proxy p) {
        AzIdOrClassVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DynamicSelectorVec {
public:
    struct Proxy { AzDynamicSelectorVec inner; Proxy(AzDynamicSelectorVec p) : inner(p) {} };

private:
    mutable AzDynamicSelectorVec inner_;

public:
    explicit DynamicSelectorVec(AzDynamicSelectorVec inner) : inner_(inner) {}
    DynamicSelectorVec(const DynamicSelectorVec& other) : inner_(other.inner_) { memset(const_cast<AzDynamicSelectorVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    DynamicSelectorVec& operator=(const DynamicSelectorVec& other) {
        AzDynamicSelectorVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDynamicSelectorVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DynamicSelectorVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DynamicSelectorVec& operator=(Proxy p) {
        AzDynamicSelectorVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssPropertyWithConditionsVec {
public:
    struct Proxy { AzCssPropertyWithConditionsVec inner; Proxy(AzCssPropertyWithConditionsVec p) : inner(p) {} };

private:
    mutable AzCssPropertyWithConditionsVec inner_;

public:
    explicit CssPropertyWithConditionsVec(AzCssPropertyWithConditionsVec inner) : inner_(inner) {}
    CssPropertyWithConditionsVec(const CssPropertyWithConditionsVec& other) : inner_(other.inner_) { memset(const_cast<AzCssPropertyWithConditionsVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssPropertyWithConditionsVec& operator=(const CssPropertyWithConditionsVec& other) {
        AzCssPropertyWithConditionsVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssPropertyWithConditionsVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssPropertyWithConditionsVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssPropertyWithConditionsVec& operator=(Proxy p) {
        AzCssPropertyWithConditionsVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBackgroundContentVec {
public:
    struct Proxy { AzStyleBackgroundContentVec inner; Proxy(AzStyleBackgroundContentVec p) : inner(p) {} };

private:
    mutable AzStyleBackgroundContentVec inner_;

public:
    explicit StyleBackgroundContentVec(AzStyleBackgroundContentVec inner) : inner_(inner) {}
    StyleBackgroundContentVec(const StyleBackgroundContentVec& other) : inner_(other.inner_) { memset(const_cast<AzStyleBackgroundContentVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyleBackgroundContentVec& operator=(const StyleBackgroundContentVec& other) {
        AzStyleBackgroundContentVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyleBackgroundContentVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyleBackgroundContentVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyleBackgroundContentVec& operator=(Proxy p) {
        AzStyleBackgroundContentVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBackgroundPositionVec {
public:
    struct Proxy { AzStyleBackgroundPositionVec inner; Proxy(AzStyleBackgroundPositionVec p) : inner(p) {} };

private:
    mutable AzStyleBackgroundPositionVec inner_;

public:
    explicit StyleBackgroundPositionVec(AzStyleBackgroundPositionVec inner) : inner_(inner) {}
    StyleBackgroundPositionVec(const StyleBackgroundPositionVec& other) : inner_(other.inner_) { memset(const_cast<AzStyleBackgroundPositionVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyleBackgroundPositionVec& operator=(const StyleBackgroundPositionVec& other) {
        AzStyleBackgroundPositionVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyleBackgroundPositionVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyleBackgroundPositionVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyleBackgroundPositionVec& operator=(Proxy p) {
        AzStyleBackgroundPositionVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBackgroundRepeatVec {
public:
    struct Proxy { AzStyleBackgroundRepeatVec inner; Proxy(AzStyleBackgroundRepeatVec p) : inner(p) {} };

private:
    mutable AzStyleBackgroundRepeatVec inner_;

public:
    explicit StyleBackgroundRepeatVec(AzStyleBackgroundRepeatVec inner) : inner_(inner) {}
    StyleBackgroundRepeatVec(const StyleBackgroundRepeatVec& other) : inner_(other.inner_) { memset(const_cast<AzStyleBackgroundRepeatVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyleBackgroundRepeatVec& operator=(const StyleBackgroundRepeatVec& other) {
        AzStyleBackgroundRepeatVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyleBackgroundRepeatVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyleBackgroundRepeatVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyleBackgroundRepeatVec& operator=(Proxy p) {
        AzStyleBackgroundRepeatVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBackgroundSizeVec {
public:
    struct Proxy { AzStyleBackgroundSizeVec inner; Proxy(AzStyleBackgroundSizeVec p) : inner(p) {} };

private:
    mutable AzStyleBackgroundSizeVec inner_;

public:
    explicit StyleBackgroundSizeVec(AzStyleBackgroundSizeVec inner) : inner_(inner) {}
    StyleBackgroundSizeVec(const StyleBackgroundSizeVec& other) : inner_(other.inner_) { memset(const_cast<AzStyleBackgroundSizeVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyleBackgroundSizeVec& operator=(const StyleBackgroundSizeVec& other) {
        AzStyleBackgroundSizeVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyleBackgroundSizeVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyleBackgroundSizeVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyleBackgroundSizeVec& operator=(Proxy p) {
        AzStyleBackgroundSizeVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleTransformVec {
public:
    struct Proxy { AzStyleTransformVec inner; Proxy(AzStyleTransformVec p) : inner(p) {} };

private:
    mutable AzStyleTransformVec inner_;

public:
    explicit StyleTransformVec(AzStyleTransformVec inner) : inner_(inner) {}
    StyleTransformVec(const StyleTransformVec& other) : inner_(other.inner_) { memset(const_cast<AzStyleTransformVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyleTransformVec& operator=(const StyleTransformVec& other) {
        AzStyleTransformVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyleTransformVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyleTransformVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyleTransformVec& operator=(Proxy p) {
        AzStyleTransformVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgVertexVec {
public:
    struct Proxy { AzSvgVertexVec inner; Proxy(AzSvgVertexVec p) : inner(p) {} };

private:
    mutable AzSvgVertexVec inner_;

public:
    explicit SvgVertexVec(AzSvgVertexVec inner) : inner_(inner) {}
    SvgVertexVec(const SvgVertexVec& other) : inner_(other.inner_) { memset(const_cast<AzSvgVertexVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    SvgVertexVec& operator=(const SvgVertexVec& other) {
        AzSvgVertexVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSvgVertexVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SvgVertexVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SvgVertexVec& operator=(Proxy p) {
        AzSvgVertexVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class U32Vec {
public:
    struct Proxy { AzU32Vec inner; Proxy(AzU32Vec p) : inner(p) {} };

private:
    mutable AzU32Vec inner_;

public:
    explicit U32Vec(AzU32Vec inner) : inner_(inner) {}
    U32Vec(const U32Vec& other) : inner_(other.inner_) { memset(const_cast<AzU32Vec*>(&other.inner_), 0, sizeof(other.inner_)); }
    U32Vec& operator=(const U32Vec& other) {
        AzU32Vec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzU32Vec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    U32Vec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    U32Vec& operator=(Proxy p) {
        AzU32Vec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VirtualKeyCodeVec {
public:
    struct Proxy { AzVirtualKeyCodeVec inner; Proxy(AzVirtualKeyCodeVec p) : inner(p) {} };

private:
    mutable AzVirtualKeyCodeVec inner_;

public:
    explicit VirtualKeyCodeVec(AzVirtualKeyCodeVec inner) : inner_(inner) {}
    VirtualKeyCodeVec(const VirtualKeyCodeVec& other) : inner_(other.inner_) { memset(const_cast<AzVirtualKeyCodeVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    VirtualKeyCodeVec& operator=(const VirtualKeyCodeVec& other) {
        AzVirtualKeyCodeVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVirtualKeyCodeVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VirtualKeyCodeVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VirtualKeyCodeVec& operator=(Proxy p) {
        AzVirtualKeyCodeVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CascadeInfoVec {
public:
    struct Proxy { AzCascadeInfoVec inner; Proxy(AzCascadeInfoVec p) : inner(p) {} };

private:
    mutable AzCascadeInfoVec inner_;

public:
    explicit CascadeInfoVec(AzCascadeInfoVec inner) : inner_(inner) {}
    CascadeInfoVec(const CascadeInfoVec& other) : inner_(other.inner_) { memset(const_cast<AzCascadeInfoVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    CascadeInfoVec& operator=(const CascadeInfoVec& other) {
        AzCascadeInfoVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCascadeInfoVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CascadeInfoVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CascadeInfoVec& operator=(Proxy p) {
        AzCascadeInfoVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssDeclarationVec {
public:
    struct Proxy { AzCssDeclarationVec inner; Proxy(AzCssDeclarationVec p) : inner(p) {} };

private:
    mutable AzCssDeclarationVec inner_;

public:
    explicit CssDeclarationVec(AzCssDeclarationVec inner) : inner_(inner) {}
    CssDeclarationVec(const CssDeclarationVec& other) : inner_(other.inner_) { memset(const_cast<AzCssDeclarationVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssDeclarationVec& operator=(const CssDeclarationVec& other) {
        AzCssDeclarationVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssDeclarationVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssDeclarationVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssDeclarationVec& operator=(Proxy p) {
        AzCssDeclarationVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssPathSelectorVec {
public:
    struct Proxy { AzCssPathSelectorVec inner; Proxy(AzCssPathSelectorVec p) : inner(p) {} };

private:
    mutable AzCssPathSelectorVec inner_;

public:
    explicit CssPathSelectorVec(AzCssPathSelectorVec inner) : inner_(inner) {}
    CssPathSelectorVec(const CssPathSelectorVec& other) : inner_(other.inner_) { memset(const_cast<AzCssPathSelectorVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssPathSelectorVec& operator=(const CssPathSelectorVec& other) {
        AzCssPathSelectorVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssPathSelectorVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssPathSelectorVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssPathSelectorVec& operator=(Proxy p) {
        AzCssPathSelectorVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssVec {
public:
    struct Proxy { AzCssVec inner; Proxy(AzCssVec p) : inner(p) {} };

private:
    mutable AzCssVec inner_;

public:
    explicit CssVec(AzCssVec inner) : inner_(inner) {}
    CssVec(const CssVec& other) : inner_(other.inner_) { memset(const_cast<AzCssVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssVec& operator=(const CssVec& other) {
        AzCssVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssVec& operator=(Proxy p) {
        AzCssVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssRuleBlockVec {
public:
    struct Proxy { AzCssRuleBlockVec inner; Proxy(AzCssRuleBlockVec p) : inner(p) {} };

private:
    mutable AzCssRuleBlockVec inner_;

public:
    explicit CssRuleBlockVec(AzCssRuleBlockVec inner) : inner_(inner) {}
    CssRuleBlockVec(const CssRuleBlockVec& other) : inner_(other.inner_) { memset(const_cast<AzCssRuleBlockVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssRuleBlockVec& operator=(const CssRuleBlockVec& other) {
        AzCssRuleBlockVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssRuleBlockVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssRuleBlockVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssRuleBlockVec& operator=(Proxy p) {
        AzCssRuleBlockVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class U16Vec {
public:
    struct Proxy { AzU16Vec inner; Proxy(AzU16Vec p) : inner(p) {} };

private:
    mutable AzU16Vec inner_;

public:
    explicit U16Vec(AzU16Vec inner) : inner_(inner) {}
    U16Vec(const U16Vec& other) : inner_(other.inner_) { memset(const_cast<AzU16Vec*>(&other.inner_), 0, sizeof(other.inner_)); }
    U16Vec& operator=(const U16Vec& other) {
        AzU16Vec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzU16Vec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    U16Vec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    U16Vec& operator=(Proxy p) {
        AzU16Vec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class F32Vec {
public:
    struct Proxy { AzF32Vec inner; Proxy(AzF32Vec p) : inner(p) {} };

private:
    mutable AzF32Vec inner_;

public:
    explicit F32Vec(AzF32Vec inner) : inner_(inner) {}
    F32Vec(const F32Vec& other) : inner_(other.inner_) { memset(const_cast<AzF32Vec*>(&other.inner_), 0, sizeof(other.inner_)); }
    F32Vec& operator=(const F32Vec& other) {
        AzF32Vec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzF32Vec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    F32Vec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    F32Vec& operator=(Proxy p) {
        AzF32Vec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class U8Vec {
public:
    struct Proxy { AzU8Vec inner; Proxy(AzU8Vec p) : inner(p) {} };

private:
    mutable AzU8Vec inner_;

public:
    explicit U8Vec(AzU8Vec inner) : inner_(inner) {}
    U8Vec(const U8Vec& other) : inner_(other.inner_) { memset(const_cast<AzU8Vec*>(&other.inner_), 0, sizeof(other.inner_)); }
    U8Vec& operator=(const U8Vec& other) {
        AzU8Vec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzU8Vec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    U8Vec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    U8Vec& operator=(Proxy p) {
        AzU8Vec_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~U8Vec() { AzU8Vec_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(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]; }
};

class GLuintVec {
public:
    struct Proxy { AzGLuintVec inner; Proxy(AzGLuintVec p) : inner(p) {} };

private:
    mutable AzGLuintVec inner_;

public:
    explicit GLuintVec(AzGLuintVec inner) : inner_(inner) {}
    GLuintVec(const GLuintVec& other) : inner_(other.inner_) { memset(const_cast<AzGLuintVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    GLuintVec& operator=(const GLuintVec& other) {
        AzGLuintVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGLuintVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GLuintVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GLuintVec& operator=(Proxy p) {
        AzGLuintVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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]; }
};

class GLintVec {
public:
    struct Proxy { AzGLintVec inner; Proxy(AzGLintVec p) : inner(p) {} };

private:
    mutable AzGLintVec inner_;

public:
    explicit GLintVec(AzGLintVec inner) : inner_(inner) {}
    GLintVec(const GLintVec& other) : inner_(other.inner_) { memset(const_cast<AzGLintVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    GLintVec& operator=(const GLintVec& other) {
        AzGLintVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGLintVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GLintVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GLintVec& operator=(Proxy p) {
        AzGLintVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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]; }
};

class StringVec {
public:
    struct Proxy { AzStringVec inner; Proxy(AzStringVec p) : inner(p) {} };

private:
    mutable AzStringVec inner_;

public:
    explicit StringVec(AzStringVec inner) : inner_(inner) {}
    StringVec(const StringVec& other) : inner_(other.inner_) { memset(const_cast<AzStringVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    StringVec& operator=(const StringVec& other) {
        AzStringVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStringVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StringVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StringVec& operator=(Proxy p) {
        AzStringVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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]; }
};

class MimeTypeDataVec {
public:
    struct Proxy { AzMimeTypeDataVec inner; Proxy(AzMimeTypeDataVec p) : inner(p) {} };

private:
    mutable AzMimeTypeDataVec inner_;

public:
    explicit MimeTypeDataVec(AzMimeTypeDataVec inner) : inner_(inner) {}
    MimeTypeDataVec(const MimeTypeDataVec& other) : inner_(other.inner_) { memset(const_cast<AzMimeTypeDataVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    MimeTypeDataVec& operator=(const MimeTypeDataVec& other) {
        AzMimeTypeDataVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMimeTypeDataVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MimeTypeDataVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MimeTypeDataVec& operator=(Proxy p) {
        AzMimeTypeDataVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StringPairVec {
public:
    struct Proxy { AzStringPairVec inner; Proxy(AzStringPairVec p) : inner(p) {} };

private:
    mutable AzStringPairVec inner_;

public:
    explicit StringPairVec(AzStringPairVec inner) : inner_(inner) {}
    StringPairVec(const StringPairVec& other) : inner_(other.inner_) { memset(const_cast<AzStringPairVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    StringPairVec& operator=(const StringPairVec& other) {
        AzStringPairVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStringPairVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StringPairVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StringPairVec& operator=(Proxy p) {
        AzStringPairVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NormalizedLinearColorStopVec {
public:
    struct Proxy { AzNormalizedLinearColorStopVec inner; Proxy(AzNormalizedLinearColorStopVec p) : inner(p) {} };

private:
    mutable AzNormalizedLinearColorStopVec inner_;

public:
    explicit NormalizedLinearColorStopVec(AzNormalizedLinearColorStopVec inner) : inner_(inner) {}
    NormalizedLinearColorStopVec(const NormalizedLinearColorStopVec& other) : inner_(other.inner_) { memset(const_cast<AzNormalizedLinearColorStopVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    NormalizedLinearColorStopVec& operator=(const NormalizedLinearColorStopVec& other) {
        AzNormalizedLinearColorStopVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNormalizedLinearColorStopVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NormalizedLinearColorStopVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NormalizedLinearColorStopVec& operator=(Proxy p) {
        AzNormalizedLinearColorStopVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NormalizedRadialColorStopVec {
public:
    struct Proxy { AzNormalizedRadialColorStopVec inner; Proxy(AzNormalizedRadialColorStopVec p) : inner(p) {} };

private:
    mutable AzNormalizedRadialColorStopVec inner_;

public:
    explicit NormalizedRadialColorStopVec(AzNormalizedRadialColorStopVec inner) : inner_(inner) {}
    NormalizedRadialColorStopVec(const NormalizedRadialColorStopVec& other) : inner_(other.inner_) { memset(const_cast<AzNormalizedRadialColorStopVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    NormalizedRadialColorStopVec& operator=(const NormalizedRadialColorStopVec& other) {
        AzNormalizedRadialColorStopVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNormalizedRadialColorStopVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NormalizedRadialColorStopVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NormalizedRadialColorStopVec& operator=(Proxy p) {
        AzNormalizedRadialColorStopVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NodeHierarchyItemVec {
public:
    struct Proxy { AzNodeHierarchyItemVec inner; Proxy(AzNodeHierarchyItemVec p) : inner(p) {} };

private:
    mutable AzNodeHierarchyItemVec inner_;

public:
    explicit NodeHierarchyItemVec(AzNodeHierarchyItemVec inner) : inner_(inner) {}
    NodeHierarchyItemVec(const NodeHierarchyItemVec& other) : inner_(other.inner_) { memset(const_cast<AzNodeHierarchyItemVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    NodeHierarchyItemVec& operator=(const NodeHierarchyItemVec& other) {
        AzNodeHierarchyItemVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNodeHierarchyItemVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NodeHierarchyItemVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NodeHierarchyItemVec& operator=(Proxy p) {
        AzNodeHierarchyItemVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TagIdToNodeIdMappingVec {
public:
    struct Proxy { AzTagIdToNodeIdMappingVec inner; Proxy(AzTagIdToNodeIdMappingVec p) : inner(p) {} };

private:
    mutable AzTagIdToNodeIdMappingVec inner_;

public:
    explicit TagIdToNodeIdMappingVec(AzTagIdToNodeIdMappingVec inner) : inner_(inner) {}
    TagIdToNodeIdMappingVec(const TagIdToNodeIdMappingVec& other) : inner_(other.inner_) { memset(const_cast<AzTagIdToNodeIdMappingVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    TagIdToNodeIdMappingVec& operator=(const TagIdToNodeIdMappingVec& other) {
        AzTagIdToNodeIdMappingVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTagIdToNodeIdMappingVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TagIdToNodeIdMappingVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TagIdToNodeIdMappingVec& operator=(Proxy p) {
        AzTagIdToNodeIdMappingVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ParentWithNodeDepthVec {
public:
    struct Proxy { AzParentWithNodeDepthVec inner; Proxy(AzParentWithNodeDepthVec p) : inner(p) {} };

private:
    mutable AzParentWithNodeDepthVec inner_;

public:
    explicit ParentWithNodeDepthVec(AzParentWithNodeDepthVec inner) : inner_(inner) {}
    ParentWithNodeDepthVec(const ParentWithNodeDepthVec& other) : inner_(other.inner_) { memset(const_cast<AzParentWithNodeDepthVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ParentWithNodeDepthVec& operator=(const ParentWithNodeDepthVec& other) {
        AzParentWithNodeDepthVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzParentWithNodeDepthVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ParentWithNodeDepthVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ParentWithNodeDepthVec& operator=(Proxy p) {
        AzParentWithNodeDepthVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NodeDataVec {
public:
    struct Proxy { AzNodeDataVec inner; Proxy(AzNodeDataVec p) : inner(p) {} };

private:
    mutable AzNodeDataVec inner_;

public:
    explicit NodeDataVec(AzNodeDataVec inner) : inner_(inner) {}
    NodeDataVec(const NodeDataVec& other) : inner_(other.inner_) { memset(const_cast<AzNodeDataVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    NodeDataVec& operator=(const NodeDataVec& other) {
        AzNodeDataVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNodeDataVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NodeDataVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NodeDataVec& operator=(Proxy p) {
        AzNodeDataVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AttributeTypeVec {
public:
    struct Proxy { AzAttributeTypeVec inner; Proxy(AzAttributeTypeVec p) : inner(p) {} };

private:
    mutable AzAttributeTypeVec inner_;

public:
    explicit AttributeTypeVec(AzAttributeTypeVec inner) : inner_(inner) {}
    AttributeTypeVec(const AttributeTypeVec& other) : inner_(other.inner_) { memset(const_cast<AzAttributeTypeVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    AttributeTypeVec& operator=(const AttributeTypeVec& other) {
        AzAttributeTypeVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzAttributeTypeVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    AttributeTypeVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    AttributeTypeVec& operator=(Proxy p) {
        AzAttributeTypeVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CoreCallbackDataVec {
public:
    struct Proxy { AzCoreCallbackDataVec inner; Proxy(AzCoreCallbackDataVec p) : inner(p) {} };

private:
    mutable AzCoreCallbackDataVec inner_;

public:
    explicit CoreCallbackDataVec(AzCoreCallbackDataVec inner) : inner_(inner) {}
    CoreCallbackDataVec(const CoreCallbackDataVec& other) : inner_(other.inner_) { memset(const_cast<AzCoreCallbackDataVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    CoreCallbackDataVec& operator=(const CoreCallbackDataVec& other) {
        AzCoreCallbackDataVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCoreCallbackDataVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CoreCallbackDataVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CoreCallbackDataVec& operator=(Proxy p) {
        AzCoreCallbackDataVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AccessibilityActionVec {
public:
    struct Proxy { AzAccessibilityActionVec inner; Proxy(AzAccessibilityActionVec p) : inner(p) {} };

private:
    mutable AzAccessibilityActionVec inner_;

public:
    explicit AccessibilityActionVec(AzAccessibilityActionVec inner) : inner_(inner) {}
    AccessibilityActionVec(const AccessibilityActionVec& other) : inner_(other.inner_) { memset(const_cast<AzAccessibilityActionVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    AccessibilityActionVec& operator=(const AccessibilityActionVec& other) {
        AzAccessibilityActionVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzAccessibilityActionVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    AccessibilityActionVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    AccessibilityActionVec& operator=(Proxy p) {
        AzAccessibilityActionVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GridTrackSizingVec {
public:
    struct Proxy { AzGridTrackSizingVec inner; Proxy(AzGridTrackSizingVec p) : inner(p) {} };

private:
    mutable AzGridTrackSizingVec inner_;

public:
    explicit GridTrackSizingVec(AzGridTrackSizingVec inner) : inner_(inner) {}
    GridTrackSizingVec(const GridTrackSizingVec& other) : inner_(other.inner_) { memset(const_cast<AzGridTrackSizingVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    GridTrackSizingVec& operator=(const GridTrackSizingVec& other) {
        AzGridTrackSizingVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGridTrackSizingVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GridTrackSizingVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GridTrackSizingVec& operator=(Proxy p) {
        AzGridTrackSizingVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VertexAttributeVec {
public:
    struct Proxy { AzVertexAttributeVec inner; Proxy(AzVertexAttributeVec p) : inner(p) {} };

private:
    mutable AzVertexAttributeVec inner_;

public:
    explicit VertexAttributeVec(AzVertexAttributeVec inner) : inner_(inner) {}
    VertexAttributeVec(const VertexAttributeVec& other) : inner_(other.inner_) { memset(const_cast<AzVertexAttributeVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    VertexAttributeVec& operator=(const VertexAttributeVec& other) {
        AzVertexAttributeVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVertexAttributeVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VertexAttributeVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VertexAttributeVec& operator=(Proxy p) {
        AzVertexAttributeVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DebugMessageVec {
public:
    struct Proxy { AzDebugMessageVec inner; Proxy(AzDebugMessageVec p) : inner(p) {} };

private:
    mutable AzDebugMessageVec inner_;

public:
    explicit DebugMessageVec(AzDebugMessageVec inner) : inner_(inner) {}
    DebugMessageVec(const DebugMessageVec& other) : inner_(other.inner_) { memset(const_cast<AzDebugMessageVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    DebugMessageVec& operator=(const DebugMessageVec& other) {
        AzDebugMessageVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDebugMessageVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DebugMessageVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DebugMessageVec& operator=(Proxy p) {
        AzDebugMessageVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ShapePointVec {
public:
    struct Proxy { AzShapePointVec inner; Proxy(AzShapePointVec p) : inner(p) {} };

private:
    mutable AzShapePointVec inner_;

public:
    explicit ShapePointVec(AzShapePointVec inner) : inner_(inner) {}
    ShapePointVec(const ShapePointVec& other) : inner_(other.inner_) { memset(const_cast<AzShapePointVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ShapePointVec& operator=(const ShapePointVec& other) {
        AzShapePointVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzShapePointVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ShapePointVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ShapePointVec& operator=(Proxy p) {
        AzShapePointVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MonitorVec {
public:
    struct Proxy { AzMonitorVec inner; Proxy(AzMonitorVec p) : inner(p) {} };

private:
    mutable AzMonitorVec inner_;

public:
    explicit MonitorVec(AzMonitorVec inner) : inner_(inner) {}
    MonitorVec(const MonitorVec& other) : inner_(other.inner_) { memset(const_cast<AzMonitorVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    MonitorVec& operator=(const MonitorVec& other) {
        AzMonitorVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMonitorVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MonitorVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MonitorVec& operator=(Proxy p) {
        AzMonitorVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VideoModeVec {
public:
    struct Proxy { AzVideoModeVec inner; Proxy(AzVideoModeVec p) : inner(p) {} };

private:
    mutable AzVideoModeVec inner_;

public:
    explicit VideoModeVec(AzVideoModeVec inner) : inner_(inner) {}
    VideoModeVec(const VideoModeVec& other) : inner_(other.inner_) { memset(const_cast<AzVideoModeVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    VideoModeVec& operator=(const VideoModeVec& other) {
        AzVideoModeVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVideoModeVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VideoModeVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VideoModeVec& operator=(Proxy p) {
        AzVideoModeVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class XWindowTypeVec {
public:
    struct Proxy { AzXWindowTypeVec inner; Proxy(AzXWindowTypeVec p) : inner(p) {} };

private:
    mutable AzXWindowTypeVec inner_;

public:
    explicit XWindowTypeVec(AzXWindowTypeVec inner) : inner_(inner) {}
    XWindowTypeVec(const XWindowTypeVec& other) : inner_(other.inner_) { memset(const_cast<AzXWindowTypeVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    XWindowTypeVec& operator=(const XWindowTypeVec& other) {
        AzXWindowTypeVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzXWindowTypeVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    XWindowTypeVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    XWindowTypeVec& operator=(Proxy p) {
        AzXWindowTypeVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ScanCodeVec {
public:
    struct Proxy { AzScanCodeVec inner; Proxy(AzScanCodeVec p) : inner(p) {} };

private:
    mutable AzScanCodeVec inner_;

public:
    explicit ScanCodeVec(AzScanCodeVec inner) : inner_(inner) {}
    ScanCodeVec(const ScanCodeVec& other) : inner_(other.inner_) { memset(const_cast<AzScanCodeVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ScanCodeVec& operator=(const ScanCodeVec& other) {
        AzScanCodeVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzScanCodeVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ScanCodeVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ScanCodeVec& operator=(Proxy p) {
        AzScanCodeVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ContentGroupVec {
public:
    struct Proxy { AzContentGroupVec inner; Proxy(AzContentGroupVec p) : inner(p) {} };

private:
    mutable AzContentGroupVec inner_;

public:
    explicit ContentGroupVec(AzContentGroupVec inner) : inner_(inner) {}
    ContentGroupVec(const ContentGroupVec& other) : inner_(other.inner_) { memset(const_cast<AzContentGroupVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ContentGroupVec& operator=(const ContentGroupVec& other) {
        AzContentGroupVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzContentGroupVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ContentGroupVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ContentGroupVec& operator=(Proxy p) {
        AzContentGroupVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyledNodeVec {
public:
    struct Proxy { AzStyledNodeVec inner; Proxy(AzStyledNodeVec p) : inner(p) {} };

private:
    mutable AzStyledNodeVec inner_;

public:
    explicit StyledNodeVec(AzStyledNodeVec inner) : inner_(inner) {}
    StyledNodeVec(const StyledNodeVec& other) : inner_(other.inner_) { memset(const_cast<AzStyledNodeVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyledNodeVec& operator=(const StyledNodeVec& other) {
        AzStyledNodeVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyledNodeVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyledNodeVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyledNodeVec& operator=(Proxy p) {
        AzStyledNodeVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DomIdVec {
public:
    struct Proxy { AzDomIdVec inner; Proxy(AzDomIdVec p) : inner(p) {} };

private:
    mutable AzDomIdVec inner_;

public:
    explicit DomIdVec(AzDomIdVec inner) : inner_(inner) {}
    DomIdVec(const DomIdVec& other) : inner_(other.inner_) { memset(const_cast<AzDomIdVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    DomIdVec& operator=(const DomIdVec& other) {
        AzDomIdVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDomIdVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DomIdVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DomIdVec& operator=(Proxy p) {
        AzDomIdVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TimerIdVec {
public:
    struct Proxy { AzTimerIdVec inner; Proxy(AzTimerIdVec p) : inner(p) {} };

private:
    mutable AzTimerIdVec inner_;

public:
    explicit TimerIdVec(AzTimerIdVec inner) : inner_(inner) {}
    TimerIdVec(const TimerIdVec& other) : inner_(other.inner_) { memset(const_cast<AzTimerIdVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    TimerIdVec& operator=(const TimerIdVec& other) {
        AzTimerIdVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTimerIdVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TimerIdVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TimerIdVec& operator=(Proxy p) {
        AzTimerIdVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SelectionRangeVec {
public:
    struct Proxy { AzSelectionRangeVec inner; Proxy(AzSelectionRangeVec p) : inner(p) {} };

private:
    mutable AzSelectionRangeVec inner_;

public:
    explicit SelectionRangeVec(AzSelectionRangeVec inner) : inner_(inner) {}
    SelectionRangeVec(const SelectionRangeVec& other) : inner_(other.inner_) { memset(const_cast<AzSelectionRangeVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    SelectionRangeVec& operator=(const SelectionRangeVec& other) {
        AzSelectionRangeVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSelectionRangeVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SelectionRangeVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SelectionRangeVec& operator=(Proxy p) {
        AzSelectionRangeVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ThreadIdVec {
public:
    struct Proxy { AzThreadIdVec inner; Proxy(AzThreadIdVec p) : inner(p) {} };

private:
    mutable AzThreadIdVec inner_;

public:
    explicit ThreadIdVec(AzThreadIdVec inner) : inner_(inner) {}
    ThreadIdVec(const ThreadIdVec& other) : inner_(other.inner_) { memset(const_cast<AzThreadIdVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ThreadIdVec& operator=(const ThreadIdVec& other) {
        AzThreadIdVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzThreadIdVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ThreadIdVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ThreadIdVec& operator=(Proxy p) {
        AzThreadIdVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyledTextRunVec {
public:
    struct Proxy { AzStyledTextRunVec inner; Proxy(AzStyledTextRunVec p) : inner(p) {} };

private:
    mutable AzStyledTextRunVec inner_;

public:
    explicit StyledTextRunVec(AzStyledTextRunVec inner) : inner_(inner) {}
    StyledTextRunVec(const StyledTextRunVec& other) : inner_(other.inner_) { memset(const_cast<AzStyledTextRunVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyledTextRunVec& operator=(const StyledTextRunVec& other) {
        AzStyledTextRunVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyledTextRunVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyledTextRunVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyledTextRunVec& operator=(Proxy p) {
        AzStyledTextRunVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SelectionVec {
public:
    struct Proxy { AzSelectionVec inner; Proxy(AzSelectionVec p) : inner(p) {} };

private:
    mutable AzSelectionVec inner_;

public:
    explicit SelectionVec(AzSelectionVec inner) : inner_(inner) {}
    SelectionVec(const SelectionVec& other) : inner_(other.inner_) { memset(const_cast<AzSelectionVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    SelectionVec& operator=(const SelectionVec& other) {
        AzSelectionVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSelectionVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SelectionVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SelectionVec& operator=(Proxy p) {
        AzSelectionVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class HttpHeaderVec {
public:
    struct Proxy { AzHttpHeaderVec inner; Proxy(AzHttpHeaderVec p) : inner(p) {} };

private:
    mutable AzHttpHeaderVec inner_;

public:
    explicit HttpHeaderVec(AzHttpHeaderVec inner) : inner_(inner) {}
    HttpHeaderVec(const HttpHeaderVec& other) : inner_(other.inner_) { memset(const_cast<AzHttpHeaderVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    HttpHeaderVec& operator=(const HttpHeaderVec& other) {
        AzHttpHeaderVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzHttpHeaderVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    HttpHeaderVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    HttpHeaderVec& operator=(Proxy p) {
        AzHttpHeaderVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FmtArgVec {
public:
    struct Proxy { AzFmtArgVec inner; Proxy(AzFmtArgVec p) : inner(p) {} };

private:
    mutable AzFmtArgVec inner_;

public:
    explicit FmtArgVec(AzFmtArgVec inner) : inner_(inner) {}
    FmtArgVec(const FmtArgVec& other) : inner_(other.inner_) { memset(const_cast<AzFmtArgVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    FmtArgVec& operator=(const FmtArgVec& other) {
        AzFmtArgVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFmtArgVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FmtArgVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FmtArgVec& operator=(Proxy p) {
        AzFmtArgVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class JsonVec {
public:
    struct Proxy { AzJsonVec inner; Proxy(AzJsonVec p) : inner(p) {} };

private:
    mutable AzJsonVec inner_;

public:
    explicit JsonVec(AzJsonVec inner) : inner_(inner) {}
    JsonVec(const JsonVec& other) : inner_(other.inner_) { memset(const_cast<AzJsonVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    JsonVec& operator=(const JsonVec& other) {
        AzJsonVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzJsonVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    JsonVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    JsonVec& operator=(Proxy p) {
        AzJsonVec_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~JsonVec() { AzJsonVec_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DirEntryVec {
public:
    struct Proxy { AzDirEntryVec inner; Proxy(AzDirEntryVec p) : inner(p) {} };

private:
    mutable AzDirEntryVec inner_;

public:
    explicit DirEntryVec(AzDirEntryVec inner) : inner_(inner) {}
    DirEntryVec(const DirEntryVec& other) : inner_(other.inner_) { memset(const_cast<AzDirEntryVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    DirEntryVec& operator=(const DirEntryVec& other) {
        AzDirEntryVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDirEntryVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DirEntryVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DirEntryVec& operator=(Proxy p) {
        AzDirEntryVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class JsonKeyValueVec {
public:
    struct Proxy { AzJsonKeyValueVec inner; Proxy(AzJsonKeyValueVec p) : inner(p) {} };

private:
    mutable AzJsonKeyValueVec inner_;

public:
    explicit JsonKeyValueVec(AzJsonKeyValueVec inner) : inner_(inner) {}
    JsonKeyValueVec(const JsonKeyValueVec& other) : inner_(other.inner_) { memset(const_cast<AzJsonKeyValueVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    JsonKeyValueVec& operator=(const JsonKeyValueVec& other) {
        AzJsonKeyValueVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzJsonKeyValueVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    JsonKeyValueVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    JsonKeyValueVec& operator=(Proxy p) {
        AzJsonKeyValueVec_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~JsonKeyValueVec() { AzJsonKeyValueVec_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NamedFontVec {
public:
    struct Proxy { AzNamedFontVec inner; Proxy(AzNamedFontVec p) : inner(p) {} };

private:
    mutable AzNamedFontVec inner_;

public:
    explicit NamedFontVec(AzNamedFontVec inner) : inner_(inner) {}
    NamedFontVec(const NamedFontVec& other) : inner_(other.inner_) { memset(const_cast<AzNamedFontVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    NamedFontVec& operator=(const NamedFontVec& other) {
        AzNamedFontVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNamedFontVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NamedFontVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NamedFontVec& operator=(Proxy p) {
        AzNamedFontVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ExternalResourceVec {
public:
    struct Proxy { AzExternalResourceVec inner; Proxy(AzExternalResourceVec p) : inner(p) {} };

private:
    mutable AzExternalResourceVec inner_;

public:
    explicit ExternalResourceVec(AzExternalResourceVec inner) : inner_(inner) {}
    ExternalResourceVec(const ExternalResourceVec& other) : inner_(other.inner_) { memset(const_cast<AzExternalResourceVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ExternalResourceVec& operator=(const ExternalResourceVec& other) {
        AzExternalResourceVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzExternalResourceVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ExternalResourceVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ExternalResourceVec& operator=(Proxy p) {
        AzExternalResourceVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NodeHierarchyItemIdVec {
public:
    struct Proxy { AzNodeHierarchyItemIdVec inner; Proxy(AzNodeHierarchyItemIdVec p) : inner(p) {} };

private:
    mutable AzNodeHierarchyItemIdVec inner_;

public:
    explicit NodeHierarchyItemIdVec(AzNodeHierarchyItemIdVec inner) : inner_(inner) {}
    NodeHierarchyItemIdVec(const NodeHierarchyItemIdVec& other) : inner_(other.inner_) { memset(const_cast<AzNodeHierarchyItemIdVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    NodeHierarchyItemIdVec& operator=(const NodeHierarchyItemIdVec& other) {
        AzNodeHierarchyItemIdVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNodeHierarchyItemIdVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NodeHierarchyItemIdVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NodeHierarchyItemIdVec& operator=(Proxy p) {
        AzNodeHierarchyItemIdVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CalcAstItemVec {
public:
    struct Proxy { AzCalcAstItemVec inner; Proxy(AzCalcAstItemVec p) : inner(p) {} };

private:
    mutable AzCalcAstItemVec inner_;

public:
    explicit CalcAstItemVec(AzCalcAstItemVec inner) : inner_(inner) {}
    CalcAstItemVec(const CalcAstItemVec& other) : inner_(other.inner_) { memset(const_cast<AzCalcAstItemVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    CalcAstItemVec& operator=(const CalcAstItemVec& other) {
        AzCalcAstItemVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCalcAstItemVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CalcAstItemVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CalcAstItemVec& operator=(Proxy p) {
        AzCalcAstItemVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GridAreaDefinitionVec {
public:
    struct Proxy { AzGridAreaDefinitionVec inner; Proxy(AzGridAreaDefinitionVec p) : inner(p) {} };

private:
    mutable AzGridAreaDefinitionVec inner_;

public:
    explicit GridAreaDefinitionVec(AzGridAreaDefinitionVec inner) : inner_(inner) {}
    GridAreaDefinitionVec(const GridAreaDefinitionVec& other) : inner_(other.inner_) { memset(const_cast<AzGridAreaDefinitionVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    GridAreaDefinitionVec& operator=(const GridAreaDefinitionVec& other) {
        AzGridAreaDefinitionVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGridAreaDefinitionVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GridAreaDefinitionVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GridAreaDefinitionVec& operator=(Proxy p) {
        AzGridAreaDefinitionVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentDataFieldVec {
public:
    struct Proxy { AzComponentDataFieldVec inner; Proxy(AzComponentDataFieldVec p) : inner(p) {} };

private:
    mutable AzComponentDataFieldVec inner_;

public:
    explicit ComponentDataFieldVec(AzComponentDataFieldVec inner) : inner_(inner) {}
    ComponentDataFieldVec(const ComponentDataFieldVec& other) : inner_(other.inner_) { memset(const_cast<AzComponentDataFieldVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentDataFieldVec& operator=(const ComponentDataFieldVec& other) {
        AzComponentDataFieldVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentDataFieldVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentDataFieldVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentDataFieldVec& operator=(Proxy p) {
        AzComponentDataFieldVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentDefVec {
public:
    struct Proxy { AzComponentDefVec inner; Proxy(AzComponentDefVec p) : inner(p) {} };

private:
    mutable AzComponentDefVec inner_;

public:
    explicit ComponentDefVec(AzComponentDefVec inner) : inner_(inner) {}
    ComponentDefVec(const ComponentDefVec& other) : inner_(other.inner_) { memset(const_cast<AzComponentDefVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentDefVec& operator=(const ComponentDefVec& other) {
        AzComponentDefVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentDefVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentDefVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentDefVec& operator=(Proxy p) {
        AzComponentDefVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentLibraryVec {
public:
    struct Proxy { AzComponentLibraryVec inner; Proxy(AzComponentLibraryVec p) : inner(p) {} };

private:
    mutable AzComponentLibraryVec inner_;

public:
    explicit ComponentLibraryVec(AzComponentLibraryVec inner) : inner_(inner) {}
    ComponentLibraryVec(const ComponentLibraryVec& other) : inner_(other.inner_) { memset(const_cast<AzComponentLibraryVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentLibraryVec& operator=(const ComponentLibraryVec& other) {
        AzComponentLibraryVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentLibraryVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentLibraryVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentLibraryVec& operator=(Proxy p) {
        AzComponentLibraryVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentDataModelVec {
public:
    struct Proxy { AzComponentDataModelVec inner; Proxy(AzComponentDataModelVec p) : inner(p) {} };

private:
    mutable AzComponentDataModelVec inner_;

public:
    explicit ComponentDataModelVec(AzComponentDataModelVec inner) : inner_(inner) {}
    ComponentDataModelVec(const ComponentDataModelVec& other) : inner_(other.inner_) { memset(const_cast<AzComponentDataModelVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentDataModelVec& operator=(const ComponentDataModelVec& other) {
        AzComponentDataModelVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentDataModelVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentDataModelVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentDataModelVec& operator=(Proxy p) {
        AzComponentDataModelVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentEnumModelVec {
public:
    struct Proxy { AzComponentEnumModelVec inner; Proxy(AzComponentEnumModelVec p) : inner(p) {} };

private:
    mutable AzComponentEnumModelVec inner_;

public:
    explicit ComponentEnumModelVec(AzComponentEnumModelVec inner) : inner_(inner) {}
    ComponentEnumModelVec(const ComponentEnumModelVec& other) : inner_(other.inner_) { memset(const_cast<AzComponentEnumModelVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentEnumModelVec& operator=(const ComponentEnumModelVec& other) {
        AzComponentEnumModelVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentEnumModelVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentEnumModelVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentEnumModelVec& operator=(Proxy p) {
        AzComponentEnumModelVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentEnumVariantVec {
public:
    struct Proxy { AzComponentEnumVariantVec inner; Proxy(AzComponentEnumVariantVec p) : inner(p) {} };

private:
    mutable AzComponentEnumVariantVec inner_;

public:
    explicit ComponentEnumVariantVec(AzComponentEnumVariantVec inner) : inner_(inner) {}
    ComponentEnumVariantVec(const ComponentEnumVariantVec& other) : inner_(other.inner_) { memset(const_cast<AzComponentEnumVariantVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentEnumVariantVec& operator=(const ComponentEnumVariantVec& other) {
        AzComponentEnumVariantVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentEnumVariantVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentEnumVariantVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentEnumVariantVec& operator=(Proxy p) {
        AzComponentEnumVariantVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentCallbackArgVec {
public:
    struct Proxy { AzComponentCallbackArgVec inner; Proxy(AzComponentCallbackArgVec p) : inner(p) {} };

private:
    mutable AzComponentCallbackArgVec inner_;

public:
    explicit ComponentCallbackArgVec(AzComponentCallbackArgVec inner) : inner_(inner) {}
    ComponentCallbackArgVec(const ComponentCallbackArgVec& other) : inner_(other.inner_) { memset(const_cast<AzComponentCallbackArgVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentCallbackArgVec& operator=(const ComponentCallbackArgVec& other) {
        AzComponentCallbackArgVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentCallbackArgVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentCallbackArgVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentCallbackArgVec& operator=(Proxy p) {
        AzComponentCallbackArgVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentFieldOverrideVec {
public:
    struct Proxy { AzComponentFieldOverrideVec inner; Proxy(AzComponentFieldOverrideVec p) : inner(p) {} };

private:
    mutable AzComponentFieldOverrideVec inner_;

public:
    explicit ComponentFieldOverrideVec(AzComponentFieldOverrideVec inner) : inner_(inner) {}
    ComponentFieldOverrideVec(const ComponentFieldOverrideVec& other) : inner_(other.inner_) { memset(const_cast<AzComponentFieldOverrideVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentFieldOverrideVec& operator=(const ComponentFieldOverrideVec& other) {
        AzComponentFieldOverrideVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentFieldOverrideVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentFieldOverrideVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentFieldOverrideVec& operator=(Proxy p) {
        AzComponentFieldOverrideVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgPathElementVec {
public:
    struct Proxy { AzSvgPathElementVec inner; Proxy(AzSvgPathElementVec p) : inner(p) {} };

private:
    mutable AzSvgPathElementVec inner_;

public:
    explicit SvgPathElementVec(AzSvgPathElementVec inner) : inner_(inner) {}
    SvgPathElementVec(const SvgPathElementVec& other) : inner_(other.inner_) { memset(const_cast<AzSvgPathElementVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    SvgPathElementVec& operator=(const SvgPathElementVec& other) {
        AzSvgPathElementVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSvgPathElementVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SvgPathElementVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SvgPathElementVec& operator=(Proxy p) {
        AzSvgPathElementVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgPathVec {
public:
    struct Proxy { AzSvgPathVec inner; Proxy(AzSvgPathVec p) : inner(p) {} };

private:
    mutable AzSvgPathVec inner_;

public:
    explicit SvgPathVec(AzSvgPathVec inner) : inner_(inner) {}
    SvgPathVec(const SvgPathVec& other) : inner_(other.inner_) { memset(const_cast<AzSvgPathVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    SvgPathVec& operator=(const SvgPathVec& other) {
        AzSvgPathVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSvgPathVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SvgPathVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SvgPathVec& operator=(Proxy p) {
        AzSvgPathVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RibbonSectionVec {
public:
    struct Proxy { AzRibbonSectionVec inner; Proxy(AzRibbonSectionVec p) : inner(p) {} };

private:
    mutable AzRibbonSectionVec inner_;

public:
    explicit RibbonSectionVec(AzRibbonSectionVec inner) : inner_(inner) {}
    RibbonSectionVec(const RibbonSectionVec& other) : inner_(other.inner_) { memset(const_cast<AzRibbonSectionVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    RibbonSectionVec& operator=(const RibbonSectionVec& other) {
        AzRibbonSectionVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRibbonSectionVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RibbonSectionVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RibbonSectionVec& operator=(Proxy p) {
        AzRibbonSectionVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RibbonTabVec {
public:
    struct Proxy { AzRibbonTabVec inner; Proxy(AzRibbonTabVec p) : inner(p) {} };

private:
    mutable AzRibbonTabVec inner_;

public:
    explicit RibbonTabVec(AzRibbonTabVec inner) : inner_(inner) {}
    RibbonTabVec(const RibbonTabVec& other) : inner_(other.inner_) { memset(const_cast<AzRibbonTabVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    RibbonTabVec& operator=(const RibbonTabVec& other) {
        AzRibbonTabVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRibbonTabVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RibbonTabVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RibbonTabVec& operator=(Proxy p) {
        AzRibbonTabVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TreeViewNodeVec {
public:
    struct Proxy { AzTreeViewNodeVec inner; Proxy(AzTreeViewNodeVec p) : inner(p) {} };

private:
    mutable AzTreeViewNodeVec inner_;

public:
    explicit TreeViewNodeVec(AzTreeViewNodeVec inner) : inner_(inner) {}
    TreeViewNodeVec(const TreeViewNodeVec& other) : inner_(other.inner_) { memset(const_cast<AzTreeViewNodeVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    TreeViewNodeVec& operator=(const TreeViewNodeVec& other) {
        AzTreeViewNodeVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTreeViewNodeVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TreeViewNodeVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TreeViewNodeVec& operator=(Proxy p) {
        AzTreeViewNodeVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RouteVec {
public:
    struct Proxy { AzRouteVec inner; Proxy(AzRouteVec p) : inner(p) {} };

private:
    mutable AzRouteVec inner_;

public:
    explicit RouteVec(AzRouteVec inner) : inner_(inner) {}
    RouteVec(const RouteVec& other) : inner_(other.inner_) { memset(const_cast<AzRouteVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    RouteVec& operator=(const RouteVec& other) {
        AzRouteVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRouteVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RouteVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RouteVec& operator=(Proxy p) {
        AzRouteVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TouchPointVec {
public:
    struct Proxy { AzTouchPointVec inner; Proxy(AzTouchPointVec p) : inner(p) {} };

private:
    mutable AzTouchPointVec inner_;

public:
    explicit TouchPointVec(AzTouchPointVec inner) : inner_(inner) {}
    TouchPointVec(const TouchPointVec& other) : inner_(other.inner_) { memset(const_cast<AzTouchPointVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    TouchPointVec& operator=(const TouchPointVec& other) {
        AzTouchPointVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTouchPointVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TouchPointVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TouchPointVec& operator=(Proxy p) {
        AzTouchPointVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutRectVec {
public:
    struct Proxy { AzLayoutRectVec inner; Proxy(AzLayoutRectVec p) : inner(p) {} };

private:
    mutable AzLayoutRectVec inner_;

public:
    explicit LayoutRectVec(AzLayoutRectVec inner) : inner_(inner) {}
    LayoutRectVec(const LayoutRectVec& other) : inner_(other.inner_) { memset(const_cast<AzLayoutRectVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    LayoutRectVec& operator=(const LayoutRectVec& other) {
        AzLayoutRectVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzLayoutRectVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    LayoutRectVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    LayoutRectVec& operator=(Proxy p) {
        AzLayoutRectVec_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~LayoutRectVec() { AzLayoutRectVec_delete(&inner_); }

    static LayoutRectVec create();
    static LayoutRectVec with_capacity(size_t cap);
    static LayoutRectVec from_item(LayoutRect item);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DbValueVec {
public:
    struct Proxy { AzDbValueVec inner; Proxy(AzDbValueVec p) : inner(p) {} };

private:
    mutable AzDbValueVec inner_;

public:
    explicit DbValueVec(AzDbValueVec inner) : inner_(inner) {}
    DbValueVec(const DbValueVec& other) : inner_(other.inner_) { memset(const_cast<AzDbValueVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    DbValueVec& operator=(const DbValueVec& other) {
        AzDbValueVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDbValueVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DbValueVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DbValueVec& operator=(Proxy p) {
        AzDbValueVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LoadedFontVec {
public:
    struct Proxy { AzLoadedFontVec inner; Proxy(AzLoadedFontVec p) : inner(p) {} };

private:
    mutable AzLoadedFontVec inner_;

public:
    explicit LoadedFontVec(AzLoadedFontVec inner) : inner_(inner) {}
    LoadedFontVec(const LoadedFontVec& other) : inner_(other.inner_) { memset(const_cast<AzLoadedFontVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    LoadedFontVec& operator=(const LoadedFontVec& other) {
        AzLoadedFontVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzLoadedFontVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    LoadedFontVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    LoadedFontVec& operator=(Proxy p) {
        AzLoadedFontVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgRenderOptions {
private:
    AzSvgRenderOptions inner_;

public:
    SvgRenderOptions(AzSvgRenderOptions inner) : inner_(inner) {}
    SvgRenderOptions(const SvgRenderOptions& other) : inner_(other.inner_) {}
    SvgRenderOptions& operator=(const SvgRenderOptions& other) { inner_ = other.inner_; return *this; }
    ~SvgRenderOptions() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class IconStyleOptions {
public:
    struct Proxy { AzIconStyleOptions inner; Proxy(AzIconStyleOptions p) : inner(p) {} };

private:
    mutable AzIconStyleOptions inner_;

public:
    explicit IconStyleOptions(AzIconStyleOptions inner) : inner_(inner) {}
    IconStyleOptions(const IconStyleOptions& other) : inner_(other.inner_) { memset(const_cast<AzIconStyleOptions*>(&other.inner_), 0, sizeof(other.inner_)); }
    IconStyleOptions& operator=(const IconStyleOptions& other) {
        AzIconStyleOptions_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzIconStyleOptions*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    IconStyleOptions(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    IconStyleOptions& operator=(Proxy p) {
        AzIconStyleOptions_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~IconStyleOptions() { AzIconStyleOptions_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TaskBarIcon {
public:
    struct Proxy { AzTaskBarIcon inner; Proxy(AzTaskBarIcon p) : inner(p) {} };

private:
    mutable AzTaskBarIcon inner_;

public:
    explicit TaskBarIcon(AzTaskBarIcon inner) : inner_(inner) {}
    TaskBarIcon(const TaskBarIcon& other) : inner_(other.inner_) { memset(const_cast<AzTaskBarIcon*>(&other.inner_), 0, sizeof(other.inner_)); }
    TaskBarIcon& operator=(const TaskBarIcon& other) {
        AzTaskBarIcon_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTaskBarIcon*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TaskBarIcon(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TaskBarIcon& operator=(Proxy p) {
        AzTaskBarIcon_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SmallWindowIconBytes {
public:
    struct Proxy { AzSmallWindowIconBytes inner; Proxy(AzSmallWindowIconBytes p) : inner(p) {} };

private:
    mutable AzSmallWindowIconBytes inner_;

public:
    explicit SmallWindowIconBytes(AzSmallWindowIconBytes inner) : inner_(inner) {}
    SmallWindowIconBytes(const SmallWindowIconBytes& other) : inner_(other.inner_) { memset(const_cast<AzSmallWindowIconBytes*>(&other.inner_), 0, sizeof(other.inner_)); }
    SmallWindowIconBytes& operator=(const SmallWindowIconBytes& other) {
        AzSmallWindowIconBytes_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSmallWindowIconBytes*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SmallWindowIconBytes(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SmallWindowIconBytes& operator=(Proxy p) {
        AzSmallWindowIconBytes_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LargeWindowIconBytes {
public:
    struct Proxy { AzLargeWindowIconBytes inner; Proxy(AzLargeWindowIconBytes p) : inner(p) {} };

private:
    mutable AzLargeWindowIconBytes inner_;

public:
    explicit LargeWindowIconBytes(AzLargeWindowIconBytes inner) : inner_(inner) {}
    LargeWindowIconBytes(const LargeWindowIconBytes& other) : inner_(other.inner_) { memset(const_cast<AzLargeWindowIconBytes*>(&other.inner_), 0, sizeof(other.inner_)); }
    LargeWindowIconBytes& operator=(const LargeWindowIconBytes& other) {
        AzLargeWindowIconBytes_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzLargeWindowIconBytes*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    LargeWindowIconBytes(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    LargeWindowIconBytes& operator=(Proxy p) {
        AzLargeWindowIconBytes_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VirtualViewCallbackInfo {
public:
    struct Proxy { AzVirtualViewCallbackInfo inner; Proxy(AzVirtualViewCallbackInfo p) : inner(p) {} };

private:
    mutable AzVirtualViewCallbackInfo inner_;

public:
    explicit VirtualViewCallbackInfo(AzVirtualViewCallbackInfo inner) : inner_(inner) {}
    VirtualViewCallbackInfo(const VirtualViewCallbackInfo& other) : inner_(other.inner_) { memset(const_cast<AzVirtualViewCallbackInfo*>(&other.inner_), 0, sizeof(other.inner_)); }
    VirtualViewCallbackInfo& operator=(const VirtualViewCallbackInfo& other) {
        AzVirtualViewCallbackInfo_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVirtualViewCallbackInfo*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VirtualViewCallbackInfo(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VirtualViewCallbackInfo& operator=(Proxy p) {
        AzVirtualViewCallbackInfo_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutCallback {
public:
    struct Proxy { AzLayoutCallback inner; Proxy(AzLayoutCallback p) : inner(p) {} };

private:
    mutable AzLayoutCallback inner_;

public:
    explicit LayoutCallback(AzLayoutCallback inner) : inner_(inner) {}
    LayoutCallback(const LayoutCallback& other) : inner_(other.inner_) { memset(const_cast<AzLayoutCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    LayoutCallback& operator=(const LayoutCallback& other) {
        AzLayoutCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzLayoutCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    LayoutCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    LayoutCallback& operator=(Proxy p) {
        AzLayoutCallback_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~LayoutCallback() { AzLayoutCallback_delete(&inner_); }

    static LayoutCallback create(AzLayoutCallbackType cb);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LayoutCallbackInfo {
public:
    struct Proxy { AzLayoutCallbackInfo inner; Proxy(AzLayoutCallbackInfo p) : inner(p) {} };

private:
    mutable AzLayoutCallbackInfo inner_;

public:
    explicit LayoutCallbackInfo(AzLayoutCallbackInfo inner) : inner_(inner) {}
    LayoutCallbackInfo(const LayoutCallbackInfo& other) : inner_(other.inner_) { memset(const_cast<AzLayoutCallbackInfo*>(&other.inner_), 0, sizeof(other.inner_)); }
    LayoutCallbackInfo& operator=(const LayoutCallbackInfo& other) {
        AzLayoutCallbackInfo_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzLayoutCallbackInfo*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    LayoutCallbackInfo(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    LayoutCallbackInfo& operator=(Proxy p) {
        AzLayoutCallbackInfo_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TimerCallback {
public:
    struct Proxy { AzTimerCallback inner; Proxy(AzTimerCallback p) : inner(p) {} };

private:
    mutable AzTimerCallback inner_;

public:
    explicit TimerCallback(AzTimerCallback inner) : inner_(inner) {}
    TimerCallback(const TimerCallback& other) : inner_(other.inner_) { memset(const_cast<AzTimerCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    TimerCallback& operator=(const TimerCallback& other) {
        AzTimerCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTimerCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TimerCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TimerCallback& operator=(Proxy p) {
        AzTimerCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WriteBackCallback {
public:
    struct Proxy { AzWriteBackCallback inner; Proxy(AzWriteBackCallback p) : inner(p) {} };

private:
    mutable AzWriteBackCallback inner_;

public:
    explicit WriteBackCallback(AzWriteBackCallback inner) : inner_(inner) {}
    WriteBackCallback(const WriteBackCallback& other) : inner_(other.inner_) { memset(const_cast<AzWriteBackCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    WriteBackCallback& operator=(const WriteBackCallback& other) {
        AzWriteBackCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzWriteBackCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    WriteBackCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    WriteBackCallback& operator=(Proxy p) {
        AzWriteBackCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ThreadCallback {
public:
    struct Proxy { AzThreadCallback inner; Proxy(AzThreadCallback p) : inner(p) {} };

private:
    mutable AzThreadCallback inner_;

public:
    explicit ThreadCallback(AzThreadCallback inner) : inner_(inner) {}
    ThreadCallback(const ThreadCallback& other) : inner_(other.inner_) { memset(const_cast<AzThreadCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    ThreadCallback& operator=(const ThreadCallback& other) {
        AzThreadCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzThreadCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ThreadCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ThreadCallback& operator=(Proxy p) {
        AzThreadCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RenderImageCallbackInfo {
public:
    struct Proxy { AzRenderImageCallbackInfo inner; Proxy(AzRenderImageCallbackInfo p) : inner(p) {} };

private:
    mutable AzRenderImageCallbackInfo inner_;

public:
    explicit RenderImageCallbackInfo(AzRenderImageCallbackInfo inner) : inner_(inner) {}
    RenderImageCallbackInfo(const RenderImageCallbackInfo& other) : inner_(other.inner_) { memset(const_cast<AzRenderImageCallbackInfo*>(&other.inner_), 0, sizeof(other.inner_)); }
    RenderImageCallbackInfo& operator=(const RenderImageCallbackInfo& other) {
        AzRenderImageCallbackInfo_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRenderImageCallbackInfo*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RenderImageCallbackInfo(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RenderImageCallbackInfo& operator=(Proxy p) {
        AzRenderImageCallbackInfo_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ListViewOnColumnClickCallback {
public:
    struct Proxy { AzListViewOnColumnClickCallback inner; Proxy(AzListViewOnColumnClickCallback p) : inner(p) {} };

private:
    mutable AzListViewOnColumnClickCallback inner_;

public:
    explicit ListViewOnColumnClickCallback(AzListViewOnColumnClickCallback inner) : inner_(inner) {}
    ListViewOnColumnClickCallback(const ListViewOnColumnClickCallback& other) : inner_(other.inner_) { memset(const_cast<AzListViewOnColumnClickCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    ListViewOnColumnClickCallback& operator=(const ListViewOnColumnClickCallback& other) {
        AzListViewOnColumnClickCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzListViewOnColumnClickCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ListViewOnColumnClickCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ListViewOnColumnClickCallback& operator=(Proxy p) {
        AzListViewOnColumnClickCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CoreCallback {
public:
    struct Proxy { AzCoreCallback inner; Proxy(AzCoreCallback p) : inner(p) {} };

private:
    mutable AzCoreCallback inner_;

public:
    explicit CoreCallback(AzCoreCallback inner) : inner_(inner) {}
    CoreCallback(const CoreCallback& other) : inner_(other.inner_) { memset(const_cast<AzCoreCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    CoreCallback& operator=(const CoreCallback& other) {
        AzCoreCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCoreCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CoreCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CoreCallback& operator=(Proxy p) {
        AzCoreCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ListViewOnRowClickCallback {
public:
    struct Proxy { AzListViewOnRowClickCallback inner; Proxy(AzListViewOnRowClickCallback p) : inner(p) {} };

private:
    mutable AzListViewOnRowClickCallback inner_;

public:
    explicit ListViewOnRowClickCallback(AzListViewOnRowClickCallback inner) : inner_(inner) {}
    ListViewOnRowClickCallback(const ListViewOnRowClickCallback& other) : inner_(other.inner_) { memset(const_cast<AzListViewOnRowClickCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    ListViewOnRowClickCallback& operator=(const ListViewOnRowClickCallback& other) {
        AzListViewOnRowClickCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzListViewOnRowClickCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ListViewOnRowClickCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ListViewOnRowClickCallback& operator=(Proxy p) {
        AzListViewOnRowClickCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CheckBoxOnToggleCallback {
public:
    struct Proxy { AzCheckBoxOnToggleCallback inner; Proxy(AzCheckBoxOnToggleCallback p) : inner(p) {} };

private:
    mutable AzCheckBoxOnToggleCallback inner_;

public:
    explicit CheckBoxOnToggleCallback(AzCheckBoxOnToggleCallback inner) : inner_(inner) {}
    CheckBoxOnToggleCallback(const CheckBoxOnToggleCallback& other) : inner_(other.inner_) { memset(const_cast<AzCheckBoxOnToggleCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    CheckBoxOnToggleCallback& operator=(const CheckBoxOnToggleCallback& other) {
        AzCheckBoxOnToggleCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCheckBoxOnToggleCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CheckBoxOnToggleCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CheckBoxOnToggleCallback& operator=(Proxy p) {
        AzCheckBoxOnToggleCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DropDownOnChoiceChangeCallback {
public:
    struct Proxy { AzDropDownOnChoiceChangeCallback inner; Proxy(AzDropDownOnChoiceChangeCallback p) : inner(p) {} };

private:
    mutable AzDropDownOnChoiceChangeCallback inner_;

public:
    explicit DropDownOnChoiceChangeCallback(AzDropDownOnChoiceChangeCallback inner) : inner_(inner) {}
    DropDownOnChoiceChangeCallback(const DropDownOnChoiceChangeCallback& other) : inner_(other.inner_) { memset(const_cast<AzDropDownOnChoiceChangeCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    DropDownOnChoiceChangeCallback& operator=(const DropDownOnChoiceChangeCallback& other) {
        AzDropDownOnChoiceChangeCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDropDownOnChoiceChangeCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DropDownOnChoiceChangeCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DropDownOnChoiceChangeCallback& operator=(Proxy p) {
        AzDropDownOnChoiceChangeCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TabOnClickCallback {
public:
    struct Proxy { AzTabOnClickCallback inner; Proxy(AzTabOnClickCallback p) : inner(p) {} };

private:
    mutable AzTabOnClickCallback inner_;

public:
    explicit TabOnClickCallback(AzTabOnClickCallback inner) : inner_(inner) {}
    TabOnClickCallback(const TabOnClickCallback& other) : inner_(other.inner_) { memset(const_cast<AzTabOnClickCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    TabOnClickCallback& operator=(const TabOnClickCallback& other) {
        AzTabOnClickCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTabOnClickCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TabOnClickCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TabOnClickCallback& operator=(Proxy p) {
        AzTabOnClickCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ListViewOnLazyLoadScrollCallback {
public:
    struct Proxy { AzListViewOnLazyLoadScrollCallback inner; Proxy(AzListViewOnLazyLoadScrollCallback p) : inner(p) {} };

private:
    mutable AzListViewOnLazyLoadScrollCallback inner_;

public:
    explicit ListViewOnLazyLoadScrollCallback(AzListViewOnLazyLoadScrollCallback inner) : inner_(inner) {}
    ListViewOnLazyLoadScrollCallback(const ListViewOnLazyLoadScrollCallback& other) : inner_(other.inner_) { memset(const_cast<AzListViewOnLazyLoadScrollCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    ListViewOnLazyLoadScrollCallback& operator=(const ListViewOnLazyLoadScrollCallback& other) {
        AzListViewOnLazyLoadScrollCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzListViewOnLazyLoadScrollCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ListViewOnLazyLoadScrollCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ListViewOnLazyLoadScrollCallback& operator=(Proxy p) {
        AzListViewOnLazyLoadScrollCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ButtonOnClickCallback {
public:
    struct Proxy { AzButtonOnClickCallback inner; Proxy(AzButtonOnClickCallback p) : inner(p) {} };

private:
    mutable AzButtonOnClickCallback inner_;

public:
    explicit ButtonOnClickCallback(AzButtonOnClickCallback inner) : inner_(inner) {}
    ButtonOnClickCallback(const ButtonOnClickCallback& other) : inner_(other.inner_) { memset(const_cast<AzButtonOnClickCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    ButtonOnClickCallback& operator=(const ButtonOnClickCallback& other) {
        AzButtonOnClickCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzButtonOnClickCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ButtonOnClickCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ButtonOnClickCallback& operator=(Proxy p) {
        AzButtonOnClickCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class XmlAttributeMap {
public:
    struct Proxy { AzXmlAttributeMap inner; Proxy(AzXmlAttributeMap p) : inner(p) {} };

private:
    mutable AzXmlAttributeMap inner_;

public:
    explicit XmlAttributeMap(AzXmlAttributeMap inner) : inner_(inner) {}
    XmlAttributeMap(const XmlAttributeMap& other) : inner_(other.inner_) { memset(const_cast<AzXmlAttributeMap*>(&other.inner_), 0, sizeof(other.inner_)); }
    XmlAttributeMap& operator=(const XmlAttributeMap& other) {
        AzXmlAttributeMap_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzXmlAttributeMap*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    XmlAttributeMap(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    XmlAttributeMap& operator=(Proxy p) {
        AzXmlAttributeMap_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~XmlAttributeMap() { AzXmlAttributeMap_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Callback {
public:
    struct Proxy { AzCallback inner; Proxy(AzCallback p) : inner(p) {} };

private:
    mutable AzCallback inner_;

public:
    explicit Callback(AzCallback inner) : inner_(inner) {}
    Callback(const Callback& other) : inner_(other.inner_) { memset(const_cast<AzCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    Callback& operator=(const Callback& other) {
        AzCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Callback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Callback& operator=(Proxy p) {
        AzCallback_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Callback() { AzCallback_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class KeyboardState {
public:
    struct Proxy { AzKeyboardState inner; Proxy(AzKeyboardState p) : inner(p) {} };

private:
    mutable AzKeyboardState inner_;

public:
    explicit KeyboardState(AzKeyboardState inner) : inner_(inner) {}
    KeyboardState(const KeyboardState& other) : inner_(other.inner_) { memset(const_cast<AzKeyboardState*>(&other.inner_), 0, sizeof(other.inner_)); }
    KeyboardState& operator=(const KeyboardState& other) {
        AzKeyboardState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzKeyboardState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    KeyboardState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    KeyboardState& operator=(Proxy p) {
        AzKeyboardState_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~KeyboardState() { AzKeyboardState_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TouchState {
public:
    struct Proxy { AzTouchState inner; Proxy(AzTouchState p) : inner(p) {} };

private:
    mutable AzTouchState inner_;

public:
    explicit TouchState(AzTouchState inner) : inner_(inner) {}
    TouchState(const TouchState& other) : inner_(other.inner_) { memset(const_cast<AzTouchState*>(&other.inner_), 0, sizeof(other.inner_)); }
    TouchState& operator=(const TouchState& other) {
        AzTouchState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTouchState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TouchState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TouchState& operator=(Proxy p) {
        AzTouchState_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~TouchState() { AzTouchState_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CoreRenderImageCallback {
public:
    struct Proxy { AzCoreRenderImageCallback inner; Proxy(AzCoreRenderImageCallback p) : inner(p) {} };

private:
    mutable AzCoreRenderImageCallback inner_;

public:
    explicit CoreRenderImageCallback(AzCoreRenderImageCallback inner) : inner_(inner) {}
    CoreRenderImageCallback(const CoreRenderImageCallback& other) : inner_(other.inner_) { memset(const_cast<AzCoreRenderImageCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    CoreRenderImageCallback& operator=(const CoreRenderImageCallback& other) {
        AzCoreRenderImageCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCoreRenderImageCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CoreRenderImageCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CoreRenderImageCallback& operator=(Proxy p) {
        AzCoreRenderImageCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VirtualKeyCodeCombo {
public:
    struct Proxy { AzVirtualKeyCodeCombo inner; Proxy(AzVirtualKeyCodeCombo p) : inner(p) {} };

private:
    mutable AzVirtualKeyCodeCombo inner_;

public:
    explicit VirtualKeyCodeCombo(AzVirtualKeyCodeCombo inner) : inner_(inner) {}
    VirtualKeyCodeCombo(const VirtualKeyCodeCombo& other) : inner_(other.inner_) { memset(const_cast<AzVirtualKeyCodeCombo*>(&other.inner_), 0, sizeof(other.inner_)); }
    VirtualKeyCodeCombo& operator=(const VirtualKeyCodeCombo& other) {
        AzVirtualKeyCodeCombo_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVirtualKeyCodeCombo*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VirtualKeyCodeCombo(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VirtualKeyCodeCombo& operator=(Proxy p) {
        AzVirtualKeyCodeCombo_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextInputOnVirtualKeyDownCallback {
public:
    struct Proxy { AzTextInputOnVirtualKeyDownCallback inner; Proxy(AzTextInputOnVirtualKeyDownCallback p) : inner(p) {} };

private:
    mutable AzTextInputOnVirtualKeyDownCallback inner_;

public:
    explicit TextInputOnVirtualKeyDownCallback(AzTextInputOnVirtualKeyDownCallback inner) : inner_(inner) {}
    TextInputOnVirtualKeyDownCallback(const TextInputOnVirtualKeyDownCallback& other) : inner_(other.inner_) { memset(const_cast<AzTextInputOnVirtualKeyDownCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextInputOnVirtualKeyDownCallback& operator=(const TextInputOnVirtualKeyDownCallback& other) {
        AzTextInputOnVirtualKeyDownCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextInputOnVirtualKeyDownCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextInputOnVirtualKeyDownCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextInputOnVirtualKeyDownCallback& operator=(Proxy p) {
        AzTextInputOnVirtualKeyDownCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SelectionState {
public:
    struct Proxy { AzSelectionState inner; Proxy(AzSelectionState p) : inner(p) {} };

private:
    mutable AzSelectionState inner_;

public:
    explicit SelectionState(AzSelectionState inner) : inner_(inner) {}
    SelectionState(const SelectionState& other) : inner_(other.inner_) { memset(const_cast<AzSelectionState*>(&other.inner_), 0, sizeof(other.inner_)); }
    SelectionState& operator=(const SelectionState& other) {
        AzSelectionState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSelectionState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SelectionState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SelectionState& operator=(Proxy p) {
        AzSelectionState_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextOpExtendSelection {
public:
    struct Proxy { AzTextOpExtendSelection inner; Proxy(AzTextOpExtendSelection p) : inner(p) {} };

private:
    mutable AzTextOpExtendSelection inner_;

public:
    explicit TextOpExtendSelection(AzTextOpExtendSelection inner) : inner_(inner) {}
    TextOpExtendSelection(const TextOpExtendSelection& other) : inner_(other.inner_) { memset(const_cast<AzTextOpExtendSelection*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextOpExtendSelection& operator=(const TextOpExtendSelection& other) {
        AzTextOpExtendSelection_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextOpExtendSelection*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextOpExtendSelection(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextOpExtendSelection& operator=(Proxy p) {
        AzTextOpExtendSelection_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RenderImageCallback {
public:
    struct Proxy { AzRenderImageCallback inner; Proxy(AzRenderImageCallback p) : inner(p) {} };

private:
    mutable AzRenderImageCallback inner_;

public:
    explicit RenderImageCallback(AzRenderImageCallback inner) : inner_(inner) {}
    RenderImageCallback(const RenderImageCallback& other) : inner_(other.inner_) { memset(const_cast<AzRenderImageCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    RenderImageCallback& operator=(const RenderImageCallback& other) {
        AzRenderImageCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRenderImageCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RenderImageCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RenderImageCallback& operator=(Proxy p) {
        AzRenderImageCallback_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~RenderImageCallback() { AzRenderImageCallback_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextOpClearSelection {
public:
    struct Proxy { AzTextOpClearSelection inner; Proxy(AzTextOpClearSelection p) : inner(p) {} };

private:
    mutable AzTextOpClearSelection inner_;

public:
    explicit TextOpClearSelection(AzTextOpClearSelection inner) : inner_(inner) {}
    TextOpClearSelection(const TextOpClearSelection& other) : inner_(other.inner_) { memset(const_cast<AzTextOpClearSelection*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextOpClearSelection& operator=(const TextOpClearSelection& other) {
        AzTextOpClearSelection_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextOpClearSelection*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextOpClearSelection(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextOpClearSelection& operator=(Proxy p) {
        AzTextOpClearSelection_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DatasetMergeCallback {
public:
    struct Proxy { AzDatasetMergeCallback inner; Proxy(AzDatasetMergeCallback p) : inner(p) {} };

private:
    mutable AzDatasetMergeCallback inner_;

public:
    explicit DatasetMergeCallback(AzDatasetMergeCallback inner) : inner_(inner) {}
    DatasetMergeCallback(const DatasetMergeCallback& other) : inner_(other.inner_) { memset(const_cast<AzDatasetMergeCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    DatasetMergeCallback& operator=(const DatasetMergeCallback& other) {
        AzDatasetMergeCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDatasetMergeCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DatasetMergeCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DatasetMergeCallback& operator=(Proxy p) {
        AzDatasetMergeCallback_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~DatasetMergeCallback() { AzDatasetMergeCallback_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FocusVisuals {
private:
    AzFocusVisuals inner_;

public:
    FocusVisuals(AzFocusVisuals inner) : inner_(inner) {}
    FocusVisuals(const FocusVisuals& other) : inner_(other.inner_) {}
    FocusVisuals& operator=(const FocusVisuals& other) { inner_ = other.inner_; return *this; }
    ~FocusVisuals() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DragData {
public:
    struct Proxy { AzDragData inner; Proxy(AzDragData p) : inner(p) {} };

private:
    mutable AzDragData inner_;

public:
    explicit DragData(AzDragData inner) : inner_(inner) {}
    DragData(const DragData& other) : inner_(other.inner_) { memset(const_cast<AzDragData*>(&other.inner_), 0, sizeof(other.inner_)); }
    DragData& operator=(const DragData& other) {
        AzDragData_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDragData*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DragData(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DragData& operator=(Proxy p) {
        AzDragData_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~DragData() { AzDragData_delete(&inner_); }

    static DragData new_();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VirtualViewCallback {
public:
    struct Proxy { AzVirtualViewCallback inner; Proxy(AzVirtualViewCallback p) : inner(p) {} };

private:
    mutable AzVirtualViewCallback inner_;

public:
    explicit VirtualViewCallback(AzVirtualViewCallback inner) : inner_(inner) {}
    VirtualViewCallback(const VirtualViewCallback& other) : inner_(other.inner_) { memset(const_cast<AzVirtualViewCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    VirtualViewCallback& operator=(const VirtualViewCallback& other) {
        AzVirtualViewCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVirtualViewCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VirtualViewCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VirtualViewCallback& operator=(Proxy p) {
        AzVirtualViewCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RibbonOnTabClickCallback {
public:
    struct Proxy { AzRibbonOnTabClickCallback inner; Proxy(AzRibbonOnTabClickCallback p) : inner(p) {} };

private:
    mutable AzRibbonOnTabClickCallback inner_;

public:
    explicit RibbonOnTabClickCallback(AzRibbonOnTabClickCallback inner) : inner_(inner) {}
    RibbonOnTabClickCallback(const RibbonOnTabClickCallback& other) : inner_(other.inner_) { memset(const_cast<AzRibbonOnTabClickCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    RibbonOnTabClickCallback& operator=(const RibbonOnTabClickCallback& other) {
        AzRibbonOnTabClickCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRibbonOnTabClickCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RibbonOnTabClickCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RibbonOnTabClickCallback& operator=(Proxy p) {
        AzRibbonOnTabClickCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TreeViewOnNodeClickCallback {
public:
    struct Proxy { AzTreeViewOnNodeClickCallback inner; Proxy(AzTreeViewOnNodeClickCallback p) : inner(p) {} };

private:
    mutable AzTreeViewOnNodeClickCallback inner_;

public:
    explicit TreeViewOnNodeClickCallback(AzTreeViewOnNodeClickCallback inner) : inner_(inner) {}
    TreeViewOnNodeClickCallback(const TreeViewOnNodeClickCallback& other) : inner_(other.inner_) { memset(const_cast<AzTreeViewOnNodeClickCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    TreeViewOnNodeClickCallback& operator=(const TreeViewOnNodeClickCallback& other) {
        AzTreeViewOnNodeClickCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTreeViewOnNodeClickCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TreeViewOnNodeClickCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TreeViewOnNodeClickCallback& operator=(Proxy p) {
        AzTreeViewOnNodeClickCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class OnVideoFrameCallback {
public:
    struct Proxy { AzOnVideoFrameCallback inner; Proxy(AzOnVideoFrameCallback p) : inner(p) {} };

private:
    mutable AzOnVideoFrameCallback inner_;

public:
    explicit OnVideoFrameCallback(AzOnVideoFrameCallback inner) : inner_(inner) {}
    OnVideoFrameCallback(const OnVideoFrameCallback& other) : inner_(other.inner_) { memset(const_cast<AzOnVideoFrameCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    OnVideoFrameCallback& operator=(const OnVideoFrameCallback& other) {
        AzOnVideoFrameCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOnVideoFrameCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OnVideoFrameCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OnVideoFrameCallback& operator=(Proxy p) {
        AzOnVideoFrameCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MapPinTapCallback {
public:
    struct Proxy { AzMapPinTapCallback inner; Proxy(AzMapPinTapCallback p) : inner(p) {} };

private:
    mutable AzMapPinTapCallback inner_;

public:
    explicit MapPinTapCallback(AzMapPinTapCallback inner) : inner_(inner) {}
    MapPinTapCallback(const MapPinTapCallback& other) : inner_(other.inner_) { memset(const_cast<AzMapPinTapCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    MapPinTapCallback& operator=(const MapPinTapCallback& other) {
        AzMapPinTapCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMapPinTapCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MapPinTapCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MapPinTapCallback& operator=(Proxy p) {
        AzMapPinTapCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class OnAudioFrameCallback {
public:
    struct Proxy { AzOnAudioFrameCallback inner; Proxy(AzOnAudioFrameCallback p) : inner(p) {} };

private:
    mutable AzOnAudioFrameCallback inner_;

public:
    explicit OnAudioFrameCallback(AzOnAudioFrameCallback inner) : inner_(inner) {}
    OnAudioFrameCallback(const OnAudioFrameCallback& other) : inner_(other.inner_) { memset(const_cast<AzOnAudioFrameCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    OnAudioFrameCallback& operator=(const OnAudioFrameCallback& other) {
        AzOnAudioFrameCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOnAudioFrameCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OnAudioFrameCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OnAudioFrameCallback& operator=(Proxy p) {
        AzOnAudioFrameCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Menu {
public:
    struct Proxy { AzMenu inner; Proxy(AzMenu p) : inner(p) {} };

private:
    mutable AzMenu inner_;

public:
    explicit Menu(AzMenu inner) : inner_(inner) {}
    Menu(const Menu& other) : inner_(other.inner_) { memset(const_cast<AzMenu*>(&other.inner_), 0, sizeof(other.inner_)); }
    Menu& operator=(const Menu& other) {
        AzMenu_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMenu*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Menu(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Menu& operator=(Proxy p) {
        AzMenu_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Menu() { AzMenu_delete(&inner_); }

    static Menu create(MenuItemVec items);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Css {
public:
    struct Proxy { AzCss inner; Proxy(AzCss p) : inner(p) {} };

private:
    mutable AzCss inner_;

public:
    explicit Css(AzCss inner) : inner_(inner) {}
    Css(const Css& other) : inner_(other.inner_) { memset(const_cast<AzCss*>(&other.inner_), 0, sizeof(other.inner_)); }
    Css& operator=(const Css& other) {
        AzCss_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCss*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Css(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Css& operator=(Proxy p) {
        AzCss_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Css() { AzCss_delete(&inner_); }

    static Css empty();
    static Css from_string(String s);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBoxShadow {
private:
    AzStyleBoxShadow inner_;

public:
    StyleBoxShadow(AzStyleBoxShadow inner) : inner_(inner) {}
    StyleBoxShadow(const StyleBoxShadow& other) : inner_(other.inner_) {}
    StyleBoxShadow& operator=(const StyleBoxShadow& other) { inner_ = other.inner_; return *this; }
    ~StyleBoxShadow() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LinearGradient {
public:
    struct Proxy { AzLinearGradient inner; Proxy(AzLinearGradient p) : inner(p) {} };

private:
    mutable AzLinearGradient inner_;

public:
    explicit LinearGradient(AzLinearGradient inner) : inner_(inner) {}
    LinearGradient(const LinearGradient& other) : inner_(other.inner_) { memset(const_cast<AzLinearGradient*>(&other.inner_), 0, sizeof(other.inner_)); }
    LinearGradient& operator=(const LinearGradient& other) {
        AzLinearGradient_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzLinearGradient*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    LinearGradient(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    LinearGradient& operator=(Proxy p) {
        AzLinearGradient_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~LinearGradient() { AzLinearGradient_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleBackgroundPosition {
private:
    AzStyleBackgroundPosition inner_;

public:
    StyleBackgroundPosition(AzStyleBackgroundPosition inner) : inner_(inner) {}
    StyleBackgroundPosition(const StyleBackgroundPosition& other) : inner_(other.inner_) {}
    StyleBackgroundPosition& operator=(const StyleBackgroundPosition& other) { inner_ = other.inner_; return *this; }
    ~StyleBackgroundPosition() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GridTemplate {
public:
    struct Proxy { AzGridTemplate inner; Proxy(AzGridTemplate p) : inner(p) {} };

private:
    mutable AzGridTemplate inner_;

public:
    explicit GridTemplate(AzGridTemplate inner) : inner_(inner) {}
    GridTemplate(const GridTemplate& other) : inner_(other.inner_) { memset(const_cast<AzGridTemplate*>(&other.inner_), 0, sizeof(other.inner_)); }
    GridTemplate& operator=(const GridTemplate& other) {
        AzGridTemplate_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGridTemplate*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GridTemplate(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GridTemplate& operator=(Proxy p) {
        AzGridTemplate_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~GridTemplate() { AzGridTemplate_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GridAutoTracks {
public:
    struct Proxy { AzGridAutoTracks inner; Proxy(AzGridAutoTracks p) : inner(p) {} };

private:
    mutable AzGridAutoTracks inner_;

public:
    explicit GridAutoTracks(AzGridAutoTracks inner) : inner_(inner) {}
    GridAutoTracks(const GridAutoTracks& other) : inner_(other.inner_) { memset(const_cast<AzGridAutoTracks*>(&other.inner_), 0, sizeof(other.inner_)); }
    GridAutoTracks& operator=(const GridAutoTracks& other) {
        AzGridAutoTracks_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGridAutoTracks*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GridAutoTracks(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GridAutoTracks& operator=(Proxy p) {
        AzGridAutoTracks_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~GridAutoTracks() { AzGridAutoTracks_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyledDom {
public:
    struct Proxy { AzStyledDom inner; Proxy(AzStyledDom p) : inner(p) {} };

private:
    mutable AzStyledDom inner_;

public:
    explicit StyledDom(AzStyledDom inner) : inner_(inner) {}
    StyledDom(const StyledDom& other) : inner_(other.inner_) { memset(const_cast<AzStyledDom*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyledDom& operator=(const StyledDom& other) {
        AzStyledDom_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyledDom*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyledDom(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyledDom& operator=(Proxy p) {
        AzStyledDom_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~StyledDom() { AzStyledDom_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VertexLayout {
public:
    struct Proxy { AzVertexLayout inner; Proxy(AzVertexLayout p) : inner(p) {} };

private:
    mutable AzVertexLayout inner_;

public:
    explicit VertexLayout(AzVertexLayout inner) : inner_(inner) {}
    VertexLayout(const VertexLayout& other) : inner_(other.inner_) { memset(const_cast<AzVertexLayout*>(&other.inner_), 0, sizeof(other.inner_)); }
    VertexLayout& operator=(const VertexLayout& other) {
        AzVertexLayout_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVertexLayout*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VertexLayout(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VertexLayout& operator=(Proxy p) {
        AzVertexLayout_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ContentGroup {
public:
    struct Proxy { AzContentGroup inner; Proxy(AzContentGroup p) : inner(p) {} };

private:
    mutable AzContentGroup inner_;

public:
    explicit ContentGroup(AzContentGroup inner) : inner_(inner) {}
    ContentGroup(const ContentGroup& other) : inner_(other.inner_) { memset(const_cast<AzContentGroup*>(&other.inner_), 0, sizeof(other.inner_)); }
    ContentGroup& operator=(const ContentGroup& other) {
        AzContentGroup_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzContentGroup*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ContentGroup(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ContentGroup& operator=(Proxy p) {
        AzContentGroup_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SafeAreaInsets {
private:
    AzSafeAreaInsets inner_;

public:
    SafeAreaInsets(AzSafeAreaInsets inner) : inner_(inner) {}
    SafeAreaInsets(const SafeAreaInsets& other) : inner_(other.inner_) {}
    SafeAreaInsets& operator=(const SafeAreaInsets& other) { inner_ = other.inner_; return *this; }
    ~SafeAreaInsets() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GridTemplateAreas {
public:
    struct Proxy { AzGridTemplateAreas inner; Proxy(AzGridTemplateAreas p) : inner(p) {} };

private:
    mutable AzGridTemplateAreas inner_;

public:
    explicit GridTemplateAreas(AzGridTemplateAreas inner) : inner_(inner) {}
    GridTemplateAreas(const GridTemplateAreas& other) : inner_(other.inner_) { memset(const_cast<AzGridTemplateAreas*>(&other.inner_), 0, sizeof(other.inner_)); }
    GridTemplateAreas& operator=(const GridTemplateAreas& other) {
        AzGridTemplateAreas_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGridTemplateAreas*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GridTemplateAreas(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GridTemplateAreas& operator=(Proxy p) {
        AzGridTemplateAreas_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~GridTemplateAreas() { AzGridTemplateAreas_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleObjectPosition {
private:
    AzStyleObjectPosition inner_;

public:
    StyleObjectPosition(AzStyleObjectPosition inner) : inner_(inner) {}
    StyleObjectPosition(const StyleObjectPosition& other) : inner_(other.inner_) {}
    StyleObjectPosition& operator=(const StyleObjectPosition& other) { inner_ = other.inner_; return *this; }
    ~StyleObjectPosition() {}

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FileInputOnPathChangeCallback {
public:
    struct Proxy { AzFileInputOnPathChangeCallback inner; Proxy(AzFileInputOnPathChangeCallback p) : inner(p) {} };

private:
    mutable AzFileInputOnPathChangeCallback inner_;

public:
    explicit FileInputOnPathChangeCallback(AzFileInputOnPathChangeCallback inner) : inner_(inner) {}
    FileInputOnPathChangeCallback(const FileInputOnPathChangeCallback& other) : inner_(other.inner_) { memset(const_cast<AzFileInputOnPathChangeCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    FileInputOnPathChangeCallback& operator=(const FileInputOnPathChangeCallback& other) {
        AzFileInputOnPathChangeCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFileInputOnPathChangeCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FileInputOnPathChangeCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FileInputOnPathChangeCallback& operator=(Proxy p) {
        AzFileInputOnPathChangeCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ColorInputOnValueChangeCallback {
public:
    struct Proxy { AzColorInputOnValueChangeCallback inner; Proxy(AzColorInputOnValueChangeCallback p) : inner(p) {} };

private:
    mutable AzColorInputOnValueChangeCallback inner_;

public:
    explicit ColorInputOnValueChangeCallback(AzColorInputOnValueChangeCallback inner) : inner_(inner) {}
    ColorInputOnValueChangeCallback(const ColorInputOnValueChangeCallback& other) : inner_(other.inner_) { memset(const_cast<AzColorInputOnValueChangeCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    ColorInputOnValueChangeCallback& operator=(const ColorInputOnValueChangeCallback& other) {
        AzColorInputOnValueChangeCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzColorInputOnValueChangeCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ColorInputOnValueChangeCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ColorInputOnValueChangeCallback& operator=(Proxy p) {
        AzColorInputOnValueChangeCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextInputOnTextInputCallback {
public:
    struct Proxy { AzTextInputOnTextInputCallback inner; Proxy(AzTextInputOnTextInputCallback p) : inner(p) {} };

private:
    mutable AzTextInputOnTextInputCallback inner_;

public:
    explicit TextInputOnTextInputCallback(AzTextInputOnTextInputCallback inner) : inner_(inner) {}
    TextInputOnTextInputCallback(const TextInputOnTextInputCallback& other) : inner_(other.inner_) { memset(const_cast<AzTextInputOnTextInputCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextInputOnTextInputCallback& operator=(const TextInputOnTextInputCallback& other) {
        AzTextInputOnTextInputCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextInputOnTextInputCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextInputOnTextInputCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextInputOnTextInputCallback& operator=(Proxy p) {
        AzTextInputOnTextInputCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextInputOnFocusLostCallback {
public:
    struct Proxy { AzTextInputOnFocusLostCallback inner; Proxy(AzTextInputOnFocusLostCallback p) : inner(p) {} };

private:
    mutable AzTextInputOnFocusLostCallback inner_;

public:
    explicit TextInputOnFocusLostCallback(AzTextInputOnFocusLostCallback inner) : inner_(inner) {}
    TextInputOnFocusLostCallback(const TextInputOnFocusLostCallback& other) : inner_(other.inner_) { memset(const_cast<AzTextInputOnFocusLostCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextInputOnFocusLostCallback& operator=(const TextInputOnFocusLostCallback& other) {
        AzTextInputOnFocusLostCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextInputOnFocusLostCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextInputOnFocusLostCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextInputOnFocusLostCallback& operator=(Proxy p) {
        AzTextInputOnFocusLostCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NumberInputOnValueChangeCallback {
public:
    struct Proxy { AzNumberInputOnValueChangeCallback inner; Proxy(AzNumberInputOnValueChangeCallback p) : inner(p) {} };

private:
    mutable AzNumberInputOnValueChangeCallback inner_;

public:
    explicit NumberInputOnValueChangeCallback(AzNumberInputOnValueChangeCallback inner) : inner_(inner) {}
    NumberInputOnValueChangeCallback(const NumberInputOnValueChangeCallback& other) : inner_(other.inner_) { memset(const_cast<AzNumberInputOnValueChangeCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    NumberInputOnValueChangeCallback& operator=(const NumberInputOnValueChangeCallback& other) {
        AzNumberInputOnValueChangeCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNumberInputOnValueChangeCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NumberInputOnValueChangeCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NumberInputOnValueChangeCallback& operator=(Proxy p) {
        AzNumberInputOnValueChangeCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NumberInputOnFocusLostCallback {
public:
    struct Proxy { AzNumberInputOnFocusLostCallback inner; Proxy(AzNumberInputOnFocusLostCallback p) : inner(p) {} };

private:
    mutable AzNumberInputOnFocusLostCallback inner_;

public:
    explicit NumberInputOnFocusLostCallback(AzNumberInputOnFocusLostCallback inner) : inner_(inner) {}
    NumberInputOnFocusLostCallback(const NumberInputOnFocusLostCallback& other) : inner_(other.inner_) { memset(const_cast<AzNumberInputOnFocusLostCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    NumberInputOnFocusLostCallback& operator=(const NumberInputOnFocusLostCallback& other) {
        AzNumberInputOnFocusLostCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNumberInputOnFocusLostCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NumberInputOnFocusLostCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NumberInputOnFocusLostCallback& operator=(Proxy p) {
        AzNumberInputOnFocusLostCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ProgressBar {
public:
    struct Proxy { AzProgressBar inner; Proxy(AzProgressBar p) : inner(p) {} };

private:
    mutable AzProgressBar inner_;

public:
    explicit ProgressBar(AzProgressBar inner) : inner_(inner) {}
    ProgressBar(const ProgressBar& other) : inner_(other.inner_) { memset(const_cast<AzProgressBar*>(&other.inner_), 0, sizeof(other.inner_)); }
    ProgressBar& operator=(const ProgressBar& other) {
        AzProgressBar_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzProgressBar*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ProgressBar(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ProgressBar& operator=(Proxy p) {
        AzProgressBar_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ProgressBar() { AzProgressBar_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ListViewState {
public:
    struct Proxy { AzListViewState inner; Proxy(AzListViewState p) : inner(p) {} };

private:
    mutable AzListViewState inner_;

public:
    explicit ListViewState(AzListViewState inner) : inner_(inner) {}
    ListViewState(const ListViewState& other) : inner_(other.inner_) { memset(const_cast<AzListViewState*>(&other.inner_), 0, sizeof(other.inner_)); }
    ListViewState& operator=(const ListViewState& other) {
        AzListViewState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzListViewState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ListViewState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ListViewState& operator=(Proxy p) {
        AzListViewState_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VideoFrame {
public:
    struct Proxy { AzVideoFrame inner; Proxy(AzVideoFrame p) : inner(p) {} };

private:
    mutable AzVideoFrame inner_;

public:
    explicit VideoFrame(AzVideoFrame inner) : inner_(inner) {}
    VideoFrame(const VideoFrame& other) : inner_(other.inner_) { memset(const_cast<AzVideoFrame*>(&other.inner_), 0, sizeof(other.inner_)); }
    VideoFrame& operator=(const VideoFrame& other) {
        AzVideoFrame_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVideoFrame*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VideoFrame(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VideoFrame& operator=(Proxy p) {
        AzVideoFrame_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MapViewportChangedCallback {
public:
    struct Proxy { AzMapViewportChangedCallback inner; Proxy(AzMapViewportChangedCallback p) : inner(p) {} };

private:
    mutable AzMapViewportChangedCallback inner_;

public:
    explicit MapViewportChangedCallback(AzMapViewportChangedCallback inner) : inner_(inner) {}
    MapViewportChangedCallback(const MapViewportChangedCallback& other) : inner_(other.inner_) { memset(const_cast<AzMapViewportChangedCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    MapViewportChangedCallback& operator=(const MapViewportChangedCallback& other) {
        AzMapViewportChangedCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMapViewportChangedCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MapViewportChangedCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MapViewportChangedCallback& operator=(Proxy p) {
        AzMapViewportChangedCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AudioFrame {
public:
    struct Proxy { AzAudioFrame inner; Proxy(AzAudioFrame p) : inner(p) {} };

private:
    mutable AzAudioFrame inner_;

public:
    explicit AudioFrame(AzAudioFrame inner) : inner_(inner) {}
    AudioFrame(const AudioFrame& other) : inner_(other.inner_) { memset(const_cast<AzAudioFrame*>(&other.inner_), 0, sizeof(other.inner_)); }
    AudioFrame& operator=(const AudioFrame& other) {
        AzAudioFrame_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzAudioFrame*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    AudioFrame(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    AudioFrame& operator=(Proxy p) {
        AzAudioFrame_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GetProgramBinaryReturn {
public:
    struct Proxy { AzGetProgramBinaryReturn inner; Proxy(AzGetProgramBinaryReturn p) : inner(p) {} };

private:
    mutable AzGetProgramBinaryReturn inner_;

public:
    explicit GetProgramBinaryReturn(AzGetProgramBinaryReturn inner) : inner_(inner) {}
    GetProgramBinaryReturn(const GetProgramBinaryReturn& other) : inner_(other.inner_) { memset(const_cast<AzGetProgramBinaryReturn*>(&other.inner_), 0, sizeof(other.inner_)); }
    GetProgramBinaryReturn& operator=(const GetProgramBinaryReturn& other) {
        AzGetProgramBinaryReturn_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGetProgramBinaryReturn*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GetProgramBinaryReturn(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GetProgramBinaryReturn& operator=(Proxy p) {
        AzGetProgramBinaryReturn_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LoadedFontSource {
public:
    struct Proxy { AzLoadedFontSource inner; Proxy(AzLoadedFontSource p) : inner(p) {} };

private:
    mutable AzLoadedFontSource inner_;

public:
    explicit LoadedFontSource(AzLoadedFontSource inner) : inner_(inner) {}
    LoadedFontSource(const LoadedFontSource& other) : inner_(other.inner_) { memset(const_cast<AzLoadedFontSource*>(&other.inner_), 0, sizeof(other.inner_)); }
    LoadedFontSource& operator=(const LoadedFontSource& other) {
        AzLoadedFontSource_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzLoadedFontSource*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    LoadedFontSource(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    LoadedFontSource& operator=(Proxy p) {
        AzLoadedFontSource_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TessellatedSvgNode {
public:
    struct Proxy { AzTessellatedSvgNode inner; Proxy(AzTessellatedSvgNode p) : inner(p) {} };

private:
    mutable AzTessellatedSvgNode inner_;

public:
    explicit TessellatedSvgNode(AzTessellatedSvgNode inner) : inner_(inner) {}
    TessellatedSvgNode(const TessellatedSvgNode& other) : inner_(other.inner_) { memset(const_cast<AzTessellatedSvgNode*>(&other.inner_), 0, sizeof(other.inner_)); }
    TessellatedSvgNode& operator=(const TessellatedSvgNode& other) {
        AzTessellatedSvgNode_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTessellatedSvgNode*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TessellatedSvgNode(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TessellatedSvgNode& operator=(Proxy p) {
        AzTessellatedSvgNode_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~TessellatedSvgNode() { AzTessellatedSvgNode_delete(&inner_); }

    static TessellatedSvgNode empty();
    static TessellatedSvgNode from_nodes(TessellatedSvgNodeVecRef nodes);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssPath {
public:
    struct Proxy { AzCssPath inner; Proxy(AzCssPath p) : inner(p) {} };

private:
    mutable AzCssPath inner_;

public:
    explicit CssPath(AzCssPath inner) : inner_(inner) {}
    CssPath(const CssPath& other) : inner_(other.inner_) { memset(const_cast<AzCssPath*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssPath& operator=(const CssPath& other) {
        AzCssPath_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssPath*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssPath(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssPath& operator=(Proxy p) {
        AzCssPath_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~CssPath() { AzCssPath_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ShapePolygon {
public:
    struct Proxy { AzShapePolygon inner; Proxy(AzShapePolygon p) : inner(p) {} };

private:
    mutable AzShapePolygon inner_;

public:
    explicit ShapePolygon(AzShapePolygon inner) : inner_(inner) {}
    ShapePolygon(const ShapePolygon& other) : inner_(other.inner_) { memset(const_cast<AzShapePolygon*>(&other.inner_), 0, sizeof(other.inner_)); }
    ShapePolygon& operator=(const ShapePolygon& other) {
        AzShapePolygon_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzShapePolygon*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ShapePolygon(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ShapePolygon& operator=(Proxy p) {
        AzShapePolygon_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgPath {
public:
    struct Proxy { AzSvgPath inner; Proxy(AzSvgPath p) : inner(p) {} };

private:
    mutable AzSvgPath inner_;

public:
    explicit SvgPath(AzSvgPath inner) : inner_(inner) {}
    SvgPath(const SvgPath& other) : inner_(other.inner_) { memset(const_cast<AzSvgPath*>(&other.inner_), 0, sizeof(other.inner_)); }
    SvgPath& operator=(const SvgPath& other) {
        AzSvgPath_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSvgPath*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SvgPath(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SvgPath& operator=(Proxy p) {
        AzSvgPath_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~SvgPath() { AzSvgPath_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgMultiPolygon {
public:
    struct Proxy { AzSvgMultiPolygon inner; Proxy(AzSvgMultiPolygon p) : inner(p) {} };

private:
    mutable AzSvgMultiPolygon inner_;

public:
    explicit SvgMultiPolygon(AzSvgMultiPolygon inner) : inner_(inner) {}
    SvgMultiPolygon(const SvgMultiPolygon& other) : inner_(other.inner_) { memset(const_cast<AzSvgMultiPolygon*>(&other.inner_), 0, sizeof(other.inner_)); }
    SvgMultiPolygon& operator=(const SvgMultiPolygon& other) {
        AzSvgMultiPolygon_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSvgMultiPolygon*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SvgMultiPolygon(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SvgMultiPolygon& operator=(Proxy p) {
        AzSvgMultiPolygon_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~SvgMultiPolygon() { AzSvgMultiPolygon_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ParsedSvg {
public:
    struct Proxy { AzParsedSvg inner; Proxy(AzParsedSvg p) : inner(p) {} };

private:
    mutable AzParsedSvg inner_;

public:
    explicit ParsedSvg(AzParsedSvg inner) : inner_(inner) {}
    ParsedSvg(const ParsedSvg& other) : inner_(other.inner_) { memset(const_cast<AzParsedSvg*>(&other.inner_), 0, sizeof(other.inner_)); }
    ParsedSvg& operator=(const ParsedSvg& other) {
        AzParsedSvg_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzParsedSvg*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ParsedSvg(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ParsedSvg& operator=(Proxy p) {
        AzParsedSvg_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ParsedSvg() { AzParsedSvg_delete(&inner_); }
    static ResultParsedSvgSvgParseError from_string(String svg_string, SvgParseOptions parse_options);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class String {
public:
    struct Proxy { AzString inner; Proxy(AzString p) : inner(p) {} };

private:
    mutable AzString inner_;

public:
    explicit String(AzString inner) : inner_(inner) {}
    String(const String& other) : inner_(other.inner_) { memset(const_cast<AzString*>(&other.inner_), 0, sizeof(other.inner_)); }
    String& operator=(const String& other) {
        AzString_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzString*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    String(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    String& operator=(Proxy p) {
        AzString_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~String() { AzString_delete(&inner_); }

    static String copy_from_bytes(const uint8_t* ptr, size_t start, size_t len);
    static String from_c_str(const int8_t* ptr);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }

    // String methods
    explicit String(const char* s) : inner_(AzString_copyFromBytes((const uint8_t*)s, 0, strlen(s))) {}
    const char* c_str() const { return (const char*)(inner_.vec.ptr); }
    size_t length() const { return inner_.vec.len; }
};

class InvalidCharMultipleError {
public:
    struct Proxy { AzInvalidCharMultipleError inner; Proxy(AzInvalidCharMultipleError p) : inner(p) {} };

private:
    mutable AzInvalidCharMultipleError inner_;

public:
    explicit InvalidCharMultipleError(AzInvalidCharMultipleError inner) : inner_(inner) {}
    InvalidCharMultipleError(const InvalidCharMultipleError& other) : inner_(other.inner_) { memset(const_cast<AzInvalidCharMultipleError*>(&other.inner_), 0, sizeof(other.inner_)); }
    InvalidCharMultipleError& operator=(const InvalidCharMultipleError& other) {
        AzInvalidCharMultipleError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzInvalidCharMultipleError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    InvalidCharMultipleError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    InvalidCharMultipleError& operator=(Proxy p) {
        AzInvalidCharMultipleError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FluentZipLoadResult {
public:
    struct Proxy { AzFluentZipLoadResult inner; Proxy(AzFluentZipLoadResult p) : inner(p) {} };

private:
    mutable AzFluentZipLoadResult inner_;

public:
    explicit FluentZipLoadResult(AzFluentZipLoadResult inner) : inner_(inner) {}
    FluentZipLoadResult(const FluentZipLoadResult& other) : inner_(other.inner_) { memset(const_cast<AzFluentZipLoadResult*>(&other.inner_), 0, sizeof(other.inner_)); }
    FluentZipLoadResult& operator=(const FluentZipLoadResult& other) {
        AzFluentZipLoadResult_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFluentZipLoadResult*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FluentZipLoadResult(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FluentZipLoadResult& operator=(Proxy p) {
        AzFluentZipLoadResult_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ThreadSender {
public:
    struct Proxy { AzThreadSender inner; Proxy(AzThreadSender p) : inner(p) {} };

private:
    mutable AzThreadSender inner_;

public:
    explicit ThreadSender(AzThreadSender inner) : inner_(inner) {}
    ThreadSender(const ThreadSender& other) : inner_(other.inner_) { memset(const_cast<AzThreadSender*>(&other.inner_), 0, sizeof(other.inner_)); }
    ThreadSender& operator=(const ThreadSender& other) {
        AzThreadSender_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzThreadSender*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ThreadSender(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ThreadSender& operator=(Proxy p) {
        AzThreadSender_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ThreadReceiver {
public:
    struct Proxy { AzThreadReceiver inner; Proxy(AzThreadReceiver p) : inner(p) {} };

private:
    mutable AzThreadReceiver inner_;

public:
    explicit ThreadReceiver(AzThreadReceiver inner) : inner_(inner) {}
    ThreadReceiver(const ThreadReceiver& other) : inner_(other.inner_) { memset(const_cast<AzThreadReceiver*>(&other.inner_), 0, sizeof(other.inner_)); }
    ThreadReceiver& operator=(const ThreadReceiver& other) {
        AzThreadReceiver_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzThreadReceiver*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ThreadReceiver(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ThreadReceiver& operator=(Proxy p) {
        AzThreadReceiver_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DbRows {
public:
    struct Proxy { AzDbRows inner; Proxy(AzDbRows p) : inner(p) {} };

private:
    mutable AzDbRows inner_;

public:
    explicit DbRows(AzDbRows inner) : inner_(inner) {}
    DbRows(const DbRows& other) : inner_(other.inner_) { memset(const_cast<AzDbRows*>(&other.inner_), 0, sizeof(other.inner_)); }
    DbRows& operator=(const DbRows& other) {
        AzDbRows_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDbRows*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DbRows(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DbRows& operator=(Proxy p) {
        AzDbRows_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentMap {
public:
    struct Proxy { AzComponentMap inner; Proxy(AzComponentMap p) : inner(p) {} };

private:
    mutable AzComponentMap inner_;

public:
    explicit ComponentMap(AzComponentMap inner) : inner_(inner) {}
    ComponentMap(const ComponentMap& other) : inner_(other.inner_) { memset(const_cast<AzComponentMap*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentMap& operator=(const ComponentMap& other) {
        AzComponentMap_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentMap*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentMap(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentMap& operator=(Proxy p) {
        AzComponentMap_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ComponentMap() { AzComponentMap_delete(&inner_); }

    static ComponentMap create();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WaylandTheme {
public:
    struct Proxy { AzWaylandTheme inner; Proxy(AzWaylandTheme p) : inner(p) {} };

private:
    mutable AzWaylandTheme inner_;

public:
    explicit WaylandTheme(AzWaylandTheme inner) : inner_(inner) {}
    WaylandTheme(const WaylandTheme& other) : inner_(other.inner_) { memset(const_cast<AzWaylandTheme*>(&other.inner_), 0, sizeof(other.inner_)); }
    WaylandTheme& operator=(const WaylandTheme& other) {
        AzWaylandTheme_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzWaylandTheme*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    WaylandTheme(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    WaylandTheme& operator=(Proxy p) {
        AzWaylandTheme_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MimeTypeHint {
public:
    struct Proxy { AzMimeTypeHint inner; Proxy(AzMimeTypeHint p) : inner(p) {} };

private:
    mutable AzMimeTypeHint inner_;

public:
    explicit MimeTypeHint(AzMimeTypeHint inner) : inner_(inner) {}
    MimeTypeHint(const MimeTypeHint& other) : inner_(other.inner_) { memset(const_cast<AzMimeTypeHint*>(&other.inner_), 0, sizeof(other.inner_)); }
    MimeTypeHint& operator=(const MimeTypeHint& other) {
        AzMimeTypeHint_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMimeTypeHint*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MimeTypeHint(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MimeTypeHint& operator=(Proxy p) {
        AzMimeTypeHint_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MimeTypeData {
public:
    struct Proxy { AzMimeTypeData inner; Proxy(AzMimeTypeData p) : inner(p) {} };

private:
    mutable AzMimeTypeData inner_;

public:
    explicit MimeTypeData(AzMimeTypeData inner) : inner_(inner) {}
    MimeTypeData(const MimeTypeData& other) : inner_(other.inner_) { memset(const_cast<AzMimeTypeData*>(&other.inner_), 0, sizeof(other.inner_)); }
    MimeTypeData& operator=(const MimeTypeData& other) {
        AzMimeTypeData_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMimeTypeData*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MimeTypeData(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MimeTypeData& operator=(Proxy p) {
        AzMimeTypeData_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~MimeTypeData() { AzMimeTypeData_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class HttpHeader {
public:
    struct Proxy { AzHttpHeader inner; Proxy(AzHttpHeader p) : inner(p) {} };

private:
    mutable AzHttpHeader inner_;

public:
    explicit HttpHeader(AzHttpHeader inner) : inner_(inner) {}
    HttpHeader(const HttpHeader& other) : inner_(other.inner_) { memset(const_cast<AzHttpHeader*>(&other.inner_), 0, sizeof(other.inner_)); }
    HttpHeader& operator=(const HttpHeader& other) {
        AzHttpHeader_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzHttpHeader*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    HttpHeader(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    HttpHeader& operator=(Proxy p) {
        AzHttpHeader_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class HttpResponse {
public:
    struct Proxy { AzHttpResponse inner; Proxy(AzHttpResponse p) : inner(p) {} };

private:
    mutable AzHttpResponse inner_;

public:
    explicit HttpResponse(AzHttpResponse inner) : inner_(inner) {}
    HttpResponse(const HttpResponse& other) : inner_(other.inner_) { memset(const_cast<AzHttpResponse*>(&other.inner_), 0, sizeof(other.inner_)); }
    HttpResponse& operator=(const HttpResponse& other) {
        AzHttpResponse_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzHttpResponse*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    HttpResponse(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    HttpResponse& operator=(Proxy p) {
        AzHttpResponse_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class HttpRequestConfig {
public:
    struct Proxy { AzHttpRequestConfig inner; Proxy(AzHttpRequestConfig p) : inner(p) {} };

private:
    mutable AzHttpRequestConfig inner_;

public:
    explicit HttpRequestConfig(AzHttpRequestConfig inner) : inner_(inner) {}
    HttpRequestConfig(const HttpRequestConfig& other) : inner_(other.inner_) { memset(const_cast<AzHttpRequestConfig*>(&other.inner_), 0, sizeof(other.inner_)); }
    HttpRequestConfig& operator=(const HttpRequestConfig& other) {
        AzHttpRequestConfig_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzHttpRequestConfig*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    HttpRequestConfig(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    HttpRequestConfig& operator=(Proxy p) {
        AzHttpRequestConfig_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~HttpRequestConfig() { AzHttpRequestConfig_delete(&inner_); }

    static HttpRequestConfig create();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TimerCallbackInfo {
public:
    struct Proxy { AzTimerCallbackInfo inner; Proxy(AzTimerCallbackInfo p) : inner(p) {} };

private:
    mutable AzTimerCallbackInfo inner_;

public:
    explicit TimerCallbackInfo(AzTimerCallbackInfo inner) : inner_(inner) {}
    TimerCallbackInfo(const TimerCallbackInfo& other) : inner_(other.inner_) { memset(const_cast<AzTimerCallbackInfo*>(&other.inner_), 0, sizeof(other.inner_)); }
    TimerCallbackInfo& operator=(const TimerCallbackInfo& other) {
        AzTimerCallbackInfo_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTimerCallbackInfo*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TimerCallbackInfo(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TimerCallbackInfo& operator=(Proxy p) {
        AzTimerCallbackInfo_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~TimerCallbackInfo() { AzTimerCallbackInfo_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CoreCallbackData {
public:
    struct Proxy { AzCoreCallbackData inner; Proxy(AzCoreCallbackData p) : inner(p) {} };

private:
    mutable AzCoreCallbackData inner_;

public:
    explicit CoreCallbackData(AzCoreCallbackData inner) : inner_(inner) {}
    CoreCallbackData(const CoreCallbackData& other) : inner_(other.inner_) { memset(const_cast<AzCoreCallbackData*>(&other.inner_), 0, sizeof(other.inner_)); }
    CoreCallbackData& operator=(const CoreCallbackData& other) {
        AzCoreCallbackData_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCoreCallbackData*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CoreCallbackData(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CoreCallbackData& operator=(Proxy p) {
        AzCoreCallbackData_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CoreMenuCallback {
public:
    struct Proxy { AzCoreMenuCallback inner; Proxy(AzCoreMenuCallback p) : inner(p) {} };

private:
    mutable AzCoreMenuCallback inner_;

public:
    explicit CoreMenuCallback(AzCoreMenuCallback inner) : inner_(inner) {}
    CoreMenuCallback(const CoreMenuCallback& other) : inner_(other.inner_) { memset(const_cast<AzCoreMenuCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    CoreMenuCallback& operator=(const CoreMenuCallback& other) {
        AzCoreMenuCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCoreMenuCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CoreMenuCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CoreMenuCallback& operator=(Proxy p) {
        AzCoreMenuCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AttributeNameValue {
public:
    struct Proxy { AzAttributeNameValue inner; Proxy(AzAttributeNameValue p) : inner(p) {} };

private:
    mutable AzAttributeNameValue inner_;

public:
    explicit AttributeNameValue(AzAttributeNameValue inner) : inner_(inner) {}
    AttributeNameValue(const AttributeNameValue& other) : inner_(other.inner_) { memset(const_cast<AzAttributeNameValue*>(&other.inner_), 0, sizeof(other.inner_)); }
    AttributeNameValue& operator=(const AttributeNameValue& other) {
        AzAttributeNameValue_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzAttributeNameValue*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    AttributeNameValue(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    AttributeNameValue& operator=(Proxy p) {
        AzAttributeNameValue_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class XmlTagName {
public:
    struct Proxy { AzXmlTagName inner; Proxy(AzXmlTagName p) : inner(p) {} };

private:
    mutable AzXmlTagName inner_;

public:
    explicit XmlTagName(AzXmlTagName inner) : inner_(inner) {}
    XmlTagName(const XmlTagName& other) : inner_(other.inner_) { memset(const_cast<AzXmlTagName*>(&other.inner_), 0, sizeof(other.inner_)); }
    XmlTagName& operator=(const XmlTagName& other) {
        AzXmlTagName_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzXmlTagName*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    XmlTagName(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    XmlTagName& operator=(Proxy p) {
        AzXmlTagName_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~XmlTagName() { AzXmlTagName_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VertexAttribute {
public:
    struct Proxy { AzVertexAttribute inner; Proxy(AzVertexAttribute p) : inner(p) {} };

private:
    mutable AzVertexAttribute inner_;

public:
    explicit VertexAttribute(AzVertexAttribute inner) : inner_(inner) {}
    VertexAttribute(const VertexAttribute& other) : inner_(other.inner_) { memset(const_cast<AzVertexAttribute*>(&other.inner_), 0, sizeof(other.inner_)); }
    VertexAttribute& operator=(const VertexAttribute& other) {
        AzVertexAttribute_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVertexAttribute*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VertexAttribute(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VertexAttribute& operator=(Proxy p) {
        AzVertexAttribute_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CoreImageCallback {
public:
    struct Proxy { AzCoreImageCallback inner; Proxy(AzCoreImageCallback p) : inner(p) {} };

private:
    mutable AzCoreImageCallback inner_;

public:
    explicit CoreImageCallback(AzCoreImageCallback inner) : inner_(inner) {}
    CoreImageCallback(const CoreImageCallback& other) : inner_(other.inner_) { memset(const_cast<AzCoreImageCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    CoreImageCallback& operator=(const CoreImageCallback& other) {
        AzCoreImageCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCoreImageCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CoreImageCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CoreImageCallback& operator=(Proxy p) {
        AzCoreImageCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ClipboardContent {
public:
    struct Proxy { AzClipboardContent inner; Proxy(AzClipboardContent p) : inner(p) {} };

private:
    mutable AzClipboardContent inner_;

public:
    explicit ClipboardContent(AzClipboardContent inner) : inner_(inner) {}
    ClipboardContent(const ClipboardContent& other) : inner_(other.inner_) { memset(const_cast<AzClipboardContent*>(&other.inner_), 0, sizeof(other.inner_)); }
    ClipboardContent& operator=(const ClipboardContent& other) {
        AzClipboardContent_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzClipboardContent*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ClipboardContent(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ClipboardContent& operator=(Proxy p) {
        AzClipboardContent_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextInputOnVirtualKeyDown {
public:
    struct Proxy { AzTextInputOnVirtualKeyDown inner; Proxy(AzTextInputOnVirtualKeyDown p) : inner(p) {} };

private:
    mutable AzTextInputOnVirtualKeyDown inner_;

public:
    explicit TextInputOnVirtualKeyDown(AzTextInputOnVirtualKeyDown inner) : inner_(inner) {}
    TextInputOnVirtualKeyDown(const TextInputOnVirtualKeyDown& other) : inner_(other.inner_) { memset(const_cast<AzTextInputOnVirtualKeyDown*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextInputOnVirtualKeyDown& operator=(const TextInputOnVirtualKeyDown& other) {
        AzTextInputOnVirtualKeyDown_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextInputOnVirtualKeyDown*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextInputOnVirtualKeyDown(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextInputOnVirtualKeyDown& operator=(Proxy p) {
        AzTextInputOnVirtualKeyDown_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextOpSetSelection {
public:
    struct Proxy { AzTextOpSetSelection inner; Proxy(AzTextOpSetSelection p) : inner(p) {} };

private:
    mutable AzTextOpSetSelection inner_;

public:
    explicit TextOpSetSelection(AzTextOpSetSelection inner) : inner_(inner) {}
    TextOpSetSelection(const TextOpSetSelection& other) : inner_(other.inner_) { memset(const_cast<AzTextOpSetSelection*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextOpSetSelection& operator=(const TextOpSetSelection& other) {
        AzTextOpSetSelection_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextOpSetSelection*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextOpSetSelection(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextOpSetSelection& operator=(Proxy p) {
        AzTextOpSetSelection_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NodeStateSnapshot {
public:
    struct Proxy { AzNodeStateSnapshot inner; Proxy(AzNodeStateSnapshot p) : inner(p) {} };

private:
    mutable AzNodeStateSnapshot inner_;

public:
    explicit NodeStateSnapshot(AzNodeStateSnapshot inner) : inner_(inner) {}
    NodeStateSnapshot(const NodeStateSnapshot& other) : inner_(other.inner_) { memset(const_cast<AzNodeStateSnapshot*>(&other.inner_), 0, sizeof(other.inner_)); }
    NodeStateSnapshot& operator=(const NodeStateSnapshot& other) {
        AzNodeStateSnapshot_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNodeStateSnapshot*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NodeStateSnapshot(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NodeStateSnapshot& operator=(Proxy p) {
        AzNodeStateSnapshot_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ParseIntErrorWithInput {
public:
    struct Proxy { AzParseIntErrorWithInput inner; Proxy(AzParseIntErrorWithInput p) : inner(p) {} };

private:
    mutable AzParseIntErrorWithInput inner_;

public:
    explicit ParseIntErrorWithInput(AzParseIntErrorWithInput inner) : inner_(inner) {}
    ParseIntErrorWithInput(const ParseIntErrorWithInput& other) : inner_(other.inner_) { memset(const_cast<AzParseIntErrorWithInput*>(&other.inner_), 0, sizeof(other.inner_)); }
    ParseIntErrorWithInput& operator=(const ParseIntErrorWithInput& other) {
        AzParseIntErrorWithInput_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzParseIntErrorWithInput*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ParseIntErrorWithInput(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ParseIntErrorWithInput& operator=(Proxy p) {
        AzParseIntErrorWithInput_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ParseFloatErrorWithInput {
public:
    struct Proxy { AzParseFloatErrorWithInput inner; Proxy(AzParseFloatErrorWithInput p) : inner(p) {} };

private:
    mutable AzParseFloatErrorWithInput inner_;

public:
    explicit ParseFloatErrorWithInput(AzParseFloatErrorWithInput inner) : inner_(inner) {}
    ParseFloatErrorWithInput(const ParseFloatErrorWithInput& other) : inner_(other.inner_) { memset(const_cast<AzParseFloatErrorWithInput*>(&other.inner_), 0, sizeof(other.inner_)); }
    ParseFloatErrorWithInput& operator=(const ParseFloatErrorWithInput& other) {
        AzParseFloatErrorWithInput_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzParseFloatErrorWithInput*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ParseFloatErrorWithInput(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ParseFloatErrorWithInput& operator=(Proxy p) {
        AzParseFloatErrorWithInput_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssRuleBlock {
public:
    struct Proxy { AzCssRuleBlock inner; Proxy(AzCssRuleBlock p) : inner(p) {} };

private:
    mutable AzCssRuleBlock inner_;

public:
    explicit CssRuleBlock(AzCssRuleBlock inner) : inner_(inner) {}
    CssRuleBlock(const CssRuleBlock& other) : inner_(other.inner_) { memset(const_cast<AzCssRuleBlock*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssRuleBlock& operator=(const CssRuleBlock& other) {
        AzCssRuleBlock_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssRuleBlock*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssRuleBlock(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssRuleBlock& operator=(Proxy p) {
        AzCssRuleBlock_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~CssRuleBlock() { AzCssRuleBlock_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RadialGradient {
public:
    struct Proxy { AzRadialGradient inner; Proxy(AzRadialGradient p) : inner(p) {} };

private:
    mutable AzRadialGradient inner_;

public:
    explicit RadialGradient(AzRadialGradient inner) : inner_(inner) {}
    RadialGradient(const RadialGradient& other) : inner_(other.inner_) { memset(const_cast<AzRadialGradient*>(&other.inner_), 0, sizeof(other.inner_)); }
    RadialGradient& operator=(const RadialGradient& other) {
        AzRadialGradient_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRadialGradient*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RadialGradient(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RadialGradient& operator=(Proxy p) {
        AzRadialGradient_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~RadialGradient() { AzRadialGradient_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ConicGradient {
public:
    struct Proxy { AzConicGradient inner; Proxy(AzConicGradient p) : inner(p) {} };

private:
    mutable AzConicGradient inner_;

public:
    explicit ConicGradient(AzConicGradient inner) : inner_(inner) {}
    ConicGradient(const ConicGradient& other) : inner_(other.inner_) { memset(const_cast<AzConicGradient*>(&other.inner_), 0, sizeof(other.inner_)); }
    ConicGradient& operator=(const ConicGradient& other) {
        AzConicGradient_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzConicGradient*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ConicGradient(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ConicGradient& operator=(Proxy p) {
        AzConicGradient_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ConicGradient() { AzConicGradient_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CounterReset {
public:
    struct Proxy { AzCounterReset inner; Proxy(AzCounterReset p) : inner(p) {} };

private:
    mutable AzCounterReset inner_;

public:
    explicit CounterReset(AzCounterReset inner) : inner_(inner) {}
    CounterReset(const CounterReset& other) : inner_(other.inner_) { memset(const_cast<AzCounterReset*>(&other.inner_), 0, sizeof(other.inner_)); }
    CounterReset& operator=(const CounterReset& other) {
        AzCounterReset_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCounterReset*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CounterReset(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CounterReset& operator=(Proxy p) {
        AzCounterReset_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~CounterReset() { AzCounterReset_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Content {
public:
    struct Proxy { AzContent inner; Proxy(AzContent p) : inner(p) {} };

private:
    mutable AzContent inner_;

public:
    explicit Content(AzContent inner) : inner_(inner) {}
    Content(const Content& other) : inner_(other.inner_) { memset(const_cast<AzContent*>(&other.inner_), 0, sizeof(other.inner_)); }
    Content& operator=(const Content& other) {
        AzContent_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzContent*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Content(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Content& operator=(Proxy p) {
        AzContent_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Content() { AzContent_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CounterIncrement {
public:
    struct Proxy { AzCounterIncrement inner; Proxy(AzCounterIncrement p) : inner(p) {} };

private:
    mutable AzCounterIncrement inner_;

public:
    explicit CounterIncrement(AzCounterIncrement inner) : inner_(inner) {}
    CounterIncrement(const CounterIncrement& other) : inner_(other.inner_) { memset(const_cast<AzCounterIncrement*>(&other.inner_), 0, sizeof(other.inner_)); }
    CounterIncrement& operator=(const CounterIncrement& other) {
        AzCounterIncrement_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCounterIncrement*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CounterIncrement(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CounterIncrement& operator=(Proxy p) {
        AzCounterIncrement_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~CounterIncrement() { AzCounterIncrement_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyleHyphenationLanguage {
public:
    struct Proxy { AzStyleHyphenationLanguage inner; Proxy(AzStyleHyphenationLanguage p) : inner(p) {} };

private:
    mutable AzStyleHyphenationLanguage inner_;

public:
    explicit StyleHyphenationLanguage(AzStyleHyphenationLanguage inner) : inner_(inner) {}
    StyleHyphenationLanguage(const StyleHyphenationLanguage& other) : inner_(other.inner_) { memset(const_cast<AzStyleHyphenationLanguage*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyleHyphenationLanguage& operator=(const StyleHyphenationLanguage& other) {
        AzStyleHyphenationLanguage_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyleHyphenationLanguage*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyleHyphenationLanguage(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyleHyphenationLanguage& operator=(Proxy p) {
        AzStyleHyphenationLanguage_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~StyleHyphenationLanguage() { AzStyleHyphenationLanguage_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NamedGridLine {
public:
    struct Proxy { AzNamedGridLine inner; Proxy(AzNamedGridLine p) : inner(p) {} };

private:
    mutable AzNamedGridLine inner_;

public:
    explicit NamedGridLine(AzNamedGridLine inner) : inner_(inner) {}
    NamedGridLine(const NamedGridLine& other) : inner_(other.inner_) { memset(const_cast<AzNamedGridLine*>(&other.inner_), 0, sizeof(other.inner_)); }
    NamedGridLine& operator=(const NamedGridLine& other) {
        AzNamedGridLine_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNamedGridLine*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NamedGridLine(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NamedGridLine& operator=(Proxy p) {
        AzNamedGridLine_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~NamedGridLine() { AzNamedGridLine_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ShapePath {
public:
    struct Proxy { AzShapePath inner; Proxy(AzShapePath p) : inner(p) {} };

private:
    mutable AzShapePath inner_;

public:
    explicit ShapePath(AzShapePath inner) : inner_(inner) {}
    ShapePath(const ShapePath& other) : inner_(other.inner_) { memset(const_cast<AzShapePath*>(&other.inner_), 0, sizeof(other.inner_)); }
    ShapePath& operator=(const ShapePath& other) {
        AzShapePath_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzShapePath*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ShapePath(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ShapePath& operator=(Proxy p) {
        AzShapePath_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextOpReplaceText {
public:
    struct Proxy { AzTextOpReplaceText inner; Proxy(AzTextOpReplaceText p) : inner(p) {} };

private:
    mutable AzTextOpReplaceText inner_;

public:
    explicit TextOpReplaceText(AzTextOpReplaceText inner) : inner_(inner) {}
    TextOpReplaceText(const TextOpReplaceText& other) : inner_(other.inner_) { memset(const_cast<AzTextOpReplaceText*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextOpReplaceText& operator=(const TextOpReplaceText& other) {
        AzTextOpReplaceText_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextOpReplaceText*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextOpReplaceText(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextOpReplaceText& operator=(Proxy p) {
        AzTextOpReplaceText_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextOpDeleteText {
public:
    struct Proxy { AzTextOpDeleteText inner; Proxy(AzTextOpDeleteText p) : inner(p) {} };

private:
    mutable AzTextOpDeleteText inner_;

public:
    explicit TextOpDeleteText(AzTextOpDeleteText inner) : inner_(inner) {}
    TextOpDeleteText(const TextOpDeleteText& other) : inner_(other.inner_) { memset(const_cast<AzTextOpDeleteText*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextOpDeleteText& operator=(const TextOpDeleteText& other) {
        AzTextOpDeleteText_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextOpDeleteText*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextOpDeleteText(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextOpDeleteText& operator=(Proxy p) {
        AzTextOpDeleteText_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextOpSelectAll {
public:
    struct Proxy { AzTextOpSelectAll inner; Proxy(AzTextOpSelectAll p) : inner(p) {} };

private:
    mutable AzTextOpSelectAll inner_;

public:
    explicit TextOpSelectAll(AzTextOpSelectAll inner) : inner_(inner) {}
    TextOpSelectAll(const TextOpSelectAll& other) : inner_(other.inner_) { memset(const_cast<AzTextOpSelectAll*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextOpSelectAll& operator=(const TextOpSelectAll& other) {
        AzTextOpSelectAll_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextOpSelectAll*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextOpSelectAll(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextOpSelectAll& operator=(Proxy p) {
        AzTextOpSelectAll_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextOpInsertText {
public:
    struct Proxy { AzTextOpInsertText inner; Proxy(AzTextOpInsertText p) : inner(p) {} };

private:
    mutable AzTextOpInsertText inner_;

public:
    explicit TextOpInsertText(AzTextOpInsertText inner) : inner_(inner) {}
    TextOpInsertText(const TextOpInsertText& other) : inner_(other.inner_) { memset(const_cast<AzTextOpInsertText*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextOpInsertText& operator=(const TextOpInsertText& other) {
        AzTextOpInsertText_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextOpInsertText*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextOpInsertText(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextOpInsertText& operator=(Proxy p) {
        AzTextOpInsertText_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class PendingTextEdit {
public:
    struct Proxy { AzPendingTextEdit inner; Proxy(AzPendingTextEdit p) : inner(p) {} };

private:
    mutable AzPendingTextEdit inner_;

public:
    explicit PendingTextEdit(AzPendingTextEdit inner) : inner_(inner) {}
    PendingTextEdit(const PendingTextEdit& other) : inner_(other.inner_) { memset(const_cast<AzPendingTextEdit*>(&other.inner_), 0, sizeof(other.inner_)); }
    PendingTextEdit& operator=(const PendingTextEdit& other) {
        AzPendingTextEdit_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzPendingTextEdit*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    PendingTextEdit(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    PendingTextEdit& operator=(Proxy p) {
        AzPendingTextEdit_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NamedFont {
public:
    struct Proxy { AzNamedFont inner; Proxy(AzNamedFont p) : inner(p) {} };

private:
    mutable AzNamedFont inner_;

public:
    explicit NamedFont(AzNamedFont inner) : inner_(inner) {}
    NamedFont(const NamedFont& other) : inner_(other.inner_) { memset(const_cast<AzNamedFont*>(&other.inner_), 0, sizeof(other.inner_)); }
    NamedFont& operator=(const NamedFont& other) {
        AzNamedFont_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNamedFont*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NamedFont(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NamedFont& operator=(Proxy p) {
        AzNamedFont_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~NamedFont() { AzNamedFont_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GridAreaDefinition {
public:
    struct Proxy { AzGridAreaDefinition inner; Proxy(AzGridAreaDefinition p) : inner(p) {} };

private:
    mutable AzGridAreaDefinition inner_;

public:
    explicit GridAreaDefinition(AzGridAreaDefinition inner) : inner_(inner) {}
    GridAreaDefinition(const GridAreaDefinition& other) : inner_(other.inner_) { memset(const_cast<AzGridAreaDefinition*>(&other.inner_), 0, sizeof(other.inner_)); }
    GridAreaDefinition& operator=(const GridAreaDefinition& other) {
        AzGridAreaDefinition_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGridAreaDefinition*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GridAreaDefinition(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GridAreaDefinition& operator=(Proxy p) {
        AzGridAreaDefinition_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class InvalidValueErrOwned {
public:
    struct Proxy { AzInvalidValueErrOwned inner; Proxy(AzInvalidValueErrOwned p) : inner(p) {} };

private:
    mutable AzInvalidValueErrOwned inner_;

public:
    explicit InvalidValueErrOwned(AzInvalidValueErrOwned inner) : inner_(inner) {}
    InvalidValueErrOwned(const InvalidValueErrOwned& other) : inner_(other.inner_) { memset(const_cast<AzInvalidValueErrOwned*>(&other.inner_), 0, sizeof(other.inner_)); }
    InvalidValueErrOwned& operator=(const InvalidValueErrOwned& other) {
        AzInvalidValueErrOwned_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzInvalidValueErrOwned*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    InvalidValueErrOwned(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    InvalidValueErrOwned& operator=(Proxy p) {
        AzInvalidValueErrOwned_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FileTypeList {
public:
    struct Proxy { AzFileTypeList inner; Proxy(AzFileTypeList p) : inner(p) {} };

private:
    mutable AzFileTypeList inner_;

public:
    explicit FileTypeList(AzFileTypeList inner) : inner_(inner) {}
    FileTypeList(const FileTypeList& other) : inner_(other.inner_) { memset(const_cast<AzFileTypeList*>(&other.inner_), 0, sizeof(other.inner_)); }
    FileTypeList& operator=(const FileTypeList& other) {
        AzFileTypeList_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFileTypeList*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FileTypeList(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FileTypeList& operator=(Proxy p) {
        AzFileTypeList_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MapTileLayer {
public:
    struct Proxy { AzMapTileLayer inner; Proxy(AzMapTileLayer p) : inner(p) {} };

private:
    mutable AzMapTileLayer inner_;

public:
    explicit MapTileLayer(AzMapTileLayer inner) : inner_(inner) {}
    MapTileLayer(const MapTileLayer& other) : inner_(other.inner_) { memset(const_cast<AzMapTileLayer*>(&other.inner_), 0, sizeof(other.inner_)); }
    MapTileLayer& operator=(const MapTileLayer& other) {
        AzMapTileLayer_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMapTileLayer*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MapTileLayer(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MapTileLayer& operator=(Proxy p) {
        AzMapTileLayer_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~MapTileLayer() { AzMapTileLayer_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ButtonOnClick {
public:
    struct Proxy { AzButtonOnClick inner; Proxy(AzButtonOnClick p) : inner(p) {} };

private:
    mutable AzButtonOnClick inner_;

public:
    explicit ButtonOnClick(AzButtonOnClick inner) : inner_(inner) {}
    ButtonOnClick(const ButtonOnClick& other) : inner_(other.inner_) { memset(const_cast<AzButtonOnClick*>(&other.inner_), 0, sizeof(other.inner_)); }
    ButtonOnClick& operator=(const ButtonOnClick& other) {
        AzButtonOnClick_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzButtonOnClick*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ButtonOnClick(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ButtonOnClick& operator=(Proxy p) {
        AzButtonOnClick_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FileInputOnPathChange {
public:
    struct Proxy { AzFileInputOnPathChange inner; Proxy(AzFileInputOnPathChange p) : inner(p) {} };

private:
    mutable AzFileInputOnPathChange inner_;

public:
    explicit FileInputOnPathChange(AzFileInputOnPathChange inner) : inner_(inner) {}
    FileInputOnPathChange(const FileInputOnPathChange& other) : inner_(other.inner_) { memset(const_cast<AzFileInputOnPathChange*>(&other.inner_), 0, sizeof(other.inner_)); }
    FileInputOnPathChange& operator=(const FileInputOnPathChange& other) {
        AzFileInputOnPathChange_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFileInputOnPathChange*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FileInputOnPathChange(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FileInputOnPathChange& operator=(Proxy p) {
        AzFileInputOnPathChange_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CheckBoxOnToggle {
public:
    struct Proxy { AzCheckBoxOnToggle inner; Proxy(AzCheckBoxOnToggle p) : inner(p) {} };

private:
    mutable AzCheckBoxOnToggle inner_;

public:
    explicit CheckBoxOnToggle(AzCheckBoxOnToggle inner) : inner_(inner) {}
    CheckBoxOnToggle(const CheckBoxOnToggle& other) : inner_(other.inner_) { memset(const_cast<AzCheckBoxOnToggle*>(&other.inner_), 0, sizeof(other.inner_)); }
    CheckBoxOnToggle& operator=(const CheckBoxOnToggle& other) {
        AzCheckBoxOnToggle_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCheckBoxOnToggle*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CheckBoxOnToggle(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CheckBoxOnToggle& operator=(Proxy p) {
        AzCheckBoxOnToggle_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DropDownOnChoiceChange {
public:
    struct Proxy { AzDropDownOnChoiceChange inner; Proxy(AzDropDownOnChoiceChange p) : inner(p) {} };

private:
    mutable AzDropDownOnChoiceChange inner_;

public:
    explicit DropDownOnChoiceChange(AzDropDownOnChoiceChange inner) : inner_(inner) {}
    DropDownOnChoiceChange(const DropDownOnChoiceChange& other) : inner_(other.inner_) { memset(const_cast<AzDropDownOnChoiceChange*>(&other.inner_), 0, sizeof(other.inner_)); }
    DropDownOnChoiceChange& operator=(const DropDownOnChoiceChange& other) {
        AzDropDownOnChoiceChange_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDropDownOnChoiceChange*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DropDownOnChoiceChange(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DropDownOnChoiceChange& operator=(Proxy p) {
        AzDropDownOnChoiceChange_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ColorInputOnValueChange {
public:
    struct Proxy { AzColorInputOnValueChange inner; Proxy(AzColorInputOnValueChange p) : inner(p) {} };

private:
    mutable AzColorInputOnValueChange inner_;

public:
    explicit ColorInputOnValueChange(AzColorInputOnValueChange inner) : inner_(inner) {}
    ColorInputOnValueChange(const ColorInputOnValueChange& other) : inner_(other.inner_) { memset(const_cast<AzColorInputOnValueChange*>(&other.inner_), 0, sizeof(other.inner_)); }
    ColorInputOnValueChange& operator=(const ColorInputOnValueChange& other) {
        AzColorInputOnValueChange_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzColorInputOnValueChange*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ColorInputOnValueChange(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ColorInputOnValueChange& operator=(Proxy p) {
        AzColorInputOnValueChange_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextInputOnTextInput {
public:
    struct Proxy { AzTextInputOnTextInput inner; Proxy(AzTextInputOnTextInput p) : inner(p) {} };

private:
    mutable AzTextInputOnTextInput inner_;

public:
    explicit TextInputOnTextInput(AzTextInputOnTextInput inner) : inner_(inner) {}
    TextInputOnTextInput(const TextInputOnTextInput& other) : inner_(other.inner_) { memset(const_cast<AzTextInputOnTextInput*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextInputOnTextInput& operator=(const TextInputOnTextInput& other) {
        AzTextInputOnTextInput_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextInputOnTextInput*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextInputOnTextInput(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextInputOnTextInput& operator=(Proxy p) {
        AzTextInputOnTextInput_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextInputOnFocusLost {
public:
    struct Proxy { AzTextInputOnFocusLost inner; Proxy(AzTextInputOnFocusLost p) : inner(p) {} };

private:
    mutable AzTextInputOnFocusLost inner_;

public:
    explicit TextInputOnFocusLost(AzTextInputOnFocusLost inner) : inner_(inner) {}
    TextInputOnFocusLost(const TextInputOnFocusLost& other) : inner_(other.inner_) { memset(const_cast<AzTextInputOnFocusLost*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextInputOnFocusLost& operator=(const TextInputOnFocusLost& other) {
        AzTextInputOnFocusLost_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextInputOnFocusLost*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextInputOnFocusLost(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextInputOnFocusLost& operator=(Proxy p) {
        AzTextInputOnFocusLost_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NumberInputOnValueChange {
public:
    struct Proxy { AzNumberInputOnValueChange inner; Proxy(AzNumberInputOnValueChange p) : inner(p) {} };

private:
    mutable AzNumberInputOnValueChange inner_;

public:
    explicit NumberInputOnValueChange(AzNumberInputOnValueChange inner) : inner_(inner) {}
    NumberInputOnValueChange(const NumberInputOnValueChange& other) : inner_(other.inner_) { memset(const_cast<AzNumberInputOnValueChange*>(&other.inner_), 0, sizeof(other.inner_)); }
    NumberInputOnValueChange& operator=(const NumberInputOnValueChange& other) {
        AzNumberInputOnValueChange_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNumberInputOnValueChange*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NumberInputOnValueChange(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NumberInputOnValueChange& operator=(Proxy p) {
        AzNumberInputOnValueChange_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NumberInputOnFocusLost {
public:
    struct Proxy { AzNumberInputOnFocusLost inner; Proxy(AzNumberInputOnFocusLost p) : inner(p) {} };

private:
    mutable AzNumberInputOnFocusLost inner_;

public:
    explicit NumberInputOnFocusLost(AzNumberInputOnFocusLost inner) : inner_(inner) {}
    NumberInputOnFocusLost(const NumberInputOnFocusLost& other) : inner_(other.inner_) { memset(const_cast<AzNumberInputOnFocusLost*>(&other.inner_), 0, sizeof(other.inner_)); }
    NumberInputOnFocusLost& operator=(const NumberInputOnFocusLost& other) {
        AzNumberInputOnFocusLost_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNumberInputOnFocusLost*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NumberInputOnFocusLost(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NumberInputOnFocusLost& operator=(Proxy p) {
        AzNumberInputOnFocusLost_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TabOnClick {
public:
    struct Proxy { AzTabOnClick inner; Proxy(AzTabOnClick p) : inner(p) {} };

private:
    mutable AzTabOnClick inner_;

public:
    explicit TabOnClick(AzTabOnClick inner) : inner_(inner) {}
    TabOnClick(const TabOnClick& other) : inner_(other.inner_) { memset(const_cast<AzTabOnClick*>(&other.inner_), 0, sizeof(other.inner_)); }
    TabOnClick& operator=(const TabOnClick& other) {
        AzTabOnClick_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTabOnClick*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TabOnClick(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TabOnClick& operator=(Proxy p) {
        AzTabOnClick_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ListViewRow {
public:
    struct Proxy { AzListViewRow inner; Proxy(AzListViewRow p) : inner(p) {} };

private:
    mutable AzListViewRow inner_;

public:
    explicit ListViewRow(AzListViewRow inner) : inner_(inner) {}
    ListViewRow(const ListViewRow& other) : inner_(other.inner_) { memset(const_cast<AzListViewRow*>(&other.inner_), 0, sizeof(other.inner_)); }
    ListViewRow& operator=(const ListViewRow& other) {
        AzListViewRow_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzListViewRow*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ListViewRow(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ListViewRow& operator=(Proxy p) {
        AzListViewRow_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ListViewOnLazyLoadScroll {
public:
    struct Proxy { AzListViewOnLazyLoadScroll inner; Proxy(AzListViewOnLazyLoadScroll p) : inner(p) {} };

private:
    mutable AzListViewOnLazyLoadScroll inner_;

public:
    explicit ListViewOnLazyLoadScroll(AzListViewOnLazyLoadScroll inner) : inner_(inner) {}
    ListViewOnLazyLoadScroll(const ListViewOnLazyLoadScroll& other) : inner_(other.inner_) { memset(const_cast<AzListViewOnLazyLoadScroll*>(&other.inner_), 0, sizeof(other.inner_)); }
    ListViewOnLazyLoadScroll& operator=(const ListViewOnLazyLoadScroll& other) {
        AzListViewOnLazyLoadScroll_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzListViewOnLazyLoadScroll*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ListViewOnLazyLoadScroll(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ListViewOnLazyLoadScroll& operator=(Proxy p) {
        AzListViewOnLazyLoadScroll_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ListViewOnColumnClick {
public:
    struct Proxy { AzListViewOnColumnClick inner; Proxy(AzListViewOnColumnClick p) : inner(p) {} };

private:
    mutable AzListViewOnColumnClick inner_;

public:
    explicit ListViewOnColumnClick(AzListViewOnColumnClick inner) : inner_(inner) {}
    ListViewOnColumnClick(const ListViewOnColumnClick& other) : inner_(other.inner_) { memset(const_cast<AzListViewOnColumnClick*>(&other.inner_), 0, sizeof(other.inner_)); }
    ListViewOnColumnClick& operator=(const ListViewOnColumnClick& other) {
        AzListViewOnColumnClick_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzListViewOnColumnClick*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ListViewOnColumnClick(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ListViewOnColumnClick& operator=(Proxy p) {
        AzListViewOnColumnClick_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ListViewOnRowClick {
public:
    struct Proxy { AzListViewOnRowClick inner; Proxy(AzListViewOnRowClick p) : inner(p) {} };

private:
    mutable AzListViewOnRowClick inner_;

public:
    explicit ListViewOnRowClick(AzListViewOnRowClick inner) : inner_(inner) {}
    ListViewOnRowClick(const ListViewOnRowClick& other) : inner_(other.inner_) { memset(const_cast<AzListViewOnRowClick*>(&other.inner_), 0, sizeof(other.inner_)); }
    ListViewOnRowClick& operator=(const ListViewOnRowClick& other) {
        AzListViewOnRowClick_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzListViewOnRowClick*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ListViewOnRowClick(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ListViewOnRowClick& operator=(Proxy p) {
        AzListViewOnRowClick_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RibbonTab {
public:
    struct Proxy { AzRibbonTab inner; Proxy(AzRibbonTab p) : inner(p) {} };

private:
    mutable AzRibbonTab inner_;

public:
    explicit RibbonTab(AzRibbonTab inner) : inner_(inner) {}
    RibbonTab(const RibbonTab& other) : inner_(other.inner_) { memset(const_cast<AzRibbonTab*>(&other.inner_), 0, sizeof(other.inner_)); }
    RibbonTab& operator=(const RibbonTab& other) {
        AzRibbonTab_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRibbonTab*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RibbonTab(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RibbonTab& operator=(Proxy p) {
        AzRibbonTab_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~RibbonTab() { AzRibbonTab_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RibbonOnTabClick {
public:
    struct Proxy { AzRibbonOnTabClick inner; Proxy(AzRibbonOnTabClick p) : inner(p) {} };

private:
    mutable AzRibbonOnTabClick inner_;

public:
    explicit RibbonOnTabClick(AzRibbonOnTabClick inner) : inner_(inner) {}
    RibbonOnTabClick(const RibbonOnTabClick& other) : inner_(other.inner_) { memset(const_cast<AzRibbonOnTabClick*>(&other.inner_), 0, sizeof(other.inner_)); }
    RibbonOnTabClick& operator=(const RibbonOnTabClick& other) {
        AzRibbonOnTabClick_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRibbonOnTabClick*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RibbonOnTabClick(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RibbonOnTabClick& operator=(Proxy p) {
        AzRibbonOnTabClick_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TreeViewNode {
public:
    struct Proxy { AzTreeViewNode inner; Proxy(AzTreeViewNode p) : inner(p) {} };

private:
    mutable AzTreeViewNode inner_;

public:
    explicit TreeViewNode(AzTreeViewNode inner) : inner_(inner) {}
    TreeViewNode(const TreeViewNode& other) : inner_(other.inner_) { memset(const_cast<AzTreeViewNode*>(&other.inner_), 0, sizeof(other.inner_)); }
    TreeViewNode& operator=(const TreeViewNode& other) {
        AzTreeViewNode_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTreeViewNode*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TreeViewNode(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TreeViewNode& operator=(Proxy p) {
        AzTreeViewNode_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~TreeViewNode() { AzTreeViewNode_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TreeViewOnNodeClick {
public:
    struct Proxy { AzTreeViewOnNodeClick inner; Proxy(AzTreeViewOnNodeClick p) : inner(p) {} };

private:
    mutable AzTreeViewOnNodeClick inner_;

public:
    explicit TreeViewOnNodeClick(AzTreeViewOnNodeClick inner) : inner_(inner) {}
    TreeViewOnNodeClick(const TreeViewOnNodeClick& other) : inner_(other.inner_) { memset(const_cast<AzTreeViewOnNodeClick*>(&other.inner_), 0, sizeof(other.inner_)); }
    TreeViewOnNodeClick& operator=(const TreeViewOnNodeClick& other) {
        AzTreeViewOnNodeClick_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTreeViewOnNodeClick*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TreeViewOnNodeClick(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TreeViewOnNodeClick& operator=(Proxy p) {
        AzTreeViewOnNodeClick_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Titlebar {
public:
    struct Proxy { AzTitlebar inner; Proxy(AzTitlebar p) : inner(p) {} };

private:
    mutable AzTitlebar inner_;

public:
    explicit Titlebar(AzTitlebar inner) : inner_(inner) {}
    Titlebar(const Titlebar& other) : inner_(other.inner_) { memset(const_cast<AzTitlebar*>(&other.inner_), 0, sizeof(other.inner_)); }
    Titlebar& operator=(const Titlebar& other) {
        AzTitlebar_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTitlebar*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Titlebar(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Titlebar& operator=(Proxy p) {
        AzTitlebar_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Titlebar() { AzTitlebar_delete(&inner_); }

    static Titlebar new_(String title);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class OnVideoFrame {
public:
    struct Proxy { AzOnVideoFrame inner; Proxy(AzOnVideoFrame p) : inner(p) {} };

private:
    mutable AzOnVideoFrame inner_;

public:
    explicit OnVideoFrame(AzOnVideoFrame inner) : inner_(inner) {}
    OnVideoFrame(const OnVideoFrame& other) : inner_(other.inner_) { memset(const_cast<AzOnVideoFrame*>(&other.inner_), 0, sizeof(other.inner_)); }
    OnVideoFrame& operator=(const OnVideoFrame& other) {
        AzOnVideoFrame_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOnVideoFrame*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OnVideoFrame(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OnVideoFrame& operator=(Proxy p) {
        AzOnVideoFrame_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MapViewportChanged {
public:
    struct Proxy { AzMapViewportChanged inner; Proxy(AzMapViewportChanged p) : inner(p) {} };

private:
    mutable AzMapViewportChanged inner_;

public:
    explicit MapViewportChanged(AzMapViewportChanged inner) : inner_(inner) {}
    MapViewportChanged(const MapViewportChanged& other) : inner_(other.inner_) { memset(const_cast<AzMapViewportChanged*>(&other.inner_), 0, sizeof(other.inner_)); }
    MapViewportChanged& operator=(const MapViewportChanged& other) {
        AzMapViewportChanged_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMapViewportChanged*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MapViewportChanged(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MapViewportChanged& operator=(Proxy p) {
        AzMapViewportChanged_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class OnAudioFrame {
public:
    struct Proxy { AzOnAudioFrame inner; Proxy(AzOnAudioFrame p) : inner(p) {} };

private:
    mutable AzOnAudioFrame inner_;

public:
    explicit OnAudioFrame(AzOnAudioFrame inner) : inner_(inner) {}
    OnAudioFrame(const OnAudioFrame& other) : inner_(other.inner_) { memset(const_cast<AzOnAudioFrame*>(&other.inner_), 0, sizeof(other.inner_)); }
    OnAudioFrame& operator=(const OnAudioFrame& other) {
        AzOnAudioFrame_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOnAudioFrame*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OnAudioFrame(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OnAudioFrame& operator=(Proxy p) {
        AzOnAudioFrame_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GetActiveAttribReturn {
public:
    struct Proxy { AzGetActiveAttribReturn inner; Proxy(AzGetActiveAttribReturn p) : inner(p) {} };

private:
    mutable AzGetActiveAttribReturn inner_;

public:
    explicit GetActiveAttribReturn(AzGetActiveAttribReturn inner) : inner_(inner) {}
    GetActiveAttribReturn(const GetActiveAttribReturn& other) : inner_(other.inner_) { memset(const_cast<AzGetActiveAttribReturn*>(&other.inner_), 0, sizeof(other.inner_)); }
    GetActiveAttribReturn& operator=(const GetActiveAttribReturn& other) {
        AzGetActiveAttribReturn_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGetActiveAttribReturn*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GetActiveAttribReturn(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GetActiveAttribReturn& operator=(Proxy p) {
        AzGetActiveAttribReturn_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GetActiveUniformReturn {
public:
    struct Proxy { AzGetActiveUniformReturn inner; Proxy(AzGetActiveUniformReturn p) : inner(p) {} };

private:
    mutable AzGetActiveUniformReturn inner_;

public:
    explicit GetActiveUniformReturn(AzGetActiveUniformReturn inner) : inner_(inner) {}
    GetActiveUniformReturn(const GetActiveUniformReturn& other) : inner_(other.inner_) { memset(const_cast<AzGetActiveUniformReturn*>(&other.inner_), 0, sizeof(other.inner_)); }
    GetActiveUniformReturn& operator=(const GetActiveUniformReturn& other) {
        AzGetActiveUniformReturn_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGetActiveUniformReturn*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GetActiveUniformReturn(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GetActiveUniformReturn& operator=(Proxy p) {
        AzGetActiveUniformReturn_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VertexArrayObject {
public:
    struct Proxy { AzVertexArrayObject inner; Proxy(AzVertexArrayObject p) : inner(p) {} };

private:
    mutable AzVertexArrayObject inner_;

public:
    explicit VertexArrayObject(AzVertexArrayObject inner) : inner_(inner) {}
    VertexArrayObject(const VertexArrayObject& other) : inner_(other.inner_) { memset(const_cast<AzVertexArrayObject*>(&other.inner_), 0, sizeof(other.inner_)); }
    VertexArrayObject& operator=(const VertexArrayObject& other) {
        AzVertexArrayObject_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVertexArrayObject*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VertexArrayObject(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VertexArrayObject& operator=(Proxy p) {
        AzVertexArrayObject_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DebugMessage {
public:
    struct Proxy { AzDebugMessage inner; Proxy(AzDebugMessage p) : inner(p) {} };

private:
    mutable AzDebugMessage inner_;

public:
    explicit DebugMessage(AzDebugMessage inner) : inner_(inner) {}
    DebugMessage(const DebugMessage& other) : inner_(other.inner_) { memset(const_cast<AzDebugMessage*>(&other.inner_), 0, sizeof(other.inner_)); }
    DebugMessage& operator=(const DebugMessage& other) {
        AzDebugMessage_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDebugMessage*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DebugMessage(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DebugMessage& operator=(Proxy p) {
        AzDebugMessage_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RawImage {
public:
    struct Proxy { AzRawImage inner; Proxy(AzRawImage p) : inner(p) {} };

private:
    mutable AzRawImage inner_;

public:
    explicit RawImage(AzRawImage inner) : inner_(inner) {}
    RawImage(const RawImage& other) : inner_(other.inner_) { memset(const_cast<AzRawImage*>(&other.inner_), 0, sizeof(other.inner_)); }
    RawImage& operator=(const RawImage& other) {
        AzRawImage_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRawImage*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RawImage(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RawImage& operator=(Proxy p) {
        AzRawImage_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~RawImage() { AzRawImage_delete(&inner_); }

    static RawImage empty();
    static RawImage allocate_clip_mask(LayoutSize size);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Route {
public:
    struct Proxy { AzRoute inner; Proxy(AzRoute p) : inner(p) {} };

private:
    mutable AzRoute inner_;

public:
    explicit Route(AzRoute inner) : inner_(inner) {}
    Route(const Route& other) : inner_(other.inner_) { memset(const_cast<AzRoute*>(&other.inner_), 0, sizeof(other.inner_)); }
    Route& operator=(const Route& other) {
        AzRoute_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRoute*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Route(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Route& operator=(Proxy p) {
        AzRoute_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RouteMatch {
public:
    struct Proxy { AzRouteMatch inner; Proxy(AzRouteMatch p) : inner(p) {} };

private:
    mutable AzRouteMatch inner_;

public:
    explicit RouteMatch(AzRouteMatch inner) : inner_(inner) {}
    RouteMatch(const RouteMatch& other) : inner_(other.inner_) { memset(const_cast<AzRouteMatch*>(&other.inner_), 0, sizeof(other.inner_)); }
    RouteMatch& operator=(const RouteMatch& other) {
        AzRouteMatch_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRouteMatch*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RouteMatch(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RouteMatch& operator=(Proxy p) {
        AzRouteMatch_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LoadedFont {
public:
    struct Proxy { AzLoadedFont inner; Proxy(AzLoadedFont p) : inner(p) {} };

private:
    mutable AzLoadedFont inner_;

public:
    explicit LoadedFont(AzLoadedFont inner) : inner_(inner) {}
    LoadedFont(const LoadedFont& other) : inner_(other.inner_) { memset(const_cast<AzLoadedFont*>(&other.inner_), 0, sizeof(other.inner_)); }
    LoadedFont& operator=(const LoadedFont& other) {
        AzLoadedFont_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzLoadedFont*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    LoadedFont(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    LoadedFont& operator=(Proxy p) {
        AzLoadedFont_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~LoadedFont() { AzLoadedFont_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FilePath {
public:
    struct Proxy { AzFilePath inner; Proxy(AzFilePath p) : inner(p) {} };

private:
    mutable AzFilePath inner_;

public:
    explicit FilePath(AzFilePath inner) : inner_(inner) {}
    FilePath(const FilePath& other) : inner_(other.inner_) { memset(const_cast<AzFilePath*>(&other.inner_), 0, sizeof(other.inner_)); }
    FilePath& operator=(const FilePath& other) {
        AzFilePath_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFilePath*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FilePath(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FilePath& operator=(Proxy p) {
        AzFilePath_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~FilePath() { AzFilePath_delete(&inner_); }

    static FilePath create(String path);
    static FilePath empty();
    static FilePath from_str(String s);
    static FilePath get_temp_dir();
    static FilePath from(String s);
    static FilePath default_();
    static ResultFilePathFileError get_current_dir();
    static OptionFilePath get_home_dir();
    static OptionFilePath get_cache_dir();
    static OptionFilePath get_config_dir();
    static OptionFilePath get_config_local_dir();
    static OptionFilePath get_data_dir();
    static OptionFilePath get_data_local_dir();
    static OptionFilePath get_desktop_dir();
    static OptionFilePath get_document_dir();
    static OptionFilePath get_download_dir();
    static OptionFilePath get_executable_dir();
    static OptionFilePath get_font_dir();
    static OptionFilePath get_picture_dir();
    static OptionFilePath get_preference_dir();
    static OptionFilePath get_public_dir();
    static OptionFilePath get_runtime_dir();
    static OptionFilePath get_state_dir();
    static OptionFilePath get_audio_dir();
    static OptionFilePath get_video_dir();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StringPair {
public:
    struct Proxy { AzStringPair inner; Proxy(AzStringPair p) : inner(p) {} };

private:
    mutable AzStringPair inner_;

public:
    explicit StringPair(AzStringPair inner) : inner_(inner) {}
    StringPair(const StringPair& other) : inner_(other.inner_) { memset(const_cast<AzStringPair*>(&other.inner_), 0, sizeof(other.inner_)); }
    StringPair& operator=(const StringPair& other) {
        AzStringPair_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStringPair*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StringPair(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StringPair& operator=(Proxy p) {
        AzStringPair_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~StringPair() { AzStringPair_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StringSet {
public:
    struct Proxy { AzStringSet inner; Proxy(AzStringSet p) : inner(p) {} };

private:
    mutable AzStringSet inner_;

public:
    explicit StringSet(AzStringSet inner) : inner_(inner) {}
    StringSet(const StringSet& other) : inner_(other.inner_) { memset(const_cast<AzStringSet*>(&other.inner_), 0, sizeof(other.inner_)); }
    StringSet& operator=(const StringSet& other) {
        AzStringSet_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStringSet*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StringSet(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StringSet& operator=(Proxy p) {
        AzStringSet_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~StringSet() { AzStringSet_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DuplicatedNamespaceError {
public:
    struct Proxy { AzDuplicatedNamespaceError inner; Proxy(AzDuplicatedNamespaceError p) : inner(p) {} };

private:
    mutable AzDuplicatedNamespaceError inner_;

public:
    explicit DuplicatedNamespaceError(AzDuplicatedNamespaceError inner) : inner_(inner) {}
    DuplicatedNamespaceError(const DuplicatedNamespaceError& other) : inner_(other.inner_) { memset(const_cast<AzDuplicatedNamespaceError*>(&other.inner_), 0, sizeof(other.inner_)); }
    DuplicatedNamespaceError& operator=(const DuplicatedNamespaceError& other) {
        AzDuplicatedNamespaceError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDuplicatedNamespaceError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DuplicatedNamespaceError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DuplicatedNamespaceError& operator=(Proxy p) {
        AzDuplicatedNamespaceError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class UnknownNamespaceError {
public:
    struct Proxy { AzUnknownNamespaceError inner; Proxy(AzUnknownNamespaceError p) : inner(p) {} };

private:
    mutable AzUnknownNamespaceError inner_;

public:
    explicit UnknownNamespaceError(AzUnknownNamespaceError inner) : inner_(inner) {}
    UnknownNamespaceError(const UnknownNamespaceError& other) : inner_(other.inner_) { memset(const_cast<AzUnknownNamespaceError*>(&other.inner_), 0, sizeof(other.inner_)); }
    UnknownNamespaceError& operator=(const UnknownNamespaceError& other) {
        AzUnknownNamespaceError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzUnknownNamespaceError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    UnknownNamespaceError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    UnknownNamespaceError& operator=(Proxy p) {
        AzUnknownNamespaceError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class UnexpectedCloseTagError {
public:
    struct Proxy { AzUnexpectedCloseTagError inner; Proxy(AzUnexpectedCloseTagError p) : inner(p) {} };

private:
    mutable AzUnexpectedCloseTagError inner_;

public:
    explicit UnexpectedCloseTagError(AzUnexpectedCloseTagError inner) : inner_(inner) {}
    UnexpectedCloseTagError(const UnexpectedCloseTagError& other) : inner_(other.inner_) { memset(const_cast<AzUnexpectedCloseTagError*>(&other.inner_), 0, sizeof(other.inner_)); }
    UnexpectedCloseTagError& operator=(const UnexpectedCloseTagError& other) {
        AzUnexpectedCloseTagError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzUnexpectedCloseTagError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    UnexpectedCloseTagError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    UnexpectedCloseTagError& operator=(Proxy p) {
        AzUnexpectedCloseTagError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class UnknownEntityReferenceError {
public:
    struct Proxy { AzUnknownEntityReferenceError inner; Proxy(AzUnknownEntityReferenceError p) : inner(p) {} };

private:
    mutable AzUnknownEntityReferenceError inner_;

public:
    explicit UnknownEntityReferenceError(AzUnknownEntityReferenceError inner) : inner_(inner) {}
    UnknownEntityReferenceError(const UnknownEntityReferenceError& other) : inner_(other.inner_) { memset(const_cast<AzUnknownEntityReferenceError*>(&other.inner_), 0, sizeof(other.inner_)); }
    UnknownEntityReferenceError& operator=(const UnknownEntityReferenceError& other) {
        AzUnknownEntityReferenceError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzUnknownEntityReferenceError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    UnknownEntityReferenceError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    UnknownEntityReferenceError& operator=(Proxy p) {
        AzUnknownEntityReferenceError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DuplicatedAttributeError {
public:
    struct Proxy { AzDuplicatedAttributeError inner; Proxy(AzDuplicatedAttributeError p) : inner(p) {} };

private:
    mutable AzDuplicatedAttributeError inner_;

public:
    explicit DuplicatedAttributeError(AzDuplicatedAttributeError inner) : inner_(inner) {}
    DuplicatedAttributeError(const DuplicatedAttributeError& other) : inner_(other.inner_) { memset(const_cast<AzDuplicatedAttributeError*>(&other.inner_), 0, sizeof(other.inner_)); }
    DuplicatedAttributeError& operator=(const DuplicatedAttributeError& other) {
        AzDuplicatedAttributeError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDuplicatedAttributeError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DuplicatedAttributeError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DuplicatedAttributeError& operator=(Proxy p) {
        AzDuplicatedAttributeError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class InvalidStringError {
public:
    struct Proxy { AzInvalidStringError inner; Proxy(AzInvalidStringError p) : inner(p) {} };

private:
    mutable AzInvalidStringError inner_;

public:
    explicit InvalidStringError(AzInvalidStringError inner) : inner_(inner) {}
    InvalidStringError(const InvalidStringError& other) : inner_(other.inner_) { memset(const_cast<AzInvalidStringError*>(&other.inner_), 0, sizeof(other.inner_)); }
    InvalidStringError& operator=(const InvalidStringError& other) {
        AzInvalidStringError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzInvalidStringError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    InvalidStringError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    InvalidStringError& operator=(Proxy p) {
        AzInvalidStringError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MalformedHierarchyError {
public:
    struct Proxy { AzMalformedHierarchyError inner; Proxy(AzMalformedHierarchyError p) : inner(p) {} };

private:
    mutable AzMalformedHierarchyError inner_;

public:
    explicit MalformedHierarchyError(AzMalformedHierarchyError inner) : inner_(inner) {}
    MalformedHierarchyError(const MalformedHierarchyError& other) : inner_(other.inner_) { memset(const_cast<AzMalformedHierarchyError*>(&other.inner_), 0, sizeof(other.inner_)); }
    MalformedHierarchyError& operator=(const MalformedHierarchyError& other) {
        AzMalformedHierarchyError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMalformedHierarchyError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MalformedHierarchyError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MalformedHierarchyError& operator=(Proxy p) {
        AzMalformedHierarchyError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SelectAllResult {
public:
    struct Proxy { AzSelectAllResult inner; Proxy(AzSelectAllResult p) : inner(p) {} };

private:
    mutable AzSelectAllResult inner_;

public:
    explicit SelectAllResult(AzSelectAllResult inner) : inner_(inner) {}
    SelectAllResult(const SelectAllResult& other) : inner_(other.inner_) { memset(const_cast<AzSelectAllResult*>(&other.inner_), 0, sizeof(other.inner_)); }
    SelectAllResult& operator=(const SelectAllResult& other) {
        AzSelectAllResult_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSelectAllResult*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SelectAllResult(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SelectAllResult& operator=(Proxy p) {
        AzSelectAllResult_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DeleteResult {
public:
    struct Proxy { AzDeleteResult inner; Proxy(AzDeleteResult p) : inner(p) {} };

private:
    mutable AzDeleteResult inner_;

public:
    explicit DeleteResult(AzDeleteResult inner) : inner_(inner) {}
    DeleteResult(const DeleteResult& other) : inner_(other.inner_) { memset(const_cast<AzDeleteResult*>(&other.inner_), 0, sizeof(other.inner_)); }
    DeleteResult& operator=(const DeleteResult& other) {
        AzDeleteResult_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDeleteResult*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DeleteResult(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DeleteResult& operator=(Proxy p) {
        AzDeleteResult_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class IcuError {
public:
    struct Proxy { AzIcuError inner; Proxy(AzIcuError p) : inner(p) {} };

private:
    mutable AzIcuError inner_;

public:
    explicit IcuError(AzIcuError inner) : inner_(inner) {}
    IcuError(const IcuError& other) : inner_(other.inner_) { memset(const_cast<AzIcuError*>(&other.inner_), 0, sizeof(other.inner_)); }
    IcuError& operator=(const IcuError& other) {
        AzIcuError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzIcuError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    IcuError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    IcuError& operator=(Proxy p) {
        AzIcuError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class HttpStatusError {
public:
    struct Proxy { AzHttpStatusError inner; Proxy(AzHttpStatusError p) : inner(p) {} };

private:
    mutable AzHttpStatusError inner_;

public:
    explicit HttpStatusError(AzHttpStatusError inner) : inner_(inner) {}
    HttpStatusError(const HttpStatusError& other) : inner_(other.inner_) { memset(const_cast<AzHttpStatusError*>(&other.inner_), 0, sizeof(other.inner_)); }
    HttpStatusError& operator=(const HttpStatusError& other) {
        AzHttpStatusError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzHttpStatusError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    HttpStatusError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    HttpStatusError& operator=(Proxy p) {
        AzHttpStatusError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FileError {
public:
    struct Proxy { AzFileError inner; Proxy(AzFileError p) : inner(p) {} };

private:
    mutable AzFileError inner_;

public:
    explicit FileError(AzFileError inner) : inner_(inner) {}
    FileError(const FileError& other) : inner_(other.inner_) { memset(const_cast<AzFileError*>(&other.inner_), 0, sizeof(other.inner_)); }
    FileError& operator=(const FileError& other) {
        AzFileError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFileError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FileError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FileError& operator=(Proxy p) {
        AzFileError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class JsonParseError {
public:
    struct Proxy { AzJsonParseError inner; Proxy(AzJsonParseError p) : inner(p) {} };

private:
    mutable AzJsonParseError inner_;

public:
    explicit JsonParseError(AzJsonParseError inner) : inner_(inner) {}
    JsonParseError(const JsonParseError& other) : inner_(other.inner_) { memset(const_cast<AzJsonParseError*>(&other.inner_), 0, sizeof(other.inner_)); }
    JsonParseError& operator=(const JsonParseError& other) {
        AzJsonParseError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzJsonParseError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    JsonParseError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    JsonParseError& operator=(Proxy p) {
        AzJsonParseError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class UrlParseError {
public:
    struct Proxy { AzUrlParseError inner; Proxy(AzUrlParseError p) : inner(p) {} };

private:
    mutable AzUrlParseError inner_;

public:
    explicit UrlParseError(AzUrlParseError inner) : inner_(inner) {}
    UrlParseError(const UrlParseError& other) : inner_(other.inner_) { memset(const_cast<AzUrlParseError*>(&other.inner_), 0, sizeof(other.inner_)); }
    UrlParseError& operator=(const UrlParseError& other) {
        AzUrlParseError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzUrlParseError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    UrlParseError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    UrlParseError& operator=(Proxy p) {
        AzUrlParseError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class PixelNoValueGivenError {
public:
    struct Proxy { AzPixelNoValueGivenError inner; Proxy(AzPixelNoValueGivenError p) : inner(p) {} };

private:
    mutable AzPixelNoValueGivenError inner_;

public:
    explicit PixelNoValueGivenError(AzPixelNoValueGivenError inner) : inner_(inner) {}
    PixelNoValueGivenError(const PixelNoValueGivenError& other) : inner_(other.inner_) { memset(const_cast<AzPixelNoValueGivenError*>(&other.inner_), 0, sizeof(other.inner_)); }
    PixelNoValueGivenError& operator=(const PixelNoValueGivenError& other) {
        AzPixelNoValueGivenError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzPixelNoValueGivenError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    PixelNoValueGivenError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    PixelNoValueGivenError& operator=(Proxy p) {
        AzPixelNoValueGivenError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VarOnShorthandPropertyError {
public:
    struct Proxy { AzVarOnShorthandPropertyError inner; Proxy(AzVarOnShorthandPropertyError p) : inner(p) {} };

private:
    mutable AzVarOnShorthandPropertyError inner_;

public:
    explicit VarOnShorthandPropertyError(AzVarOnShorthandPropertyError inner) : inner_(inner) {}
    VarOnShorthandPropertyError(const VarOnShorthandPropertyError& other) : inner_(other.inner_) { memset(const_cast<AzVarOnShorthandPropertyError*>(&other.inner_), 0, sizeof(other.inner_)); }
    VarOnShorthandPropertyError& operator=(const VarOnShorthandPropertyError& other) {
        AzVarOnShorthandPropertyError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVarOnShorthandPropertyError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VarOnShorthandPropertyError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VarOnShorthandPropertyError& operator=(Proxy p) {
        AzVarOnShorthandPropertyError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WrongComponentCountError {
public:
    struct Proxy { AzWrongComponentCountError inner; Proxy(AzWrongComponentCountError p) : inner(p) {} };

private:
    mutable AzWrongComponentCountError inner_;

public:
    explicit WrongComponentCountError(AzWrongComponentCountError inner) : inner_(inner) {}
    WrongComponentCountError(const WrongComponentCountError& other) : inner_(other.inner_) { memset(const_cast<AzWrongComponentCountError*>(&other.inner_), 0, sizeof(other.inner_)); }
    WrongComponentCountError& operator=(const WrongComponentCountError& other) {
        AzWrongComponentCountError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzWrongComponentCountError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    WrongComponentCountError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    WrongComponentCountError& operator=(Proxy p) {
        AzWrongComponentCountError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AngleNoValueGivenError {
public:
    struct Proxy { AzAngleNoValueGivenError inner; Proxy(AzAngleNoValueGivenError p) : inner(p) {} };

private:
    mutable AzAngleNoValueGivenError inner_;

public:
    explicit AngleNoValueGivenError(AzAngleNoValueGivenError inner) : inner_(inner) {}
    AngleNoValueGivenError(const AngleNoValueGivenError& other) : inner_(other.inner_) { memset(const_cast<AzAngleNoValueGivenError*>(&other.inner_), 0, sizeof(other.inner_)); }
    AngleNoValueGivenError& operator=(const AngleNoValueGivenError& other) {
        AzAngleNoValueGivenError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzAngleNoValueGivenError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    AngleNoValueGivenError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    AngleNoValueGivenError& operator=(Proxy p) {
        AzAngleNoValueGivenError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WhiteSpaceInComponentNameError {
public:
    struct Proxy { AzWhiteSpaceInComponentNameError inner; Proxy(AzWhiteSpaceInComponentNameError p) : inner(p) {} };

private:
    mutable AzWhiteSpaceInComponentNameError inner_;

public:
    explicit WhiteSpaceInComponentNameError(AzWhiteSpaceInComponentNameError inner) : inner_(inner) {}
    WhiteSpaceInComponentNameError(const WhiteSpaceInComponentNameError& other) : inner_(other.inner_) { memset(const_cast<AzWhiteSpaceInComponentNameError*>(&other.inner_), 0, sizeof(other.inner_)); }
    WhiteSpaceInComponentNameError& operator=(const WhiteSpaceInComponentNameError& other) {
        AzWhiteSpaceInComponentNameError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzWhiteSpaceInComponentNameError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    WhiteSpaceInComponentNameError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    WhiteSpaceInComponentNameError& operator=(Proxy p) {
        AzWhiteSpaceInComponentNameError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WhiteSpaceInComponentTypeError {
public:
    struct Proxy { AzWhiteSpaceInComponentTypeError inner; Proxy(AzWhiteSpaceInComponentTypeError p) : inner(p) {} };

private:
    mutable AzWhiteSpaceInComponentTypeError inner_;

public:
    explicit WhiteSpaceInComponentTypeError(AzWhiteSpaceInComponentTypeError inner) : inner_(inner) {}
    WhiteSpaceInComponentTypeError(const WhiteSpaceInComponentTypeError& other) : inner_(other.inner_) { memset(const_cast<AzWhiteSpaceInComponentTypeError*>(&other.inner_), 0, sizeof(other.inner_)); }
    WhiteSpaceInComponentTypeError& operator=(const WhiteSpaceInComponentTypeError& other) {
        AzWhiteSpaceInComponentTypeError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzWhiteSpaceInComponentTypeError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    WhiteSpaceInComponentTypeError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    WhiteSpaceInComponentTypeError& operator=(Proxy p) {
        AzWhiteSpaceInComponentTypeError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class UnknownPropertyKeyError {
public:
    struct Proxy { AzUnknownPropertyKeyError inner; Proxy(AzUnknownPropertyKeyError p) : inner(p) {} };

private:
    mutable AzUnknownPropertyKeyError inner_;

public:
    explicit UnknownPropertyKeyError(AzUnknownPropertyKeyError inner) : inner_(inner) {}
    UnknownPropertyKeyError(const UnknownPropertyKeyError& other) : inner_(other.inner_) { memset(const_cast<AzUnknownPropertyKeyError*>(&other.inner_), 0, sizeof(other.inner_)); }
    UnknownPropertyKeyError& operator=(const UnknownPropertyKeyError& other) {
        AzUnknownPropertyKeyError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzUnknownPropertyKeyError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    UnknownPropertyKeyError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    UnknownPropertyKeyError& operator=(Proxy p) {
        AzUnknownPropertyKeyError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class UselessFunctionArgumentError {
public:
    struct Proxy { AzUselessFunctionArgumentError inner; Proxy(AzUselessFunctionArgumentError p) : inner(p) {} };

private:
    mutable AzUselessFunctionArgumentError inner_;

public:
    explicit UselessFunctionArgumentError(AzUselessFunctionArgumentError inner) : inner_(inner) {}
    UselessFunctionArgumentError(const UselessFunctionArgumentError& other) : inner_(other.inner_) { memset(const_cast<AzUselessFunctionArgumentError*>(&other.inner_), 0, sizeof(other.inner_)); }
    UselessFunctionArgumentError& operator=(const UselessFunctionArgumentError& other) {
        AzUselessFunctionArgumentError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzUselessFunctionArgumentError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    UselessFunctionArgumentError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    UselessFunctionArgumentError& operator=(Proxy p) {
        AzUselessFunctionArgumentError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MissingTypeError {
public:
    struct Proxy { AzMissingTypeError inner; Proxy(AzMissingTypeError p) : inner(p) {} };

private:
    mutable AzMissingTypeError inner_;

public:
    explicit MissingTypeError(AzMissingTypeError inner) : inner_(inner) {}
    MissingTypeError(const MissingTypeError& other) : inner_(other.inner_) { memset(const_cast<AzMissingTypeError*>(&other.inner_), 0, sizeof(other.inner_)); }
    MissingTypeError& operator=(const MissingTypeError& other) {
        AzMissingTypeError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMissingTypeError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MissingTypeError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MissingTypeError& operator=(Proxy p) {
        AzMissingTypeError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MapPinTap {
public:
    struct Proxy { AzMapPinTap inner; Proxy(AzMapPinTap p) : inner(p) {} };

private:
    mutable AzMapPinTap inner_;

public:
    explicit MapPinTap(AzMapPinTap inner) : inner_(inner) {}
    MapPinTap(const MapPinTap& other) : inner_(other.inner_) { memset(const_cast<AzMapPinTap*>(&other.inner_), 0, sizeof(other.inner_)); }
    MapPinTap& operator=(const MapPinTap& other) {
        AzMapPinTap_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMapPinTap*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MapPinTap(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MapPinTap& operator=(Proxy p) {
        AzMapPinTap_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ThreadWriteBackMsg {
public:
    struct Proxy { AzThreadWriteBackMsg inner; Proxy(AzThreadWriteBackMsg p) : inner(p) {} };

private:
    mutable AzThreadWriteBackMsg inner_;

public:
    explicit ThreadWriteBackMsg(AzThreadWriteBackMsg inner) : inner_(inner) {}
    ThreadWriteBackMsg(const ThreadWriteBackMsg& other) : inner_(other.inner_) { memset(const_cast<AzThreadWriteBackMsg*>(&other.inner_), 0, sizeof(other.inner_)); }
    ThreadWriteBackMsg& operator=(const ThreadWriteBackMsg& other) {
        AzThreadWriteBackMsg_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzThreadWriteBackMsg*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ThreadWriteBackMsg(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ThreadWriteBackMsg& operator=(Proxy p) {
        AzThreadWriteBackMsg_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ThreadWriteBackMsg() { AzThreadWriteBackMsg_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Url {
public:
    struct Proxy { AzUrl inner; Proxy(AzUrl p) : inner(p) {} };

private:
    mutable AzUrl inner_;

public:
    explicit Url(AzUrl inner) : inner_(inner) {}
    Url(const Url& other) : inner_(other.inner_) { memset(const_cast<AzUrl*>(&other.inner_), 0, sizeof(other.inner_)); }
    Url& operator=(const Url& other) {
        AzUrl_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzUrl*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Url(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Url& operator=(Proxy p) {
        AzUrl_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Url() { AzUrl_delete(&inner_); }

    static Url from_parts(String scheme, String host, uint16_t port, String path);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class JsonInternal {
public:
    struct Proxy { AzJsonInternal inner; Proxy(AzJsonInternal p) : inner(p) {} };

private:
    mutable AzJsonInternal inner_;

public:
    explicit JsonInternal(AzJsonInternal inner) : inner_(inner) {}
    JsonInternal(const JsonInternal& other) : inner_(other.inner_) { memset(const_cast<AzJsonInternal*>(&other.inner_), 0, sizeof(other.inner_)); }
    JsonInternal& operator=(const JsonInternal& other) {
        AzJsonInternal_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzJsonInternal*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    JsonInternal(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    JsonInternal& operator=(Proxy p) {
        AzJsonInternal_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~JsonInternal() { AzJsonInternal_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DirEntry {
public:
    struct Proxy { AzDirEntry inner; Proxy(AzDirEntry p) : inner(p) {} };

private:
    mutable AzDirEntry inner_;

public:
    explicit DirEntry(AzDirEntry inner) : inner_(inner) {}
    DirEntry(const DirEntry& other) : inner_(other.inner_) { memset(const_cast<AzDirEntry*>(&other.inner_), 0, sizeof(other.inner_)); }
    DirEntry& operator=(const DirEntry& other) {
        AzDirEntry_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDirEntry*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DirEntry(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DirEntry& operator=(Proxy p) {
        AzDirEntry_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class BiometricPrompt {
public:
    struct Proxy { AzBiometricPrompt inner; Proxy(AzBiometricPrompt p) : inner(p) {} };

private:
    mutable AzBiometricPrompt inner_;

public:
    explicit BiometricPrompt(AzBiometricPrompt inner) : inner_(inner) {}
    BiometricPrompt(const BiometricPrompt& other) : inner_(other.inner_) { memset(const_cast<AzBiometricPrompt*>(&other.inner_), 0, sizeof(other.inner_)); }
    BiometricPrompt& operator=(const BiometricPrompt& other) {
        AzBiometricPrompt_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzBiometricPrompt*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    BiometricPrompt(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    BiometricPrompt& operator=(Proxy p) {
        AzBiometricPrompt_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~BiometricPrompt() { AzBiometricPrompt_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VideoConfig {
public:
    struct Proxy { AzVideoConfig inner; Proxy(AzVideoConfig p) : inner(p) {} };

private:
    mutable AzVideoConfig inner_;

public:
    explicit VideoConfig(AzVideoConfig inner) : inner_(inner) {}
    VideoConfig(const VideoConfig& other) : inner_(other.inner_) { memset(const_cast<AzVideoConfig*>(&other.inner_), 0, sizeof(other.inner_)); }
    VideoConfig& operator=(const VideoConfig& other) {
        AzVideoConfig_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVideoConfig*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VideoConfig(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VideoConfig& operator=(Proxy p) {
        AzVideoConfig_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~VideoConfig() { AzVideoConfig_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentId {
public:
    struct Proxy { AzComponentId inner; Proxy(AzComponentId p) : inner(p) {} };

private:
    mutable AzComponentId inner_;

public:
    explicit ComponentId(AzComponentId inner) : inner_(inner) {}
    ComponentId(const ComponentId& other) : inner_(other.inner_) { memset(const_cast<AzComponentId*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentId& operator=(const ComponentId& other) {
        AzComponentId_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentId*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentId(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentId& operator=(Proxy p) {
        AzComponentId_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ComponentId() { AzComponentId_delete(&inner_); }

    static ComponentId builtin(String name);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentLibrary {
public:
    struct Proxy { AzComponentLibrary inner; Proxy(AzComponentLibrary p) : inner(p) {} };

private:
    mutable AzComponentLibrary inner_;

public:
    explicit ComponentLibrary(AzComponentLibrary inner) : inner_(inner) {}
    ComponentLibrary(const ComponentLibrary& other) : inner_(other.inner_) { memset(const_cast<AzComponentLibrary*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentLibrary& operator=(const ComponentLibrary& other) {
        AzComponentLibrary_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentLibrary*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentLibrary(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentLibrary& operator=(Proxy p) {
        AzComponentLibrary_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentDataModel {
public:
    struct Proxy { AzComponentDataModel inner; Proxy(AzComponentDataModel p) : inner(p) {} };

private:
    mutable AzComponentDataModel inner_;

public:
    explicit ComponentDataModel(AzComponentDataModel inner) : inner_(inner) {}
    ComponentDataModel(const ComponentDataModel& other) : inner_(other.inner_) { memset(const_cast<AzComponentDataModel*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentDataModel& operator=(const ComponentDataModel& other) {
        AzComponentDataModel_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentDataModel*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentDataModel(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentDataModel& operator=(Proxy p) {
        AzComponentDataModel_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentEnumVariant {
public:
    struct Proxy { AzComponentEnumVariant inner; Proxy(AzComponentEnumVariant p) : inner(p) {} };

private:
    mutable AzComponentEnumVariant inner_;

public:
    explicit ComponentEnumVariant(AzComponentEnumVariant inner) : inner_(inner) {}
    ComponentEnumVariant(const ComponentEnumVariant& other) : inner_(other.inner_) { memset(const_cast<AzComponentEnumVariant*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentEnumVariant& operator=(const ComponentEnumVariant& other) {
        AzComponentEnumVariant_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentEnumVariant*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentEnumVariant(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentEnumVariant& operator=(Proxy p) {
        AzComponentEnumVariant_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentEnumModel {
public:
    struct Proxy { AzComponentEnumModel inner; Proxy(AzComponentEnumModel p) : inner(p) {} };

private:
    mutable AzComponentEnumModel inner_;

public:
    explicit ComponentEnumModel(AzComponentEnumModel inner) : inner_(inner) {}
    ComponentEnumModel(const ComponentEnumModel& other) : inner_(other.inner_) { memset(const_cast<AzComponentEnumModel*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentEnumModel& operator=(const ComponentEnumModel& other) {
        AzComponentEnumModel_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentEnumModel*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentEnumModel(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentEnumModel& operator=(Proxy p) {
        AzComponentEnumModel_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentInstanceDefault {
public:
    struct Proxy { AzComponentInstanceDefault inner; Proxy(AzComponentInstanceDefault p) : inner(p) {} };

private:
    mutable AzComponentInstanceDefault inner_;

public:
    explicit ComponentInstanceDefault(AzComponentInstanceDefault inner) : inner_(inner) {}
    ComponentInstanceDefault(const ComponentInstanceDefault& other) : inner_(other.inner_) { memset(const_cast<AzComponentInstanceDefault*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentInstanceDefault& operator=(const ComponentInstanceDefault& other) {
        AzComponentInstanceDefault_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentInstanceDefault*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentInstanceDefault(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentInstanceDefault& operator=(Proxy p) {
        AzComponentInstanceDefault_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentCallbackSignature {
public:
    struct Proxy { AzComponentCallbackSignature inner; Proxy(AzComponentCallbackSignature p) : inner(p) {} };

private:
    mutable AzComponentCallbackSignature inner_;

public:
    explicit ComponentCallbackSignature(AzComponentCallbackSignature inner) : inner_(inner) {}
    ComponentCallbackSignature(const ComponentCallbackSignature& other) : inner_(other.inner_) { memset(const_cast<AzComponentCallbackSignature*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentCallbackSignature& operator=(const ComponentCallbackSignature& other) {
        AzComponentCallbackSignature_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentCallbackSignature*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentCallbackSignature(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentCallbackSignature& operator=(Proxy p) {
        AzComponentCallbackSignature_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Monitor {
public:
    struct Proxy { AzMonitor inner; Proxy(AzMonitor p) : inner(p) {} };

private:
    mutable AzMonitor inner_;

public:
    explicit Monitor(AzMonitor inner) : inner_(inner) {}
    Monitor(const Monitor& other) : inner_(other.inner_) { memset(const_cast<AzMonitor*>(&other.inner_), 0, sizeof(other.inner_)); }
    Monitor& operator=(const Monitor& other) {
        AzMonitor_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMonitor*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Monitor(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Monitor& operator=(Proxy p) {
        AzMonitor_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Monitor() { AzMonitor_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DialogAriaInfo {
public:
    struct Proxy { AzDialogAriaInfo inner; Proxy(AzDialogAriaInfo p) : inner(p) {} };

private:
    mutable AzDialogAriaInfo inner_;

public:
    explicit DialogAriaInfo(AzDialogAriaInfo inner) : inner_(inner) {}
    DialogAriaInfo(const DialogAriaInfo& other) : inner_(other.inner_) { memset(const_cast<AzDialogAriaInfo*>(&other.inner_), 0, sizeof(other.inner_)); }
    DialogAriaInfo& operator=(const DialogAriaInfo& other) {
        AzDialogAriaInfo_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDialogAriaInfo*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DialogAriaInfo(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DialogAriaInfo& operator=(Proxy p) {
        AzDialogAriaInfo_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~DialogAriaInfo() { AzDialogAriaInfo_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AccessibilityInfo {
public:
    struct Proxy { AzAccessibilityInfo inner; Proxy(AzAccessibilityInfo p) : inner(p) {} };

private:
    mutable AzAccessibilityInfo inner_;

public:
    explicit AccessibilityInfo(AzAccessibilityInfo inner) : inner_(inner) {}
    AccessibilityInfo(const AccessibilityInfo& other) : inner_(other.inner_) { memset(const_cast<AzAccessibilityInfo*>(&other.inner_), 0, sizeof(other.inner_)); }
    AccessibilityInfo& operator=(const AccessibilityInfo& other) {
        AzAccessibilityInfo_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzAccessibilityInfo*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    AccessibilityInfo(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    AccessibilityInfo& operator=(Proxy p) {
        AzAccessibilityInfo_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DragState {
public:
    struct Proxy { AzDragState inner; Proxy(AzDragState p) : inner(p) {} };

private:
    mutable AzDragState inner_;

public:
    explicit DragState(AzDragState inner) : inner_(inner) {}
    DragState(const DragState& other) : inner_(other.inner_) { memset(const_cast<AzDragState*>(&other.inner_), 0, sizeof(other.inner_)); }
    DragState& operator=(const DragState& other) {
        AzDragState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDragState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DragState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DragState& operator=(Proxy p) {
        AzDragState_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SmallAriaInfo {
public:
    struct Proxy { AzSmallAriaInfo inner; Proxy(AzSmallAriaInfo p) : inner(p) {} };

private:
    mutable AzSmallAriaInfo inner_;

public:
    explicit SmallAriaInfo(AzSmallAriaInfo inner) : inner_(inner) {}
    SmallAriaInfo(const SmallAriaInfo& other) : inner_(other.inner_) { memset(const_cast<AzSmallAriaInfo*>(&other.inner_), 0, sizeof(other.inner_)); }
    SmallAriaInfo& operator=(const SmallAriaInfo& other) {
        AzSmallAriaInfo_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSmallAriaInfo*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SmallAriaInfo(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SmallAriaInfo& operator=(Proxy p) {
        AzSmallAriaInfo_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~SmallAriaInfo() { AzSmallAriaInfo_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ProgressAriaInfo {
public:
    struct Proxy { AzProgressAriaInfo inner; Proxy(AzProgressAriaInfo p) : inner(p) {} };

private:
    mutable AzProgressAriaInfo inner_;

public:
    explicit ProgressAriaInfo(AzProgressAriaInfo inner) : inner_(inner) {}
    ProgressAriaInfo(const ProgressAriaInfo& other) : inner_(other.inner_) { memset(const_cast<AzProgressAriaInfo*>(&other.inner_), 0, sizeof(other.inner_)); }
    ProgressAriaInfo& operator=(const ProgressAriaInfo& other) {
        AzProgressAriaInfo_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzProgressAriaInfo*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ProgressAriaInfo(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ProgressAriaInfo& operator=(Proxy p) {
        AzProgressAriaInfo_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ProgressAriaInfo() { AzProgressAriaInfo_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MeterAriaInfo {
public:
    struct Proxy { AzMeterAriaInfo inner; Proxy(AzMeterAriaInfo p) : inner(p) {} };

private:
    mutable AzMeterAriaInfo inner_;

public:
    explicit MeterAriaInfo(AzMeterAriaInfo inner) : inner_(inner) {}
    MeterAriaInfo(const MeterAriaInfo& other) : inner_(other.inner_) { memset(const_cast<AzMeterAriaInfo*>(&other.inner_), 0, sizeof(other.inner_)); }
    MeterAriaInfo& operator=(const MeterAriaInfo& other) {
        AzMeterAriaInfo_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMeterAriaInfo*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MeterAriaInfo(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MeterAriaInfo& operator=(Proxy p) {
        AzMeterAriaInfo_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~MeterAriaInfo() { AzMeterAriaInfo_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssAttributeSelector {
public:
    struct Proxy { AzCssAttributeSelector inner; Proxy(AzCssAttributeSelector p) : inner(p) {} };

private:
    mutable AzCssAttributeSelector inner_;

public:
    explicit CssAttributeSelector(AzCssAttributeSelector inner) : inner_(inner) {}
    CssAttributeSelector(const CssAttributeSelector& other) : inner_(other.inner_) { memset(const_cast<AzCssAttributeSelector*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssAttributeSelector& operator=(const CssAttributeSelector& other) {
        AzCssAttributeSelector_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssAttributeSelector*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssAttributeSelector(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssAttributeSelector& operator=(Proxy p) {
        AzCssAttributeSelector_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~CssAttributeSelector() { AzCssAttributeSelector_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StyledTextRun {
public:
    struct Proxy { AzStyledTextRun inner; Proxy(AzStyledTextRun p) : inner(p) {} };

private:
    mutable AzStyledTextRun inner_;

public:
    explicit StyledTextRun(AzStyledTextRun inner) : inner_(inner) {}
    StyledTextRun(const StyledTextRun& other) : inner_(other.inner_) { memset(const_cast<AzStyledTextRun*>(&other.inner_), 0, sizeof(other.inner_)); }
    StyledTextRun& operator=(const StyledTextRun& other) {
        AzStyledTextRun_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStyledTextRun*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StyledTextRun(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StyledTextRun& operator=(Proxy p) {
        AzStyledTextRun_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextOpCopy {
public:
    struct Proxy { AzTextOpCopy inner; Proxy(AzTextOpCopy p) : inner(p) {} };

private:
    mutable AzTextOpCopy inner_;

public:
    explicit TextOpCopy(AzTextOpCopy inner) : inner_(inner) {}
    TextOpCopy(const TextOpCopy& other) : inner_(other.inner_) { memset(const_cast<AzTextOpCopy*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextOpCopy& operator=(const TextOpCopy& other) {
        AzTextOpCopy_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextOpCopy*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextOpCopy(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextOpCopy& operator=(Proxy p) {
        AzTextOpCopy_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextOpPaste {
public:
    struct Proxy { AzTextOpPaste inner; Proxy(AzTextOpPaste p) : inner(p) {} };

private:
    mutable AzTextOpPaste inner_;

public:
    explicit TextOpPaste(AzTextOpPaste inner) : inner_(inner) {}
    TextOpPaste(const TextOpPaste& other) : inner_(other.inner_) { memset(const_cast<AzTextOpPaste*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextOpPaste& operator=(const TextOpPaste& other) {
        AzTextOpPaste_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextOpPaste*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextOpPaste(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextOpPaste& operator=(Proxy p) {
        AzTextOpPaste_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextOpCut {
public:
    struct Proxy { AzTextOpCut inner; Proxy(AzTextOpCut p) : inner(p) {} };

private:
    mutable AzTextOpCut inner_;

public:
    explicit TextOpCut(AzTextOpCut inner) : inner_(inner) {}
    TextOpCut(const TextOpCut& other) : inner_(other.inner_) { memset(const_cast<AzTextOpCut*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextOpCut& operator=(const TextOpCut& other) {
        AzTextOpCut_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextOpCut*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextOpCut(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextOpCut& operator=(Proxy p) {
        AzTextOpCut_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SystemFonts {
public:
    struct Proxy { AzSystemFonts inner; Proxy(AzSystemFonts p) : inner(p) {} };

private:
    mutable AzSystemFonts inner_;

public:
    explicit SystemFonts(AzSystemFonts inner) : inner_(inner) {}
    SystemFonts(const SystemFonts& other) : inner_(other.inner_) { memset(const_cast<AzSystemFonts*>(&other.inner_), 0, sizeof(other.inner_)); }
    SystemFonts& operator=(const SystemFonts& other) {
        AzSystemFonts_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSystemFonts*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SystemFonts(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SystemFonts& operator=(Proxy p) {
        AzSystemFonts_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~SystemFonts() { AzSystemFonts_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class PercentageParseErrorWithInput {
public:
    struct Proxy { AzPercentageParseErrorWithInput inner; Proxy(AzPercentageParseErrorWithInput p) : inner(p) {} };

private:
    mutable AzPercentageParseErrorWithInput inner_;

public:
    explicit PercentageParseErrorWithInput(AzPercentageParseErrorWithInput inner) : inner_(inner) {}
    PercentageParseErrorWithInput(const PercentageParseErrorWithInput& other) : inner_(other.inner_) { memset(const_cast<AzPercentageParseErrorWithInput*>(&other.inner_), 0, sizeof(other.inner_)); }
    PercentageParseErrorWithInput& operator=(const PercentageParseErrorWithInput& other) {
        AzPercentageParseErrorWithInput_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzPercentageParseErrorWithInput*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    PercentageParseErrorWithInput(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    PercentageParseErrorWithInput& operator=(Proxy p) {
        AzPercentageParseErrorWithInput_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TitlebarMetrics {
public:
    struct Proxy { AzTitlebarMetrics inner; Proxy(AzTitlebarMetrics p) : inner(p) {} };

private:
    mutable AzTitlebarMetrics inner_;

public:
    explicit TitlebarMetrics(AzTitlebarMetrics inner) : inner_(inner) {}
    TitlebarMetrics(const TitlebarMetrics& other) : inner_(other.inner_) { memset(const_cast<AzTitlebarMetrics*>(&other.inner_), 0, sizeof(other.inner_)); }
    TitlebarMetrics& operator=(const TitlebarMetrics& other) {
        AzTitlebarMetrics_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTitlebarMetrics*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TitlebarMetrics(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TitlebarMetrics& operator=(Proxy p) {
        AzTitlebarMetrics_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~TitlebarMetrics() { AzTitlebarMetrics_delete(&inner_); }

    static TitlebarMetrics windows();
    static TitlebarMetrics macos();
    static TitlebarMetrics linux_gnome();
    static TitlebarMetrics ios();
    static TitlebarMetrics android();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LinuxCustomization {
public:
    struct Proxy { AzLinuxCustomization inner; Proxy(AzLinuxCustomization p) : inner(p) {} };

private:
    mutable AzLinuxCustomization inner_;

public:
    explicit LinuxCustomization(AzLinuxCustomization inner) : inner_(inner) {}
    LinuxCustomization(const LinuxCustomization& other) : inner_(other.inner_) { memset(const_cast<AzLinuxCustomization*>(&other.inner_), 0, sizeof(other.inner_)); }
    LinuxCustomization& operator=(const LinuxCustomization& other) {
        AzLinuxCustomization_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzLinuxCustomization*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    LinuxCustomization(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    LinuxCustomization& operator=(Proxy p) {
        AzLinuxCustomization_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~LinuxCustomization() { AzLinuxCustomization_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FileInputState {
public:
    struct Proxy { AzFileInputState inner; Proxy(AzFileInputState p) : inner(p) {} };

private:
    mutable AzFileInputState inner_;

public:
    explicit FileInputState(AzFileInputState inner) : inner_(inner) {}
    FileInputState(const FileInputState& other) : inner_(other.inner_) { memset(const_cast<AzFileInputState*>(&other.inner_), 0, sizeof(other.inner_)); }
    FileInputState& operator=(const FileInputState& other) {
        AzFileInputState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFileInputState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FileInputState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FileInputState& operator=(Proxy p) {
        AzFileInputState_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~FileInputState() { AzFileInputState_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextInputState {
public:
    struct Proxy { AzTextInputState inner; Proxy(AzTextInputState p) : inner(p) {} };

private:
    mutable AzTextInputState inner_;

public:
    explicit TextInputState(AzTextInputState inner) : inner_(inner) {}
    TextInputState(const TextInputState& other) : inner_(other.inner_) { memset(const_cast<AzTextInputState*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextInputState& operator=(const TextInputState& other) {
        AzTextInputState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextInputState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextInputState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextInputState& operator=(Proxy p) {
        AzTextInputState_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~TextInputState() { AzTextInputState_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VertexBuffer {
public:
    struct Proxy { AzVertexBuffer inner; Proxy(AzVertexBuffer p) : inner(p) {} };

private:
    mutable AzVertexBuffer inner_;

public:
    explicit VertexBuffer(AzVertexBuffer inner) : inner_(inner) {}
    VertexBuffer(const VertexBuffer& other) : inner_(other.inner_) { memset(const_cast<AzVertexBuffer*>(&other.inner_), 0, sizeof(other.inner_)); }
    VertexBuffer& operator=(const VertexBuffer& other) {
        AzVertexBuffer_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVertexBuffer*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VertexBuffer(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VertexBuffer& operator=(Proxy p) {
        AzVertexBuffer_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SvgParseOptions {
public:
    struct Proxy { AzSvgParseOptions inner; Proxy(AzSvgParseOptions p) : inner(p) {} };

private:
    mutable AzSvgParseOptions inner_;

public:
    explicit SvgParseOptions(AzSvgParseOptions inner) : inner_(inner) {}
    SvgParseOptions(const SvgParseOptions& other) : inner_(other.inner_) { memset(const_cast<AzSvgParseOptions*>(&other.inner_), 0, sizeof(other.inner_)); }
    SvgParseOptions& operator=(const SvgParseOptions& other) {
        AzSvgParseOptions_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSvgParseOptions*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SvgParseOptions(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SvgParseOptions& operator=(Proxy p) {
        AzSvgParseOptions_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~SvgParseOptions() { AzSvgParseOptions_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class UnknownSelectorError {
public:
    struct Proxy { AzUnknownSelectorError inner; Proxy(AzUnknownSelectorError p) : inner(p) {} };

private:
    mutable AzUnknownSelectorError inner_;

public:
    explicit UnknownSelectorError(AzUnknownSelectorError inner) : inner_(inner) {}
    UnknownSelectorError(const UnknownSelectorError& other) : inner_(other.inner_) { memset(const_cast<AzUnknownSelectorError*>(&other.inner_), 0, sizeof(other.inner_)); }
    UnknownSelectorError& operator=(const UnknownSelectorError& other) {
        AzUnknownSelectorError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzUnknownSelectorError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    UnknownSelectorError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    UnknownSelectorError& operator=(Proxy p) {
        AzUnknownSelectorError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Timer {
public:
    struct Proxy { AzTimer inner; Proxy(AzTimer p) : inner(p) {} };

private:
    mutable AzTimer inner_;

public:
    explicit Timer(AzTimer inner) : inner_(inner) {}
    Timer(const Timer& other) : inner_(other.inner_) { memset(const_cast<AzTimer*>(&other.inner_), 0, sizeof(other.inner_)); }
    Timer& operator=(const Timer& other) {
        AzTimer_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTimer*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Timer(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Timer& operator=(Proxy p) {
        AzTimer_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Timer() { AzTimer_delete(&inner_); }

    static Timer create(RefAny refany, AzTimerCallbackType callback, GetSystemTimeCallback get_system_time_fn);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FmtArg {
public:
    struct Proxy { AzFmtArg inner; Proxy(AzFmtArg p) : inner(p) {} };

private:
    mutable AzFmtArg inner_;

public:
    explicit FmtArg(AzFmtArg inner) : inner_(inner) {}
    FmtArg(const FmtArg& other) : inner_(other.inner_) { memset(const_cast<AzFmtArg*>(&other.inner_), 0, sizeof(other.inner_)); }
    FmtArg& operator=(const FmtArg& other) {
        AzFmtArg_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFmtArg*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FmtArg(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FmtArg& operator=(Proxy p) {
        AzFmtArg_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Json {
public:
    struct Proxy { AzJson inner; Proxy(AzJson p) : inner(p) {} };

private:
    mutable AzJson inner_;

public:
    explicit Json(AzJson inner) : inner_(inner) {}
    Json(const Json& other) : inner_(other.inner_) { memset(const_cast<AzJson*>(&other.inner_), 0, sizeof(other.inner_)); }
    Json& operator=(const Json& other) {
        AzJson_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzJson*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Json(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Json& operator=(Proxy p) {
        AzJson_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Json() { AzJson_delete(&inner_); }

    static Json null();
    static Json bool_(bool value);
    static Json float_(double value);
    static Json int_(int64_t value);
    static Json string(String value);
    static Json array(JsonVec values);
    static Json object(JsonKeyValueVec entries);
    static ResultJsonJsonParseError parse(String s);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentDef {
public:
    struct Proxy { AzComponentDef inner; Proxy(AzComponentDef p) : inner(p) {} };

private:
    mutable AzComponentDef inner_;

public:
    explicit ComponentDef(AzComponentDef inner) : inner_(inner) {}
    ComponentDef(const ComponentDef& other) : inner_(other.inner_) { memset(const_cast<AzComponentDef*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentDef& operator=(const ComponentDef& other) {
        AzComponentDef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentDef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentDef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentDef& operator=(Proxy p) {
        AzComponentDef_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentFieldOverride {
public:
    struct Proxy { AzComponentFieldOverride inner; Proxy(AzComponentFieldOverride p) : inner(p) {} };

private:
    mutable AzComponentFieldOverride inner_;

public:
    explicit ComponentFieldOverride(AzComponentFieldOverride inner) : inner_(inner) {}
    ComponentFieldOverride(const ComponentFieldOverride& other) : inner_(other.inner_) { memset(const_cast<AzComponentFieldOverride*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentFieldOverride& operator=(const ComponentFieldOverride& other) {
        AzComponentFieldOverride_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentFieldOverride*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentFieldOverride(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentFieldOverride& operator=(Proxy p) {
        AzComponentFieldOverride_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class LinuxWindowOptions {
public:
    struct Proxy { AzLinuxWindowOptions inner; Proxy(AzLinuxWindowOptions p) : inner(p) {} };

private:
    mutable AzLinuxWindowOptions inner_;

public:
    explicit LinuxWindowOptions(AzLinuxWindowOptions inner) : inner_(inner) {}
    LinuxWindowOptions(const LinuxWindowOptions& other) : inner_(other.inner_) { memset(const_cast<AzLinuxWindowOptions*>(&other.inner_), 0, sizeof(other.inner_)); }
    LinuxWindowOptions& operator=(const LinuxWindowOptions& other) {
        AzLinuxWindowOptions_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzLinuxWindowOptions*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    LinuxWindowOptions(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    LinuxWindowOptions& operator=(Proxy p) {
        AzLinuxWindowOptions_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~LinuxWindowOptions() { AzLinuxWindowOptions_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WindowsWindowOptions {
public:
    struct Proxy { AzWindowsWindowOptions inner; Proxy(AzWindowsWindowOptions p) : inner(p) {} };

private:
    mutable AzWindowsWindowOptions inner_;

public:
    explicit WindowsWindowOptions(AzWindowsWindowOptions inner) : inner_(inner) {}
    WindowsWindowOptions(const WindowsWindowOptions& other) : inner_(other.inner_) { memset(const_cast<AzWindowsWindowOptions*>(&other.inner_), 0, sizeof(other.inner_)); }
    WindowsWindowOptions& operator=(const WindowsWindowOptions& other) {
        AzWindowsWindowOptions_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzWindowsWindowOptions*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    WindowsWindowOptions(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    WindowsWindowOptions& operator=(Proxy p) {
        AzWindowsWindowOptions_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~WindowsWindowOptions() { AzWindowsWindowOptions_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NodeData {
public:
    struct Proxy { AzNodeData inner; Proxy(AzNodeData p) : inner(p) {} };

private:
    mutable AzNodeData inner_;

public:
    explicit NodeData(AzNodeData inner) : inner_(inner) {}
    NodeData(const NodeData& other) : inner_(other.inner_) { memset(const_cast<AzNodeData*>(&other.inner_), 0, sizeof(other.inner_)); }
    NodeData& operator=(const NodeData& other) {
        AzNodeData_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNodeData*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NodeData(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NodeData& operator=(Proxy p) {
        AzNodeData_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~NodeData() { AzNodeData_delete(&inner_); }

    static NodeData create(AzNodeType node_type);
    static NodeData create_body();
    static NodeData create_div();
    static NodeData create_br();
    static NodeData create_text(String value);
    static NodeData create_image(ImageRef image);
    static NodeData create_virtual_view(RefAny data, AzVirtualViewCallbackType callback);
    static NodeData create_node(AzNodeType node_type);
    static NodeData create_button(SmallAriaInfo aria);
    static NodeData create_button_no_a11y();
    static NodeData create_a(String href, SmallAriaInfo aria);
    static NodeData create_a_no_a11y(String href);
    static NodeData create_input(String input_type, String name, String label, SmallAriaInfo aria);
    static NodeData create_input_no_a11y(String input_type, String name, String label);
    static NodeData create_textarea(String name, String label, SmallAriaInfo aria);
    static NodeData create_textarea_no_a11y(String name, String label);
    static NodeData create_select(String name, String label, SmallAriaInfo aria);
    static NodeData create_select_no_a11y(String name, String label);
    static NodeData create_table(SmallAriaInfo aria);
    static NodeData create_table_no_a11y();
    static NodeData create_label(String for_id, SmallAriaInfo aria);
    static NodeData create_label_no_a11y(String for_id);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class StringMenuItem {
public:
    struct Proxy { AzStringMenuItem inner; Proxy(AzStringMenuItem p) : inner(p) {} };

private:
    mutable AzStringMenuItem inner_;

public:
    explicit StringMenuItem(AzStringMenuItem inner) : inner_(inner) {}
    StringMenuItem(const StringMenuItem& other) : inner_(other.inner_) { memset(const_cast<AzStringMenuItem*>(&other.inner_), 0, sizeof(other.inner_)); }
    StringMenuItem& operator=(const StringMenuItem& other) {
        AzStringMenuItem_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzStringMenuItem*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    StringMenuItem(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    StringMenuItem& operator=(Proxy p) {
        AzStringMenuItem_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~StringMenuItem() { AzStringMenuItem_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class GridPlacement {
public:
    struct Proxy { AzGridPlacement inner; Proxy(AzGridPlacement p) : inner(p) {} };

private:
    mutable AzGridPlacement inner_;

public:
    explicit GridPlacement(AzGridPlacement inner) : inner_(inner) {}
    GridPlacement(const GridPlacement& other) : inner_(other.inner_) { memset(const_cast<AzGridPlacement*>(&other.inner_), 0, sizeof(other.inner_)); }
    GridPlacement& operator=(const GridPlacement& other) {
        AzGridPlacement_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzGridPlacement*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    GridPlacement(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    GridPlacement& operator=(Proxy p) {
        AzGridPlacement_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~GridPlacement() { AzGridPlacement_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssMockEnvironment {
public:
    struct Proxy { AzCssMockEnvironment inner; Proxy(AzCssMockEnvironment p) : inner(p) {} };

private:
    mutable AzCssMockEnvironment inner_;

public:
    explicit CssMockEnvironment(AzCssMockEnvironment inner) : inner_(inner) {}
    CssMockEnvironment(const CssMockEnvironment& other) : inner_(other.inner_) { memset(const_cast<AzCssMockEnvironment*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssMockEnvironment& operator=(const CssMockEnvironment& other) {
        AzCssMockEnvironment_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssMockEnvironment*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssMockEnvironment(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssMockEnvironment& operator=(Proxy p) {
        AzCssMockEnvironment_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~CssMockEnvironment() { AzCssMockEnvironment_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SystemMetrics {
public:
    struct Proxy { AzSystemMetrics inner; Proxy(AzSystemMetrics p) : inner(p) {} };

private:
    mutable AzSystemMetrics inner_;

public:
    explicit SystemMetrics(AzSystemMetrics inner) : inner_(inner) {}
    SystemMetrics(const SystemMetrics& other) : inner_(other.inner_) { memset(const_cast<AzSystemMetrics*>(&other.inner_), 0, sizeof(other.inner_)); }
    SystemMetrics& operator=(const SystemMetrics& other) {
        AzSystemMetrics_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSystemMetrics*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SystemMetrics(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SystemMetrics& operator=(Proxy p) {
        AzSystemMetrics_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~SystemMetrics() { AzSystemMetrics_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Button {
public:
    struct Proxy { AzButton inner; Proxy(AzButton p) : inner(p) {} };

private:
    mutable AzButton inner_;

public:
    explicit Button(AzButton inner) : inner_(inner) {}
    Button(const Button& other) : inner_(other.inner_) { memset(const_cast<AzButton*>(&other.inner_), 0, sizeof(other.inner_)); }
    Button& operator=(const Button& other) {
        AzButton_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzButton*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Button(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Button& operator=(Proxy p) {
        AzButton_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Button() { AzButton_delete(&inner_); }

    static Button create(String label);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MapWidget {
public:
    struct Proxy { AzMapWidget inner; Proxy(AzMapWidget p) : inner(p) {} };

private:
    mutable AzMapWidget inner_;

public:
    explicit MapWidget(AzMapWidget inner) : inner_(inner) {}
    MapWidget(const MapWidget& other) : inner_(other.inner_) { memset(const_cast<AzMapWidget*>(&other.inner_), 0, sizeof(other.inner_)); }
    MapWidget& operator=(const MapWidget& other) {
        AzMapWidget_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMapWidget*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MapWidget(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MapWidget& operator=(Proxy p) {
        AzMapWidget_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~MapWidget() { AzMapWidget_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FileInputStateWrapper {
public:
    struct Proxy { AzFileInputStateWrapper inner; Proxy(AzFileInputStateWrapper p) : inner(p) {} };

private:
    mutable AzFileInputStateWrapper inner_;

public:
    explicit FileInputStateWrapper(AzFileInputStateWrapper inner) : inner_(inner) {}
    FileInputStateWrapper(const FileInputStateWrapper& other) : inner_(other.inner_) { memset(const_cast<AzFileInputStateWrapper*>(&other.inner_), 0, sizeof(other.inner_)); }
    FileInputStateWrapper& operator=(const FileInputStateWrapper& other) {
        AzFileInputStateWrapper_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFileInputStateWrapper*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FileInputStateWrapper(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FileInputStateWrapper& operator=(Proxy p) {
        AzFileInputStateWrapper_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~FileInputStateWrapper() { AzFileInputStateWrapper_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CheckBoxStateWrapper {
public:
    struct Proxy { AzCheckBoxStateWrapper inner; Proxy(AzCheckBoxStateWrapper p) : inner(p) {} };

private:
    mutable AzCheckBoxStateWrapper inner_;

public:
    explicit CheckBoxStateWrapper(AzCheckBoxStateWrapper inner) : inner_(inner) {}
    CheckBoxStateWrapper(const CheckBoxStateWrapper& other) : inner_(other.inner_) { memset(const_cast<AzCheckBoxStateWrapper*>(&other.inner_), 0, sizeof(other.inner_)); }
    CheckBoxStateWrapper& operator=(const CheckBoxStateWrapper& other) {
        AzCheckBoxStateWrapper_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCheckBoxStateWrapper*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CheckBoxStateWrapper(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CheckBoxStateWrapper& operator=(Proxy p) {
        AzCheckBoxStateWrapper_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~CheckBoxStateWrapper() { AzCheckBoxStateWrapper_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DropDown {
public:
    struct Proxy { AzDropDown inner; Proxy(AzDropDown p) : inner(p) {} };

private:
    mutable AzDropDown inner_;

public:
    explicit DropDown(AzDropDown inner) : inner_(inner) {}
    DropDown(const DropDown& other) : inner_(other.inner_) { memset(const_cast<AzDropDown*>(&other.inner_), 0, sizeof(other.inner_)); }
    DropDown& operator=(const DropDown& other) {
        AzDropDown_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDropDown*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DropDown(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DropDown& operator=(Proxy p) {
        AzDropDown_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~DropDown() { AzDropDown_delete(&inner_); }

    static DropDown create(StringVec choices);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ColorInputStateWrapper {
public:
    struct Proxy { AzColorInputStateWrapper inner; Proxy(AzColorInputStateWrapper p) : inner(p) {} };

private:
    mutable AzColorInputStateWrapper inner_;

public:
    explicit ColorInputStateWrapper(AzColorInputStateWrapper inner) : inner_(inner) {}
    ColorInputStateWrapper(const ColorInputStateWrapper& other) : inner_(other.inner_) { memset(const_cast<AzColorInputStateWrapper*>(&other.inner_), 0, sizeof(other.inner_)); }
    ColorInputStateWrapper& operator=(const ColorInputStateWrapper& other) {
        AzColorInputStateWrapper_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzColorInputStateWrapper*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ColorInputStateWrapper(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ColorInputStateWrapper& operator=(Proxy p) {
        AzColorInputStateWrapper_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ColorInputStateWrapper() { AzColorInputStateWrapper_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextInputStateWrapper {
public:
    struct Proxy { AzTextInputStateWrapper inner; Proxy(AzTextInputStateWrapper p) : inner(p) {} };

private:
    mutable AzTextInputStateWrapper inner_;

public:
    explicit TextInputStateWrapper(AzTextInputStateWrapper inner) : inner_(inner) {}
    TextInputStateWrapper(const TextInputStateWrapper& other) : inner_(other.inner_) { memset(const_cast<AzTextInputStateWrapper*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextInputStateWrapper& operator=(const TextInputStateWrapper& other) {
        AzTextInputStateWrapper_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextInputStateWrapper*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextInputStateWrapper(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextInputStateWrapper& operator=(Proxy p) {
        AzTextInputStateWrapper_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~TextInputStateWrapper() { AzTextInputStateWrapper_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NumberInputStateWrapper {
public:
    struct Proxy { AzNumberInputStateWrapper inner; Proxy(AzNumberInputStateWrapper p) : inner(p) {} };

private:
    mutable AzNumberInputStateWrapper inner_;

public:
    explicit NumberInputStateWrapper(AzNumberInputStateWrapper inner) : inner_(inner) {}
    NumberInputStateWrapper(const NumberInputStateWrapper& other) : inner_(other.inner_) { memset(const_cast<AzNumberInputStateWrapper*>(&other.inner_), 0, sizeof(other.inner_)); }
    NumberInputStateWrapper& operator=(const NumberInputStateWrapper& other) {
        AzNumberInputStateWrapper_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNumberInputStateWrapper*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NumberInputStateWrapper(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NumberInputStateWrapper& operator=(Proxy p) {
        AzNumberInputStateWrapper_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~NumberInputStateWrapper() { AzNumberInputStateWrapper_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TabHeader {
public:
    struct Proxy { AzTabHeader inner; Proxy(AzTabHeader p) : inner(p) {} };

private:
    mutable AzTabHeader inner_;

public:
    explicit TabHeader(AzTabHeader inner) : inner_(inner) {}
    TabHeader(const TabHeader& other) : inner_(other.inner_) { memset(const_cast<AzTabHeader*>(&other.inner_), 0, sizeof(other.inner_)); }
    TabHeader& operator=(const TabHeader& other) {
        AzTabHeader_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTabHeader*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TabHeader(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TabHeader& operator=(Proxy p) {
        AzTabHeader_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~TabHeader() { AzTabHeader_delete(&inner_); }

    static TabHeader create(StringVec tabs);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ListView {
public:
    struct Proxy { AzListView inner; Proxy(AzListView p) : inner(p) {} };

private:
    mutable AzListView inner_;

public:
    explicit ListView(AzListView inner) : inner_(inner) {}
    ListView(const ListView& other) : inner_(other.inner_) { memset(const_cast<AzListView*>(&other.inner_), 0, sizeof(other.inner_)); }
    ListView& operator=(const ListView& other) {
        AzListView_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzListView*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ListView(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ListView& operator=(Proxy p) {
        AzListView_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ListView() { AzListView_delete(&inner_); }

    static ListView create(StringVec columns);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Ribbon {
public:
    struct Proxy { AzRibbon inner; Proxy(AzRibbon p) : inner(p) {} };

private:
    mutable AzRibbon inner_;

public:
    explicit Ribbon(AzRibbon inner) : inner_(inner) {}
    Ribbon(const Ribbon& other) : inner_(other.inner_) { memset(const_cast<AzRibbon*>(&other.inner_), 0, sizeof(other.inner_)); }
    Ribbon& operator=(const Ribbon& other) {
        AzRibbon_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRibbon*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Ribbon(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Ribbon& operator=(Proxy p) {
        AzRibbon_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Ribbon() { AzRibbon_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TreeView {
public:
    struct Proxy { AzTreeView inner; Proxy(AzTreeView p) : inner(p) {} };

private:
    mutable AzTreeView inner_;

public:
    explicit TreeView(AzTreeView inner) : inner_(inner) {}
    TreeView(const TreeView& other) : inner_(other.inner_) { memset(const_cast<AzTreeView*>(&other.inner_), 0, sizeof(other.inner_)); }
    TreeView& operator=(const TreeView& other) {
        AzTreeView_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTreeView*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TreeView(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TreeView& operator=(Proxy p) {
        AzTreeView_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~TreeView() { AzTreeView_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CameraWidget {
public:
    struct Proxy { AzCameraWidget inner; Proxy(AzCameraWidget p) : inner(p) {} };

private:
    mutable AzCameraWidget inner_;

public:
    explicit CameraWidget(AzCameraWidget inner) : inner_(inner) {}
    CameraWidget(const CameraWidget& other) : inner_(other.inner_) { memset(const_cast<AzCameraWidget*>(&other.inner_), 0, sizeof(other.inner_)); }
    CameraWidget& operator=(const CameraWidget& other) {
        AzCameraWidget_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCameraWidget*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CameraWidget(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CameraWidget& operator=(Proxy p) {
        AzCameraWidget_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~CameraWidget() { AzCameraWidget_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ScreenCaptureWidget {
public:
    struct Proxy { AzScreenCaptureWidget inner; Proxy(AzScreenCaptureWidget p) : inner(p) {} };

private:
    mutable AzScreenCaptureWidget inner_;

public:
    explicit ScreenCaptureWidget(AzScreenCaptureWidget inner) : inner_(inner) {}
    ScreenCaptureWidget(const ScreenCaptureWidget& other) : inner_(other.inner_) { memset(const_cast<AzScreenCaptureWidget*>(&other.inner_), 0, sizeof(other.inner_)); }
    ScreenCaptureWidget& operator=(const ScreenCaptureWidget& other) {
        AzScreenCaptureWidget_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzScreenCaptureWidget*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ScreenCaptureWidget(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ScreenCaptureWidget& operator=(Proxy p) {
        AzScreenCaptureWidget_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ScreenCaptureWidget() { AzScreenCaptureWidget_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VideoWidget {
public:
    struct Proxy { AzVideoWidget inner; Proxy(AzVideoWidget p) : inner(p) {} };

private:
    mutable AzVideoWidget inner_;

public:
    explicit VideoWidget(AzVideoWidget inner) : inner_(inner) {}
    VideoWidget(const VideoWidget& other) : inner_(other.inner_) { memset(const_cast<AzVideoWidget*>(&other.inner_), 0, sizeof(other.inner_)); }
    VideoWidget& operator=(const VideoWidget& other) {
        AzVideoWidget_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVideoWidget*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VideoWidget(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VideoWidget& operator=(Proxy p) {
        AzVideoWidget_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~VideoWidget() { AzVideoWidget_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class MicrophoneWidget {
public:
    struct Proxy { AzMicrophoneWidget inner; Proxy(AzMicrophoneWidget p) : inner(p) {} };

private:
    mutable AzMicrophoneWidget inner_;

public:
    explicit MicrophoneWidget(AzMicrophoneWidget inner) : inner_(inner) {}
    MicrophoneWidget(const MicrophoneWidget& other) : inner_(other.inner_) { memset(const_cast<AzMicrophoneWidget*>(&other.inner_), 0, sizeof(other.inner_)); }
    MicrophoneWidget& operator=(const MicrophoneWidget& other) {
        AzMicrophoneWidget_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzMicrophoneWidget*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    MicrophoneWidget(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    MicrophoneWidget& operator=(Proxy p) {
        AzMicrophoneWidget_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~MicrophoneWidget() { AzMicrophoneWidget_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TessellatedGPUSvgNode {
public:
    struct Proxy { AzTessellatedGPUSvgNode inner; Proxy(AzTessellatedGPUSvgNode p) : inner(p) {} };

private:
    mutable AzTessellatedGPUSvgNode inner_;

public:
    explicit TessellatedGPUSvgNode(AzTessellatedGPUSvgNode inner) : inner_(inner) {}
    TessellatedGPUSvgNode(const TessellatedGPUSvgNode& other) : inner_(other.inner_) { memset(const_cast<AzTessellatedGPUSvgNode*>(&other.inner_), 0, sizeof(other.inner_)); }
    TessellatedGPUSvgNode& operator=(const TessellatedGPUSvgNode& other) {
        AzTessellatedGPUSvgNode_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTessellatedGPUSvgNode*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TessellatedGPUSvgNode(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TessellatedGPUSvgNode& operator=(Proxy p) {
        AzTessellatedGPUSvgNode_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~TessellatedGPUSvgNode() { AzTessellatedGPUSvgNode_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TessellatedColoredGPUSvgNode {
public:
    struct Proxy { AzTessellatedColoredGPUSvgNode inner; Proxy(AzTessellatedColoredGPUSvgNode p) : inner(p) {} };

private:
    mutable AzTessellatedColoredGPUSvgNode inner_;

public:
    explicit TessellatedColoredGPUSvgNode(AzTessellatedColoredGPUSvgNode inner) : inner_(inner) {}
    TessellatedColoredGPUSvgNode(const TessellatedColoredGPUSvgNode& other) : inner_(other.inner_) { memset(const_cast<AzTessellatedColoredGPUSvgNode*>(&other.inner_), 0, sizeof(other.inner_)); }
    TessellatedColoredGPUSvgNode& operator=(const TessellatedColoredGPUSvgNode& other) {
        AzTessellatedColoredGPUSvgNode_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTessellatedColoredGPUSvgNode*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TessellatedColoredGPUSvgNode(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TessellatedColoredGPUSvgNode& operator=(Proxy p) {
        AzTessellatedColoredGPUSvgNode_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class XmlTextError {
public:
    struct Proxy { AzXmlTextError inner; Proxy(AzXmlTextError p) : inner(p) {} };

private:
    mutable AzXmlTextError inner_;

public:
    explicit XmlTextError(AzXmlTextError inner) : inner_(inner) {}
    XmlTextError(const XmlTextError& other) : inner_(other.inner_) { memset(const_cast<AzXmlTextError*>(&other.inner_), 0, sizeof(other.inner_)); }
    XmlTextError& operator=(const XmlTextError& other) {
        AzXmlTextError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzXmlTextError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    XmlTextError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    XmlTextError& operator=(Proxy p) {
        AzXmlTextError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class JsonKeyValue {
public:
    struct Proxy { AzJsonKeyValue inner; Proxy(AzJsonKeyValue p) : inner(p) {} };

private:
    mutable AzJsonKeyValue inner_;

public:
    explicit JsonKeyValue(AzJsonKeyValue inner) : inner_(inner) {}
    JsonKeyValue(const JsonKeyValue& other) : inner_(other.inner_) { memset(const_cast<AzJsonKeyValue*>(&other.inner_), 0, sizeof(other.inner_)); }
    JsonKeyValue& operator=(const JsonKeyValue& other) {
        AzJsonKeyValue_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzJsonKeyValue*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    JsonKeyValue(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    JsonKeyValue& operator=(Proxy p) {
        AzJsonKeyValue_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~JsonKeyValue() { AzJsonKeyValue_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ExternalResource {
public:
    struct Proxy { AzExternalResource inner; Proxy(AzExternalResource p) : inner(p) {} };

private:
    mutable AzExternalResource inner_;

public:
    explicit ExternalResource(AzExternalResource inner) : inner_(inner) {}
    ExternalResource(const ExternalResource& other) : inner_(other.inner_) { memset(const_cast<AzExternalResource*>(&other.inner_), 0, sizeof(other.inner_)); }
    ExternalResource& operator=(const ExternalResource& other) {
        AzExternalResource_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzExternalResource*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ExternalResource(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ExternalResource& operator=(Proxy p) {
        AzExternalResource_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentCallbackArg {
public:
    struct Proxy { AzComponentCallbackArg inner; Proxy(AzComponentCallbackArg p) : inner(p) {} };

private:
    mutable AzComponentCallbackArg inner_;

public:
    explicit ComponentCallbackArg(AzComponentCallbackArg inner) : inner_(inner) {}
    ComponentCallbackArg(const ComponentCallbackArg& other) : inner_(other.inner_) { memset(const_cast<AzComponentCallbackArg*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentCallbackArg& operator=(const ComponentCallbackArg& other) {
        AzComponentCallbackArg_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentCallbackArg*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentCallbackArg(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentCallbackArg& operator=(Proxy p) {
        AzComponentCallbackArg_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class PlatformSpecificOptions {
public:
    struct Proxy { AzPlatformSpecificOptions inner; Proxy(AzPlatformSpecificOptions p) : inner(p) {} };

private:
    mutable AzPlatformSpecificOptions inner_;

public:
    explicit PlatformSpecificOptions(AzPlatformSpecificOptions inner) : inner_(inner) {}
    PlatformSpecificOptions(const PlatformSpecificOptions& other) : inner_(other.inner_) { memset(const_cast<AzPlatformSpecificOptions*>(&other.inner_), 0, sizeof(other.inner_)); }
    PlatformSpecificOptions& operator=(const PlatformSpecificOptions& other) {
        AzPlatformSpecificOptions_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzPlatformSpecificOptions*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    PlatformSpecificOptions(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    PlatformSpecificOptions& operator=(Proxy p) {
        AzPlatformSpecificOptions_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~PlatformSpecificOptions() { AzPlatformSpecificOptions_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextChangeset {
public:
    struct Proxy { AzTextChangeset inner; Proxy(AzTextChangeset p) : inner(p) {} };

private:
    mutable AzTextChangeset inner_;

public:
    explicit TextChangeset(AzTextChangeset inner) : inner_(inner) {}
    TextChangeset(const TextChangeset& other) : inner_(other.inner_) { memset(const_cast<AzTextChangeset*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextChangeset& operator=(const TextChangeset& other) {
        AzTextChangeset_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextChangeset*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextChangeset(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextChangeset& operator=(Proxy p) {
        AzTextChangeset_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Dom {
public:
    struct Proxy { AzDom inner; Proxy(AzDom p) : inner(p) {} };

private:
    mutable AzDom inner_;

public:
    explicit Dom(AzDom inner) : inner_(inner) {}
    Dom(const Dom& other) : inner_(other.inner_) { memset(const_cast<AzDom*>(&other.inner_), 0, sizeof(other.inner_)); }
    Dom& operator=(const Dom& other) {
        AzDom_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDom*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Dom(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Dom& operator=(Proxy p) {
        AzDom_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Dom() { AzDom_delete(&inner_); }

    static Dom create_body();
    static Dom create_div();
    static Dom create_br();
    static Dom create_text(String value);
    static Dom create_image(ImageRef image);
    static Dom create_icon(String icon_name);
    static Dom create_virtual_view(RefAny data, AzVirtualViewCallbackType callback);
    static Dom create_node(AzNodeType node_type);
    static Dom create_from_data(NodeData node_data);
    static Dom create_from_parsed_xml(AzXml xml);
    static Dom create_html();
    static Dom create_head();
    static Dom create_article();
    static Dom create_section();
    static Dom create_nav();
    static Dom create_aside();
    static Dom create_header();
    static Dom create_footer();
    static Dom create_main();
    static Dom create_figure();
    static Dom create_figcaption();
    static Dom create_details(SmallAriaInfo aria);
    static Dom create_details_no_a11y();
    static Dom create_summary(SmallAriaInfo aria);
    static Dom create_summary_no_a11y();
    static Dom create_summary_with_text(String text, SmallAriaInfo aria);
    static Dom create_summary_with_text_no_a11y(String text);
    static Dom create_dialog(DialogAriaInfo aria);
    static Dom create_dialog_no_a11y();
    static Dom create_p();
    static Dom create_h1();
    static Dom create_h1_with_text(String text);
    static Dom create_h2();
    static Dom create_h2_with_text(String text);
    static Dom create_h3();
    static Dom create_h3_with_text(String text);
    static Dom create_h4();
    static Dom create_h4_with_text(String text);
    static Dom create_h5();
    static Dom create_h5_with_text(String text);
    static Dom create_h6();
    static Dom create_h6_with_text(String text);
    static Dom create_span();
    static Dom create_span_with_text(String text);
    static Dom create_strong();
    static Dom create_strong_with_text(String text);
    static Dom create_em();
    static Dom create_em_with_text(String text);
    static Dom create_code();
    static Dom create_code_with_text(String code);
    static Dom create_pre();
    static Dom create_pre_with_text(String text);
    static Dom create_blockquote();
    static Dom create_blockquote_with_text(String text);
    static Dom create_cite();
    static Dom create_cite_with_text(String text);
    static Dom create_abbr();
    static Dom create_abbr_with_title(String abbr_text, String title);
    static Dom create_kbd();
    static Dom create_kbd_with_text(String text);
    static Dom create_samp();
    static Dom create_samp_with_text(String text);
    static Dom create_var();
    static Dom create_var_with_text(String text);
    static Dom create_sub();
    static Dom create_sub_with_text(String text);
    static Dom create_sup();
    static Dom create_sup_with_text(String text);
    static Dom create_u();
    static Dom create_u_with_text(String text);
    static Dom create_s();
    static Dom create_s_with_text(String text);
    static Dom create_mark();
    static Dom create_mark_with_text(String text);
    static Dom create_del();
    static Dom create_del_with_text(String text);
    static Dom create_ins();
    static Dom create_ins_with_text(String text);
    static Dom create_dfn();
    static Dom create_dfn_with_text(String text);
    static Dom create_time(String text, OptionString datetime);
    static Dom create_bdo();
    static Dom create_bdo_with_text(String text);
    static Dom create_a(String href, String text, SmallAriaInfo aria);
    static Dom create_a_no_a11y(String href, OptionString label);
    static Dom create_button(String text, SmallAriaInfo aria);
    static Dom create_button_no_a11y(String text);
    static Dom create_label(String for_id, String text, SmallAriaInfo aria);
    static Dom create_label_no_a11y(String for_id, String text);
    static Dom create_input(String input_type, String name, String label, SmallAriaInfo aria);
    static Dom create_input_no_a11y(String input_type, String name, String label);
    static Dom create_textarea(String name, String label, SmallAriaInfo aria);
    static Dom create_textarea_no_a11y(String name, String label);
    static Dom create_select(String name, String label, SmallAriaInfo aria);
    static Dom create_select_no_a11y(String name, String label);
    static Dom create_option(String value, String text, SmallAriaInfo aria);
    static Dom create_option_no_a11y(String value, String text);
    static Dom create_ul();
    static Dom create_ol();
    static Dom create_li();
    static Dom create_table(String caption, SmallAriaInfo aria);
    static Dom create_table_no_a11y();
    static Dom create_caption();
    static Dom create_thead();
    static Dom create_tbody();
    static Dom create_tfoot();
    static Dom create_tr();
    static Dom create_th();
    static Dom create_td();
    static Dom create_form(SmallAriaInfo aria);
    static Dom create_form_no_a11y();
    static Dom create_fieldset(SmallAriaInfo aria);
    static Dom create_fieldset_no_a11y();
    static Dom create_legend(SmallAriaInfo aria);
    static Dom create_legend_no_a11y();
    static Dom create_hr();
    static Dom create_address();
    static Dom create_dl();
    static Dom create_dt();
    static Dom create_dd();
    static Dom create_colgroup();
    static Dom create_col(int32_t span);
    static Dom create_optgroup(String label, SmallAriaInfo aria);
    static Dom create_optgroup_no_a11y(String label);
    static Dom create_q();
    static Dom create_acronym();
    static Dom create_acronym_with_text(String text);
    static Dom create_menu(SmallAriaInfo aria);
    static Dom create_menu_no_a11y();
    static Dom create_menuitem(SmallAriaInfo aria);
    static Dom create_menuitem_no_a11y();
    static Dom create_menuitem_with_text(String text, SmallAriaInfo aria);
    static Dom create_menuitem_with_text_no_a11y(String text);
    static Dom create_output(SmallAriaInfo aria);
    static Dom create_output_no_a11y();
    static Dom create_progress(ProgressAriaInfo aria);
    static Dom create_progress_no_a11y(float value, float max);
    static Dom create_meter(MeterAriaInfo aria);
    static Dom create_meter_no_a11y(float value, float min, float max);
    static Dom create_datalist(SmallAriaInfo aria);
    static Dom create_datalist_no_a11y();
    static Dom create_canvas(SmallAriaInfo aria);
    static Dom create_canvas_no_a11y();
    static Dom create_object();
    static Dom create_param(String name, String value);
    static Dom create_embed();
    static Dom create_audio(SmallAriaInfo aria);
    static Dom create_audio_no_a11y();
    static Dom create_video(SmallAriaInfo aria);
    static Dom create_video_no_a11y();
    static Dom create_source(String src, String media_type);
    static Dom create_track(String src, String kind);
    static Dom create_map();
    static Dom create_area(SmallAriaInfo aria);
    static Dom create_area_no_a11y();
    static Dom create_title();
    static Dom create_title_with_text(String text);
    static Dom create_meta();
    static Dom create_link();
    static Dom create_script();
    static Dom create_style();
    static Dom create_style_with_text(String text);
    static Dom create_base(String href);
    static Dom create_b();
    static Dom create_b_with_text(String text);
    static Dom create_i();
    static Dom create_i_with_text(String text);
    static Dom create_small();
    static Dom create_small_with_text(String text);
    static Dom create_big();
    static Dom create_big_with_text(String text);
    static Dom create_bdi();
    static Dom create_bdi_with_text(String text);
    static Dom create_wbr();
    static Dom create_ruby();
    static Dom create_rt();
    static Dom create_rt_with_text(String text);
    static Dom create_rtc();
    static Dom create_rp();
    static Dom create_rp_with_text(String text);
    static Dom create_data(String value);
    static Dom create_data_with_text(String value, String text);
    static Dom create_dir();
    static Dom create_svg();
    static Dom create_th_with_scope(String scope, String text);
    static Dom create_td_with_text(String text);
    static Dom create_th_with_text(String text);
    static Dom create_li_with_text(String text);
    static Dom create_p_with_text(String text);
    static Dom create_geolocation_probe(GeolocationProbeConfig config);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class SystemStyle {
public:
    struct Proxy { AzSystemStyle inner; Proxy(AzSystemStyle p) : inner(p) {} };

private:
    mutable AzSystemStyle inner_;

public:
    explicit SystemStyle(AzSystemStyle inner) : inner_(inner) {}
    SystemStyle(const SystemStyle& other) : inner_(other.inner_) { memset(const_cast<AzSystemStyle*>(&other.inner_), 0, sizeof(other.inner_)); }
    SystemStyle& operator=(const SystemStyle& other) {
        AzSystemStyle_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzSystemStyle*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    SystemStyle(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    SystemStyle& operator=(Proxy p) {
        AzSystemStyle_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~SystemStyle() { AzSystemStyle_delete(&inner_); }

    static SystemStyle detect();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssStyleBorderRadiusParseErrorOwned {
public:
    struct Proxy { AzCssStyleBorderRadiusParseErrorOwned inner; Proxy(AzCssStyleBorderRadiusParseErrorOwned p) : inner(p) {} };

private:
    mutable AzCssStyleBorderRadiusParseErrorOwned inner_;

public:
    explicit CssStyleBorderRadiusParseErrorOwned(AzCssStyleBorderRadiusParseErrorOwned inner) : inner_(inner) {}
    CssStyleBorderRadiusParseErrorOwned(const CssStyleBorderRadiusParseErrorOwned& other) : inner_(other.inner_) { memset(const_cast<AzCssStyleBorderRadiusParseErrorOwned*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssStyleBorderRadiusParseErrorOwned& operator=(const CssStyleBorderRadiusParseErrorOwned& other) {
        AzCssStyleBorderRadiusParseErrorOwned_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssStyleBorderRadiusParseErrorOwned*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssStyleBorderRadiusParseErrorOwned(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssStyleBorderRadiusParseErrorOwned& operator=(Proxy p) {
        AzCssStyleBorderRadiusParseErrorOwned_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FileInput {
public:
    struct Proxy { AzFileInput inner; Proxy(AzFileInput p) : inner(p) {} };

private:
    mutable AzFileInput inner_;

public:
    explicit FileInput(AzFileInput inner) : inner_(inner) {}
    FileInput(const FileInput& other) : inner_(other.inner_) { memset(const_cast<AzFileInput*>(&other.inner_), 0, sizeof(other.inner_)); }
    FileInput& operator=(const FileInput& other) {
        AzFileInput_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFileInput*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FileInput(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FileInput& operator=(Proxy p) {
        AzFileInput_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~FileInput() { AzFileInput_delete(&inner_); }

    static FileInput create(OptionString path);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CheckBox {
public:
    struct Proxy { AzCheckBox inner; Proxy(AzCheckBox p) : inner(p) {} };

private:
    mutable AzCheckBox inner_;

public:
    explicit CheckBox(AzCheckBox inner) : inner_(inner) {}
    CheckBox(const CheckBox& other) : inner_(other.inner_) { memset(const_cast<AzCheckBox*>(&other.inner_), 0, sizeof(other.inner_)); }
    CheckBox& operator=(const CheckBox& other) {
        AzCheckBox_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCheckBox*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CheckBox(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CheckBox& operator=(Proxy p) {
        AzCheckBox_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~CheckBox() { AzCheckBox_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ColorInput {
public:
    struct Proxy { AzColorInput inner; Proxy(AzColorInput p) : inner(p) {} };

private:
    mutable AzColorInput inner_;

public:
    explicit ColorInput(AzColorInput inner) : inner_(inner) {}
    ColorInput(const ColorInput& other) : inner_(other.inner_) { memset(const_cast<AzColorInput*>(&other.inner_), 0, sizeof(other.inner_)); }
    ColorInput& operator=(const ColorInput& other) {
        AzColorInput_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzColorInput*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ColorInput(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ColorInput& operator=(Proxy p) {
        AzColorInput_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~ColorInput() { AzColorInput_delete(&inner_); }

    static ColorInput create(ColorU color);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class TextInput {
public:
    struct Proxy { AzTextInput inner; Proxy(AzTextInput p) : inner(p) {} };

private:
    mutable AzTextInput inner_;

public:
    explicit TextInput(AzTextInput inner) : inner_(inner) {}
    TextInput(const TextInput& other) : inner_(other.inner_) { memset(const_cast<AzTextInput*>(&other.inner_), 0, sizeof(other.inner_)); }
    TextInput& operator=(const TextInput& other) {
        AzTextInput_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzTextInput*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    TextInput(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    TextInput& operator=(Proxy p) {
        AzTextInput_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~TextInput() { AzTextInput_delete(&inner_); }

    static TextInput create();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class ComponentDataField {
public:
    struct Proxy { AzComponentDataField inner; Proxy(AzComponentDataField p) : inner(p) {} };

private:
    mutable AzComponentDataField inner_;

public:
    explicit ComponentDataField(AzComponentDataField inner) : inner_(inner) {}
    ComponentDataField(const ComponentDataField& other) : inner_(other.inner_) { memset(const_cast<AzComponentDataField*>(&other.inner_), 0, sizeof(other.inner_)); }
    ComponentDataField& operator=(const ComponentDataField& other) {
        AzComponentDataField_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzComponentDataField*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ComponentDataField(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ComponentDataField& operator=(Proxy p) {
        AzComponentDataField_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class FullWindowState {
public:
    struct Proxy { AzFullWindowState inner; Proxy(AzFullWindowState p) : inner(p) {} };

private:
    mutable AzFullWindowState inner_;

public:
    explicit FullWindowState(AzFullWindowState inner) : inner_(inner) {}
    FullWindowState(const FullWindowState& other) : inner_(other.inner_) { memset(const_cast<AzFullWindowState*>(&other.inner_), 0, sizeof(other.inner_)); }
    FullWindowState& operator=(const FullWindowState& other) {
        AzFullWindowState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFullWindowState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    FullWindowState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    FullWindowState& operator=(Proxy p) {
        AzFullWindowState_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~FullWindowState() { AzFullWindowState_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class UndoableOperation {
public:
    struct Proxy { AzUndoableOperation inner; Proxy(AzUndoableOperation p) : inner(p) {} };

private:
    mutable AzUndoableOperation inner_;

public:
    explicit UndoableOperation(AzUndoableOperation inner) : inner_(inner) {}
    UndoableOperation(const UndoableOperation& other) : inner_(other.inner_) { memset(const_cast<AzUndoableOperation*>(&other.inner_), 0, sizeof(other.inner_)); }
    UndoableOperation& operator=(const UndoableOperation& other) {
        AzUndoableOperation_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzUndoableOperation*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    UndoableOperation(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    UndoableOperation& operator=(Proxy p) {
        AzUndoableOperation_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class NumberInput {
public:
    struct Proxy { AzNumberInput inner; Proxy(AzNumberInput p) : inner(p) {} };

private:
    mutable AzNumberInput inner_;

public:
    explicit NumberInput(AzNumberInput inner) : inner_(inner) {}
    NumberInput(const NumberInput& other) : inner_(other.inner_) { memset(const_cast<AzNumberInput*>(&other.inner_), 0, sizeof(other.inner_)); }
    NumberInput& operator=(const NumberInput& other) {
        AzNumberInput_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzNumberInput*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    NumberInput(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    NumberInput& operator=(Proxy p) {
        AzNumberInput_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~NumberInput() { AzNumberInput_delete(&inner_); }

    static NumberInput create(float number);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class Frame {
public:
    struct Proxy { AzFrame inner; Proxy(AzFrame p) : inner(p) {} };

private:
    mutable AzFrame inner_;

public:
    explicit Frame(AzFrame inner) : inner_(inner) {}
    Frame(const Frame& other) : inner_(other.inner_) { memset(const_cast<AzFrame*>(&other.inner_), 0, sizeof(other.inner_)); }
    Frame& operator=(const Frame& other) {
        AzFrame_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzFrame*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Frame(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Frame& operator=(Proxy p) {
        AzFrame_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~Frame() { AzFrame_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class RibbonSection {
public:
    struct Proxy { AzRibbonSection inner; Proxy(AzRibbonSection p) : inner(p) {} };

private:
    mutable AzRibbonSection inner_;

public:
    explicit RibbonSection(AzRibbonSection inner) : inner_(inner) {}
    RibbonSection(const RibbonSection& other) : inner_(other.inner_) { memset(const_cast<AzRibbonSection*>(&other.inner_), 0, sizeof(other.inner_)); }
    RibbonSection& operator=(const RibbonSection& other) {
        AzRibbonSection_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzRibbonSection*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    RibbonSection(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    RibbonSection& operator=(Proxy p) {
        AzRibbonSection_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~RibbonSection() { AzRibbonSection_delete(&inner_); }

    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class AppConfig {
public:
    struct Proxy { AzAppConfig inner; Proxy(AzAppConfig p) : inner(p) {} };

private:
    mutable AzAppConfig inner_;

public:
    explicit AppConfig(AzAppConfig inner) : inner_(inner) {}
    AppConfig(const AppConfig& other) : inner_(other.inner_) { memset(const_cast<AzAppConfig*>(&other.inner_), 0, sizeof(other.inner_)); }
    AppConfig& operator=(const AppConfig& other) {
        AzAppConfig_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzAppConfig*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    AppConfig(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    AppConfig& operator=(Proxy p) {
        AzAppConfig_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~AppConfig() { AzAppConfig_delete(&inner_); }

    static AppConfig create();
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class WindowCreateOptions {
public:
    struct Proxy { AzWindowCreateOptions inner; Proxy(AzWindowCreateOptions p) : inner(p) {} };

private:
    mutable AzWindowCreateOptions inner_;

public:
    explicit WindowCreateOptions(AzWindowCreateOptions inner) : inner_(inner) {}
    WindowCreateOptions(const WindowCreateOptions& other) : inner_(other.inner_) { memset(const_cast<AzWindowCreateOptions*>(&other.inner_), 0, sizeof(other.inner_)); }
    WindowCreateOptions& operator=(const WindowCreateOptions& other) {
        AzWindowCreateOptions_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzWindowCreateOptions*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    WindowCreateOptions(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    WindowCreateOptions& operator=(Proxy p) {
        AzWindowCreateOptions_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~WindowCreateOptions() { AzWindowCreateOptions_delete(&inner_); }

    static WindowCreateOptions create(AzLayoutCallbackType layout_callback);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class VirtualViewReturn {
public:
    struct Proxy { AzVirtualViewReturn inner; Proxy(AzVirtualViewReturn p) : inner(p) {} };

private:
    mutable AzVirtualViewReturn inner_;

public:
    explicit VirtualViewReturn(AzVirtualViewReturn inner) : inner_(inner) {}
    VirtualViewReturn(const VirtualViewReturn& other) : inner_(other.inner_) { memset(const_cast<AzVirtualViewReturn*>(&other.inner_), 0, sizeof(other.inner_)); }
    VirtualViewReturn& operator=(const VirtualViewReturn& other) {
        AzVirtualViewReturn_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzVirtualViewReturn*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    VirtualViewReturn(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    VirtualViewReturn& operator=(Proxy p) {
        AzVirtualViewReturn_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~VirtualViewReturn() { AzVirtualViewReturn_delete(&inner_); }

    static VirtualViewReturn with_dom(Dom dom, LogicalSize scroll_size, LogicalPosition scroll_offset, LogicalSize virtual_scroll_size, LogicalPosition virtual_scroll_offset);
    static VirtualViewReturn keep_current(LogicalSize scroll_size, LogicalPosition scroll_offset, LogicalSize virtual_scroll_size, LogicalPosition virtual_scroll_offset);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class DynamicCssProperty {
public:
    struct Proxy { AzDynamicCssProperty inner; Proxy(AzDynamicCssProperty p) : inner(p) {} };

private:
    mutable AzDynamicCssProperty inner_;

public:
    explicit DynamicCssProperty(AzDynamicCssProperty inner) : inner_(inner) {}
    DynamicCssProperty(const DynamicCssProperty& other) : inner_(other.inner_) { memset(const_cast<AzDynamicCssProperty*>(&other.inner_), 0, sizeof(other.inner_)); }
    DynamicCssProperty& operator=(const DynamicCssProperty& other) {
        AzDynamicCssProperty_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzDynamicCssProperty*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    DynamicCssProperty(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    DynamicCssProperty& operator=(Proxy p) {
        AzDynamicCssProperty_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssPropertyWithConditions {
public:
    struct Proxy { AzCssPropertyWithConditions inner; Proxy(AzCssPropertyWithConditions p) : inner(p) {} };

private:
    mutable AzCssPropertyWithConditions inner_;

public:
    explicit CssPropertyWithConditions(AzCssPropertyWithConditions inner) : inner_(inner) {}
    CssPropertyWithConditions(const CssPropertyWithConditions& other) : inner_(other.inner_) { memset(const_cast<AzCssPropertyWithConditions*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssPropertyWithConditions& operator=(const CssPropertyWithConditions& other) {
        AzCssPropertyWithConditions_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssPropertyWithConditions*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssPropertyWithConditions(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssPropertyWithConditions& operator=(Proxy p) {
        AzCssPropertyWithConditions_delete(&inner_);
        inner_ = p.inner;
        return *this;
    }
    ~CssPropertyWithConditions() { AzCssPropertyWithConditions_delete(&inner_); }

    static CssPropertyWithConditions simple(AzCssProperty property);
    static CssPropertyWithConditions with_condition(AzCssProperty property, AzDynamicSelector condition);
    static CssPropertyWithConditions with_conditions(AzCssProperty property, DynamicSelectorVec conditions);
    static CssPropertyWithConditions on_hover(AzCssProperty property);
    static CssPropertyWithConditions on_active(AzCssProperty property);
    static CssPropertyWithConditions on_focus(AzCssProperty property);
    static CssPropertyWithConditions when_disabled(AzCssProperty property);
    static CssPropertyWithConditions on_os(AzCssProperty property, AzOsCondition os);
    static CssPropertyWithConditions dark_theme(AzCssProperty property);
    static CssPropertyWithConditions light_theme(AzCssProperty property);
    static CssPropertyWithConditions on_windows(AzCssProperty property);
    static CssPropertyWithConditions on_macos(AzCssProperty property);
    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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssBorderParseErrorOwned {
public:
    struct Proxy { AzCssBorderParseErrorOwned inner; Proxy(AzCssBorderParseErrorOwned p) : inner(p) {} };

private:
    mutable AzCssBorderParseErrorOwned inner_;

public:
    explicit CssBorderParseErrorOwned(AzCssBorderParseErrorOwned inner) : inner_(inner) {}
    CssBorderParseErrorOwned(const CssBorderParseErrorOwned& other) : inner_(other.inner_) { memset(const_cast<AzCssBorderParseErrorOwned*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssBorderParseErrorOwned& operator=(const CssBorderParseErrorOwned& other) {
        AzCssBorderParseErrorOwned_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssBorderParseErrorOwned*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssBorderParseErrorOwned(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssBorderParseErrorOwned& operator=(Proxy p) {
        AzCssBorderParseErrorOwned_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class CssParseErrorOwned {
public:
    struct Proxy { AzCssParseErrorOwned inner; Proxy(AzCssParseErrorOwned p) : inner(p) {} };

private:
    mutable AzCssParseErrorOwned inner_;

public:
    explicit CssParseErrorOwned(AzCssParseErrorOwned inner) : inner_(inner) {}
    CssParseErrorOwned(const CssParseErrorOwned& other) : inner_(other.inner_) { memset(const_cast<AzCssParseErrorOwned*>(&other.inner_), 0, sizeof(other.inner_)); }
    CssParseErrorOwned& operator=(const CssParseErrorOwned& other) {
        AzCssParseErrorOwned_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzCssParseErrorOwned*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    CssParseErrorOwned(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    CssParseErrorOwned& operator=(Proxy p) {
        AzCssParseErrorOwned_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(inner_)); return result; }
};

class OptionI16 {
private:
    AzOptionI16 inner_;

public:
    OptionI16(AzOptionI16 inner) : inner_(inner) {}
    OptionI16(const OptionI16& other) : inner_(other.inner_) {}
    OptionI16& operator=(const OptionI16& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionU16 {
private:
    AzOptionU16 inner_;

public:
    OptionU16(AzOptionU16 inner) : inner_(inner) {}
    OptionU16(const OptionU16& other) : inner_(other.inner_) {}
    OptionU16& operator=(const OptionU16& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionU32 {
private:
    AzOptionU32 inner_;

public:
    OptionU32(AzOptionU32 inner) : inner_(inner) {}
    OptionU32(const OptionU32& other) : inner_(other.inner_) {}
    OptionU32& operator=(const OptionU32& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionUsize {
private:
    AzOptionUsize inner_;

public:
    OptionUsize(AzOptionUsize inner) : inner_(inner) {}
    OptionUsize(const OptionUsize& other) : inner_(other.inner_) {}
    OptionUsize& operator=(const OptionUsize& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionF32 {
private:
    AzOptionF32 inner_;

public:
    OptionF32(AzOptionF32 inner) : inner_(inner) {}
    OptionF32(const OptionF32& other) : inner_(other.inner_) {}
    OptionF32& operator=(const OptionF32& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionF64 {
private:
    AzOptionF64 inner_;

public:
    OptionF64(AzOptionF64 inner) : inner_(inner) {}
    OptionF64(const OptionF64& other) : inner_(other.inner_) {}
    OptionF64& operator=(const OptionF64& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionBool {
private:
    AzOptionBool inner_;

public:
    OptionBool(AzOptionBool inner) : inner_(inner) {}
    OptionBool(const OptionBool& other) : inner_(other.inner_) {}
    OptionBool& operator=(const OptionBool& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionI64 {
private:
    AzOptionI64 inner_;

public:
    OptionI64(AzOptionI64 inner) : inner_(inner) {}
    OptionI64(const OptionI64& other) : inner_(other.inner_) {}
    OptionI64& operator=(const OptionI64& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionI32 {
private:
    AzOptionI32 inner_;

public:
    OptionI32(AzOptionI32 inner) : inner_(inner) {}
    OptionI32(const OptionI32& other) : inner_(other.inner_) {}
    OptionI32& operator=(const OptionI32& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionU64 {
private:
    AzOptionU64 inner_;

public:
    OptionU64(AzOptionU64 inner) : inner_(inner) {}
    OptionU64(const OptionU64& other) : inner_(other.inner_) {}
    OptionU64& operator=(const OptionU64& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionU8 {
private:
    AzOptionU8 inner_;

public:
    OptionU8(AzOptionU8 inner) : inner_(inner) {}
    OptionU8(const OptionU8& other) : inner_(other.inner_) {}
    OptionU8& operator=(const OptionU8& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionTimerId {
private:
    AzOptionTimerId inner_;

public:
    OptionTimerId(AzOptionTimerId inner) : inner_(inner) {}
    OptionTimerId(const OptionTimerId& other) : inner_(other.inner_) {}
    OptionTimerId& operator=(const OptionTimerId& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionThread {
public:
    struct Proxy { AzOptionThread inner; Proxy(AzOptionThread p) : inner(p) {} };

private:
    mutable AzOptionThread inner_;

public:
    explicit OptionThread(AzOptionThread inner) : inner_(inner) {}
    OptionThread(const OptionThread& other) : inner_(other.inner_) { memset(const_cast<AzOptionThread*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionThread& operator=(const OptionThread& other) {
        AzOptionThread_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionThread*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionThread(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionThread& operator=(Proxy p) {
        AzOptionThread_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionImageRef {
public:
    struct Proxy { AzOptionImageRef inner; Proxy(AzOptionImageRef p) : inner(p) {} };

private:
    mutable AzOptionImageRef inner_;

public:
    explicit OptionImageRef(AzOptionImageRef inner) : inner_(inner) {}
    OptionImageRef(const OptionImageRef& other) : inner_(other.inner_) { memset(const_cast<AzOptionImageRef*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionImageRef& operator=(const OptionImageRef& other) {
        AzOptionImageRef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionImageRef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionImageRef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionImageRef& operator=(Proxy p) {
        AzOptionImageRef_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionLayoutSize {
private:
    AzOptionLayoutSize inner_;

public:
    OptionLayoutSize(AzOptionLayoutSize inner) : inner_(inner) {}
    OptionLayoutSize(const OptionLayoutSize& other) : inner_(other.inner_) {}
    OptionLayoutSize& operator=(const OptionLayoutSize& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionColorU {
private:
    AzOptionColorU inner_;

public:
    OptionColorU(AzOptionColorU inner) : inner_(inner) {}
    OptionColorU(const OptionColorU& other) : inner_(other.inner_) {}
    OptionColorU& operator=(const OptionColorU& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionTabIndex {
private:
    AzOptionTabIndex inner_;

public:
    OptionTabIndex(AzOptionTabIndex inner) : inner_(inner) {}
    OptionTabIndex(const OptionTabIndex& other) : inner_(other.inner_) {}
    OptionTabIndex& operator=(const OptionTabIndex& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionLogicalPosition {
private:
    AzOptionLogicalPosition inner_;

public:
    OptionLogicalPosition(AzOptionLogicalPosition inner) : inner_(inner) {}
    OptionLogicalPosition(const OptionLogicalPosition& other) : inner_(other.inner_) {}
    OptionLogicalPosition& operator=(const OptionLogicalPosition& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionScreenPosition {
private:
    AzOptionScreenPosition inner_;

public:
    OptionScreenPosition(AzOptionScreenPosition inner) : inner_(inner) {}
    OptionScreenPosition(const OptionScreenPosition& other) : inner_(other.inner_) {}
    OptionScreenPosition& operator=(const OptionScreenPosition& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCursorNodePosition {
private:
    AzOptionCursorNodePosition inner_;

public:
    OptionCursorNodePosition(AzOptionCursorNodePosition inner) : inner_(inner) {}
    OptionCursorNodePosition(const OptionCursorNodePosition& other) : inner_(other.inner_) {}
    OptionCursorNodePosition& operator=(const OptionCursorNodePosition& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDragDelta {
private:
    AzOptionDragDelta inner_;

public:
    OptionDragDelta(AzOptionDragDelta inner) : inner_(inner) {}
    OptionDragDelta(const OptionDragDelta& other) : inner_(other.inner_) {}
    OptionDragDelta& operator=(const OptionDragDelta& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionMouseCursorType {
private:
    AzOptionMouseCursorType inner_;

public:
    OptionMouseCursorType(AzOptionMouseCursorType inner) : inner_(inner) {}
    OptionMouseCursorType(const OptionMouseCursorType& other) : inner_(other.inner_) {}
    OptionMouseCursorType& operator=(const OptionMouseCursorType& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionHwndHandle {
public:
    struct Proxy { AzOptionHwndHandle inner; Proxy(AzOptionHwndHandle p) : inner(p) {} };

private:
    mutable AzOptionHwndHandle inner_;

public:
    explicit OptionHwndHandle(AzOptionHwndHandle inner) : inner_(inner) {}
    OptionHwndHandle(const OptionHwndHandle& other) : inner_(other.inner_) { memset(const_cast<AzOptionHwndHandle*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionHwndHandle& operator=(const OptionHwndHandle& other) {
        AzOptionHwndHandle_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionHwndHandle*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionHwndHandle(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionHwndHandle& operator=(Proxy p) {
        AzOptionHwndHandle_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionLinuxDecorationsState {
private:
    AzOptionLinuxDecorationsState inner_;

public:
    OptionLinuxDecorationsState(AzOptionLinuxDecorationsState inner) : inner_(inner) {}
    OptionLinuxDecorationsState(const OptionLinuxDecorationsState& other) : inner_(other.inner_) {}
    OptionLinuxDecorationsState& operator=(const OptionLinuxDecorationsState& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionLogicalSize {
private:
    AzOptionLogicalSize inner_;

public:
    OptionLogicalSize(AzOptionLogicalSize inner) : inner_(inner) {}
    OptionLogicalSize(const OptionLogicalSize& other) : inner_(other.inner_) {}
    OptionLogicalSize& operator=(const OptionLogicalSize& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionVirtualKeyCode {
private:
    AzOptionVirtualKeyCode inner_;

public:
    OptionVirtualKeyCode(AzOptionVirtualKeyCode inner) : inner_(inner) {}
    OptionVirtualKeyCode(const OptionVirtualKeyCode& other) : inner_(other.inner_) {}
    OptionVirtualKeyCode& operator=(const OptionVirtualKeyCode& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionX11Visual {
private:
    AzOptionX11Visual inner_;

public:
    OptionX11Visual(AzOptionX11Visual inner) : inner_(inner) {}
    OptionX11Visual(const OptionX11Visual& other) : inner_(other.inner_) {}
    OptionX11Visual& operator=(const OptionX11Visual& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionWindowTheme {
private:
    AzOptionWindowTheme inner_;

public:
    OptionWindowTheme(AzOptionWindowTheme inner) : inner_(inner) {}
    OptionWindowTheme(const OptionWindowTheme& other) : inner_(other.inner_) {}
    OptionWindowTheme& operator=(const OptionWindowTheme& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionAccessibilityRole {
private:
    AzOptionAccessibilityRole inner_;

public:
    OptionAccessibilityRole(AzOptionAccessibilityRole inner) : inner_(inner) {}
    OptionAccessibilityRole(const OptionAccessibilityRole& other) : inner_(other.inner_) {}
    OptionAccessibilityRole& operator=(const OptionAccessibilityRole& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionPenTilt {
private:
    AzOptionPenTilt inner_;

public:
    OptionPenTilt(AzOptionPenTilt inner) : inner_(inner) {}
    OptionPenTilt(const OptionPenTilt& other) : inner_(other.inner_) {}
    OptionPenTilt& operator=(const OptionPenTilt& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionGestureDirection {
private:
    AzOptionGestureDirection inner_;

public:
    OptionGestureDirection(AzOptionGestureDirection inner) : inner_(inner) {}
    OptionGestureDirection(const OptionGestureDirection& other) : inner_(other.inner_) {}
    OptionGestureDirection& operator=(const OptionGestureDirection& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionThreadId {
private:
    AzOptionThreadId inner_;

public:
    OptionThreadId(AzOptionThreadId inner) : inner_(inner) {}
    OptionThreadId(const OptionThreadId& other) : inner_(other.inner_) {}
    OptionThreadId& operator=(const OptionThreadId& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDomId {
private:
    AzOptionDomId inner_;

public:
    OptionDomId(AzOptionDomId inner) : inner_(inner) {}
    OptionDomId(const OptionDomId& other) : inner_(other.inner_) {}
    OptionDomId& operator=(const OptionDomId& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionAccessibilityState {
private:
    AzOptionAccessibilityState inner_;

public:
    OptionAccessibilityState(AzOptionAccessibilityState inner) : inner_(inner) {}
    OptionAccessibilityState(const OptionAccessibilityState& other) : inner_(other.inner_) {}
    OptionAccessibilityState& operator=(const OptionAccessibilityState& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionSvgVertex {
private:
    AzOptionSvgVertex inner_;

public:
    OptionSvgVertex(AzOptionSvgVertex inner) : inner_(inner) {}
    OptionSvgVertex(const OptionSvgVertex& other) : inner_(other.inner_) {}
    OptionSvgVertex& operator=(const OptionSvgVertex& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCascadeInfo {
private:
    AzOptionCascadeInfo inner_;

public:
    OptionCascadeInfo(AzOptionCascadeInfo inner) : inner_(inner) {}
    OptionCascadeInfo(const OptionCascadeInfo& other) : inner_(other.inner_) {}
    OptionCascadeInfo& operator=(const OptionCascadeInfo& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionNodeHierarchyItem {
private:
    AzOptionNodeHierarchyItem inner_;

public:
    OptionNodeHierarchyItem(AzOptionNodeHierarchyItem inner) : inner_(inner) {}
    OptionNodeHierarchyItem(const OptionNodeHierarchyItem& other) : inner_(other.inner_) {}
    OptionNodeHierarchyItem& operator=(const OptionNodeHierarchyItem& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionXWindowType {
private:
    AzOptionXWindowType inner_;

public:
    OptionXWindowType(AzOptionXWindowType inner) : inner_(inner) {}
    OptionXWindowType(const OptionXWindowType& other) : inner_(other.inner_) {}
    OptionXWindowType& operator=(const OptionXWindowType& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionStyleBackgroundRepeat {
private:
    AzOptionStyleBackgroundRepeat inner_;

public:
    OptionStyleBackgroundRepeat(AzOptionStyleBackgroundRepeat inner) : inner_(inner) {}
    OptionStyleBackgroundRepeat(const OptionStyleBackgroundRepeat& other) : inner_(other.inner_) {}
    OptionStyleBackgroundRepeat& operator=(const OptionStyleBackgroundRepeat& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionShapePoint {
private:
    AzOptionShapePoint inner_;

public:
    OptionShapePoint(AzOptionShapePoint inner) : inner_(inner) {}
    OptionShapePoint(const OptionShapePoint& other) : inner_(other.inner_) {}
    OptionShapePoint& operator=(const OptionShapePoint& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionU8VecRef {
public:
    struct Proxy { AzOptionU8VecRef inner; Proxy(AzOptionU8VecRef p) : inner(p) {} };

private:
    mutable AzOptionU8VecRef inner_;

public:
    explicit OptionU8VecRef(AzOptionU8VecRef inner) : inner_(inner) {}
    OptionU8VecRef(const OptionU8VecRef& other) : inner_(other.inner_) { memset(const_cast<AzOptionU8VecRef*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionU8VecRef& operator=(const OptionU8VecRef& other) {
        AzOptionU8VecRef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionU8VecRef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionU8VecRef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionU8VecRef& operator=(Proxy p) {
        AzOptionU8VecRef_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionNodeHierarchyItemId {
private:
    AzOptionNodeHierarchyItemId inner_;

public:
    OptionNodeHierarchyItemId(AzOptionNodeHierarchyItemId inner) : inner_(inner) {}
    OptionNodeHierarchyItemId(const OptionNodeHierarchyItemId& other) : inner_(other.inner_) {}
    OptionNodeHierarchyItemId& operator=(const OptionNodeHierarchyItemId& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionLinuxDesktopEnv {
private:
    AzOptionLinuxDesktopEnv inner_;

public:
    OptionLinuxDesktopEnv(AzOptionLinuxDesktopEnv inner) : inner_(inner) {}
    OptionLinuxDesktopEnv(const OptionLinuxDesktopEnv& other) : inner_(other.inner_) {}
    OptionLinuxDesktopEnv& operator=(const OptionLinuxDesktopEnv& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionOsCondition {
private:
    AzOptionOsCondition inner_;

public:
    OptionOsCondition(AzOptionOsCondition inner) : inner_(inner) {}
    OptionOsCondition(const OptionOsCondition& other) : inner_(other.inner_) {}
    OptionOsCondition& operator=(const OptionOsCondition& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionSvgDashPattern {
private:
    AzOptionSvgDashPattern inner_;

public:
    OptionSvgDashPattern(AzOptionSvgDashPattern inner) : inner_(inner) {}
    OptionSvgDashPattern(const OptionSvgDashPattern& other) : inner_(other.inner_) {}
    OptionSvgDashPattern& operator=(const OptionSvgDashPattern& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionSvgPoint {
public:
    struct Proxy { AzOptionSvgPoint inner; Proxy(AzOptionSvgPoint p) : inner(p) {} };

private:
    mutable AzOptionSvgPoint inner_;

public:
    explicit OptionSvgPoint(AzOptionSvgPoint inner) : inner_(inner) {}
    OptionSvgPoint(const OptionSvgPoint& other) : inner_(other.inner_) { memset(const_cast<AzOptionSvgPoint*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionSvgPoint& operator=(const OptionSvgPoint& other) {
        AzOptionSvgPoint_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionSvgPoint*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionSvgPoint(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionSvgPoint& operator=(Proxy p) {
        AzOptionSvgPoint_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionLocationFix {
private:
    AzOptionLocationFix inner_;

public:
    OptionLocationFix(AzOptionLocationFix inner) : inner_(inner) {}
    OptionLocationFix(const OptionLocationFix& other) : inner_(other.inner_) {}
    OptionLocationFix& operator=(const OptionLocationFix& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionBiometricResult {
private:
    AzOptionBiometricResult inner_;

public:
    OptionBiometricResult(AzOptionBiometricResult inner) : inner_(inner) {}
    OptionBiometricResult(const OptionBiometricResult& other) : inner_(other.inner_) {}
    OptionBiometricResult& operator=(const OptionBiometricResult& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionWacomPadState {
private:
    AzOptionWacomPadState inner_;

public:
    OptionWacomPadState(AzOptionWacomPadState inner) : inner_(inner) {}
    OptionWacomPadState(const OptionWacomPadState& other) : inner_(other.inner_) {}
    OptionWacomPadState& operator=(const OptionWacomPadState& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionScrollState {
private:
    AzOptionScrollState inner_;

public:
    OptionScrollState(AzOptionScrollState inner) : inner_(inner) {}
    OptionScrollState(const OptionScrollState& other) : inner_(other.inner_) {}
    OptionScrollState& operator=(const OptionScrollState& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionPixelValue {
private:
    AzOptionPixelValue inner_;

public:
    OptionPixelValue(AzOptionPixelValue inner) : inner_(inner) {}
    OptionPixelValue(const OptionPixelValue& other) : inner_(other.inner_) {}
    OptionPixelValue& operator=(const OptionPixelValue& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionTextInputSelection {
public:
    struct Proxy { AzOptionTextInputSelection inner; Proxy(AzOptionTextInputSelection p) : inner(p) {} };

private:
    mutable AzOptionTextInputSelection inner_;

public:
    explicit OptionTextInputSelection(AzOptionTextInputSelection inner) : inner_(inner) {}
    OptionTextInputSelection(const OptionTextInputSelection& other) : inner_(other.inner_) { memset(const_cast<AzOptionTextInputSelection*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionTextInputSelection& operator=(const OptionTextInputSelection& other) {
        AzOptionTextInputSelection_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionTextInputSelection*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionTextInputSelection(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionTextInputSelection& operator=(Proxy p) {
        AzOptionTextInputSelection_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionMenuItemIcon {
public:
    struct Proxy { AzOptionMenuItemIcon inner; Proxy(AzOptionMenuItemIcon p) : inner(p) {} };

private:
    mutable AzOptionMenuItemIcon inner_;

public:
    explicit OptionMenuItemIcon(AzOptionMenuItemIcon inner) : inner_(inner) {}
    OptionMenuItemIcon(const OptionMenuItemIcon& other) : inner_(other.inner_) { memset(const_cast<AzOptionMenuItemIcon*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionMenuItemIcon& operator=(const OptionMenuItemIcon& other) {
        AzOptionMenuItemIcon_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionMenuItemIcon*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionMenuItemIcon(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionMenuItemIcon& operator=(Proxy p) {
        AzOptionMenuItemIcon_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionFontRef {
public:
    struct Proxy { AzOptionFontRef inner; Proxy(AzOptionFontRef p) : inner(p) {} };

private:
    mutable AzOptionFontRef inner_;

public:
    explicit OptionFontRef(AzOptionFontRef inner) : inner_(inner) {}
    OptionFontRef(const OptionFontRef& other) : inner_(other.inner_) { memset(const_cast<AzOptionFontRef*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionFontRef& operator=(const OptionFontRef& other) {
        AzOptionFontRef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionFontRef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionFontRef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionFontRef& operator=(Proxy p) {
        AzOptionFontRef_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionRefAny {
public:
    struct Proxy { AzOptionRefAny inner; Proxy(AzOptionRefAny p) : inner(p) {} };

private:
    mutable AzOptionRefAny inner_;

public:
    explicit OptionRefAny(AzOptionRefAny inner) : inner_(inner) {}
    OptionRefAny(const OptionRefAny& other) : inner_(other.inner_) { memset(const_cast<AzOptionRefAny*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionRefAny& operator=(const OptionRefAny& other) {
        AzOptionRefAny_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionRefAny*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionRefAny(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionRefAny& operator=(Proxy p) {
        AzOptionRefAny_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionLayoutRect {
private:
    AzOptionLayoutRect inner_;

public:
    OptionLayoutRect(AzOptionLayoutRect inner) : inner_(inner) {}
    OptionLayoutRect(const OptionLayoutRect& other) : inner_(other.inner_) {}
    OptionLayoutRect& operator=(const OptionLayoutRect& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDomNodeId {
private:
    AzOptionDomNodeId inner_;

public:
    OptionDomNodeId(AzOptionDomNodeId inner) : inner_(inner) {}
    OptionDomNodeId(const OptionDomNodeId& other) : inner_(other.inner_) {}
    OptionDomNodeId& operator=(const OptionDomNodeId& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDuration {
private:
    AzOptionDuration inner_;

public:
    OptionDuration(AzOptionDuration inner) : inner_(inner) {}
    OptionDuration(const OptionDuration& other) : inner_(other.inner_) {}
    OptionDuration& operator=(const OptionDuration& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionLogicalRect {
private:
    AzOptionLogicalRect inner_;

public:
    OptionLogicalRect(AzOptionLogicalRect inner) : inner_(inner) {}
    OptionLogicalRect(const OptionLogicalRect& other) : inner_(other.inner_) {}
    OptionLogicalRect& operator=(const OptionLogicalRect& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionRendererOptions {
private:
    AzOptionRendererOptions inner_;

public:
    OptionRendererOptions(AzOptionRendererOptions inner) : inner_(inner) {}
    OptionRendererOptions(const OptionRendererOptions& other) : inner_(other.inner_) {}
    OptionRendererOptions& operator=(const OptionRendererOptions& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionGlContextPtr {
public:
    struct Proxy { AzOptionGlContextPtr inner; Proxy(AzOptionGlContextPtr p) : inner(p) {} };

private:
    mutable AzOptionGlContextPtr inner_;

public:
    explicit OptionGlContextPtr(AzOptionGlContextPtr inner) : inner_(inner) {}
    OptionGlContextPtr(const OptionGlContextPtr& other) : inner_(other.inner_) { memset(const_cast<AzOptionGlContextPtr*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionGlContextPtr& operator=(const OptionGlContextPtr& other) {
        AzOptionGlContextPtr_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionGlContextPtr*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionGlContextPtr(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionGlContextPtr& operator=(Proxy p) {
        AzOptionGlContextPtr_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionTextCursor {
private:
    AzOptionTextCursor inner_;

public:
    OptionTextCursor(AzOptionTextCursor inner) : inner_(inner) {}
    OptionTextCursor(const OptionTextCursor& other) : inner_(other.inner_) {}
    OptionTextCursor& operator=(const OptionTextCursor& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionWindowFlags {
public:
    struct Proxy { AzOptionWindowFlags inner; Proxy(AzOptionWindowFlags p) : inner(p) {} };

private:
    mutable AzOptionWindowFlags inner_;

public:
    explicit OptionWindowFlags(AzOptionWindowFlags inner) : inner_(inner) {}
    OptionWindowFlags(const OptionWindowFlags& other) : inner_(other.inner_) { memset(const_cast<AzOptionWindowFlags*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionWindowFlags& operator=(const OptionWindowFlags& other) {
        AzOptionWindowFlags_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionWindowFlags*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionWindowFlags(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionWindowFlags& operator=(Proxy p) {
        AzOptionWindowFlags_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDetectedPinch {
private:
    AzOptionDetectedPinch inner_;

public:
    OptionDetectedPinch(AzOptionDetectedPinch inner) : inner_(inner) {}
    OptionDetectedPinch(const OptionDetectedPinch& other) : inner_(other.inner_) {}
    OptionDetectedPinch& operator=(const OptionDetectedPinch& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDetectedRotation {
private:
    AzOptionDetectedRotation inner_;

public:
    OptionDetectedRotation(AzOptionDetectedRotation inner) : inner_(inner) {}
    OptionDetectedRotation(const OptionDetectedRotation& other) : inner_(other.inner_) {}
    OptionDetectedRotation& operator=(const OptionDetectedRotation& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDetectedLongPress {
private:
    AzOptionDetectedLongPress inner_;

public:
    OptionDetectedLongPress(AzOptionDetectedLongPress inner) : inner_(inner) {}
    OptionDetectedLongPress(const OptionDetectedLongPress& other) : inner_(other.inner_) {}
    OptionDetectedLongPress& operator=(const OptionDetectedLongPress& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionPenState {
private:
    AzOptionPenState inner_;

public:
    OptionPenState(AzOptionPenState inner) : inner_(inner) {}
    OptionPenState(const OptionPenState& other) : inner_(other.inner_) {}
    OptionPenState& operator=(const OptionPenState& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionStyledNode {
public:
    struct Proxy { AzOptionStyledNode inner; Proxy(AzOptionStyledNode p) : inner(p) {} };

private:
    mutable AzOptionStyledNode inner_;

public:
    explicit OptionStyledNode(AzOptionStyledNode inner) : inner_(inner) {}
    OptionStyledNode(const OptionStyledNode& other) : inner_(other.inner_) { memset(const_cast<AzOptionStyledNode*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionStyledNode& operator=(const OptionStyledNode& other) {
        AzOptionStyledNode_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionStyledNode*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionStyledNode(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionStyledNode& operator=(Proxy p) {
        AzOptionStyledNode_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionParentWithNodeDepth {
private:
    AzOptionParentWithNodeDepth inner_;

public:
    OptionParentWithNodeDepth(AzOptionParentWithNodeDepth inner) : inner_(inner) {}
    OptionParentWithNodeDepth(const OptionParentWithNodeDepth& other) : inner_(other.inner_) {}
    OptionParentWithNodeDepth& operator=(const OptionParentWithNodeDepth& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionVideoMode {
private:
    AzOptionVideoMode inner_;

public:
    OptionVideoMode(AzOptionVideoMode inner) : inner_(inner) {}
    OptionVideoMode(const OptionVideoMode& other) : inner_(other.inner_) {}
    OptionVideoMode& operator=(const OptionVideoMode& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionOsVersion {
private:
    AzOptionOsVersion inner_;

public:
    OptionOsVersion(AzOptionOsVersion inner) : inner_(inner) {}
    OptionOsVersion(const OptionOsVersion& other) : inner_(other.inner_) {}
    OptionOsVersion& operator=(const OptionOsVersion& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionTouchPoint {
private:
    AzOptionTouchPoint inner_;

public:
    OptionTouchPoint(AzOptionTouchPoint inner) : inner_(inner) {}
    OptionTouchPoint(const OptionTouchPoint& other) : inner_(other.inner_) {}
    OptionTouchPoint& operator=(const OptionTouchPoint& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionSensorReading {
private:
    AzOptionSensorReading inner_;

public:
    OptionSensorReading(AzOptionSensorReading inner) : inner_(inner) {}
    OptionSensorReading(const OptionSensorReading& other) : inner_(other.inner_) {}
    OptionSensorReading& operator=(const OptionSensorReading& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionGamepadState {
private:
    AzOptionGamepadState inner_;

public:
    OptionGamepadState(AzOptionGamepadState inner) : inner_(inner) {}
    OptionGamepadState(const OptionGamepadState& other) : inner_(other.inner_) {}
    OptionGamepadState& operator=(const OptionGamepadState& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionPixelValueNoPercent {
private:
    AzOptionPixelValueNoPercent inner_;

public:
    OptionPixelValueNoPercent(AzOptionPixelValueNoPercent inner) : inner_(inner) {}
    OptionPixelValueNoPercent(const OptionPixelValueNoPercent& other) : inner_(other.inner_) {}
    OptionPixelValueNoPercent& operator=(const OptionPixelValueNoPercent& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionSelectionRange {
private:
    AzOptionSelectionRange inner_;

public:
    OptionSelectionRange(AzOptionSelectionRange inner) : inner_(inner) {}
    OptionSelectionRange(const OptionSelectionRange& other) : inner_(other.inner_) {}
    OptionSelectionRange& operator=(const OptionSelectionRange& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionMouseState {
private:
    AzOptionMouseState inner_;

public:
    OptionMouseState(AzOptionMouseState inner) : inner_(inner) {}
    OptionMouseState(const OptionMouseState& other) : inner_(other.inner_) {}
    OptionMouseState& operator=(const OptionMouseState& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionThreadSendMsg {
public:
    struct Proxy { AzOptionThreadSendMsg inner; Proxy(AzOptionThreadSendMsg p) : inner(p) {} };

private:
    mutable AzOptionThreadSendMsg inner_;

public:
    explicit OptionThreadSendMsg(AzOptionThreadSendMsg inner) : inner_(inner) {}
    OptionThreadSendMsg(const OptionThreadSendMsg& other) : inner_(other.inner_) { memset(const_cast<AzOptionThreadSendMsg*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionThreadSendMsg& operator=(const OptionThreadSendMsg& other) {
        AzOptionThreadSendMsg_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionThreadSendMsg*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionThreadSendMsg(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionThreadSendMsg& operator=(Proxy p) {
        AzOptionThreadSendMsg_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionTagIdToNodeIdMapping {
public:
    struct Proxy { AzOptionTagIdToNodeIdMapping inner; Proxy(AzOptionTagIdToNodeIdMapping p) : inner(p) {} };

private:
    mutable AzOptionTagIdToNodeIdMapping inner_;

public:
    explicit OptionTagIdToNodeIdMapping(AzOptionTagIdToNodeIdMapping inner) : inner_(inner) {}
    OptionTagIdToNodeIdMapping(const OptionTagIdToNodeIdMapping& other) : inner_(other.inner_) { memset(const_cast<AzOptionTagIdToNodeIdMapping*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionTagIdToNodeIdMapping& operator=(const OptionTagIdToNodeIdMapping& other) {
        AzOptionTagIdToNodeIdMapping_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionTagIdToNodeIdMapping*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionTagIdToNodeIdMapping(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionTagIdToNodeIdMapping& operator=(Proxy p) {
        AzOptionTagIdToNodeIdMapping_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionNormalizedRadialColorStop {
public:
    struct Proxy { AzOptionNormalizedRadialColorStop inner; Proxy(AzOptionNormalizedRadialColorStop p) : inner(p) {} };

private:
    mutable AzOptionNormalizedRadialColorStop inner_;

public:
    explicit OptionNormalizedRadialColorStop(AzOptionNormalizedRadialColorStop inner) : inner_(inner) {}
    OptionNormalizedRadialColorStop(const OptionNormalizedRadialColorStop& other) : inner_(other.inner_) { memset(const_cast<AzOptionNormalizedRadialColorStop*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionNormalizedRadialColorStop& operator=(const OptionNormalizedRadialColorStop& other) {
        AzOptionNormalizedRadialColorStop_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionNormalizedRadialColorStop*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionNormalizedRadialColorStop(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionNormalizedRadialColorStop& operator=(Proxy p) {
        AzOptionNormalizedRadialColorStop_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionNormalizedLinearColorStop {
public:
    struct Proxy { AzOptionNormalizedLinearColorStop inner; Proxy(AzOptionNormalizedLinearColorStop p) : inner(p) {} };

private:
    mutable AzOptionNormalizedLinearColorStop inner_;

public:
    explicit OptionNormalizedLinearColorStop(AzOptionNormalizedLinearColorStop inner) : inner_(inner) {}
    OptionNormalizedLinearColorStop(const OptionNormalizedLinearColorStop& other) : inner_(other.inner_) { memset(const_cast<AzOptionNormalizedLinearColorStop*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionNormalizedLinearColorStop& operator=(const OptionNormalizedLinearColorStop& other) {
        AzOptionNormalizedLinearColorStop_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionNormalizedLinearColorStop*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionNormalizedLinearColorStop(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionNormalizedLinearColorStop& operator=(Proxy p) {
        AzOptionNormalizedLinearColorStop_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionGridTrackSizing {
public:
    struct Proxy { AzOptionGridTrackSizing inner; Proxy(AzOptionGridTrackSizing p) : inner(p) {} };

private:
    mutable AzOptionGridTrackSizing inner_;

public:
    explicit OptionGridTrackSizing(AzOptionGridTrackSizing inner) : inner_(inner) {}
    OptionGridTrackSizing(const OptionGridTrackSizing& other) : inner_(other.inner_) { memset(const_cast<AzOptionGridTrackSizing*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionGridTrackSizing& operator=(const OptionGridTrackSizing& other) {
        AzOptionGridTrackSizing_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionGridTrackSizing*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionGridTrackSizing(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionGridTrackSizing& operator=(Proxy p) {
        AzOptionGridTrackSizing_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionStringVec {
public:
    struct Proxy { AzOptionStringVec inner; Proxy(AzOptionStringVec p) : inner(p) {} };

private:
    mutable AzOptionStringVec inner_;

public:
    explicit OptionStringVec(AzOptionStringVec inner) : inner_(inner) {}
    OptionStringVec(const OptionStringVec& other) : inner_(other.inner_) { memset(const_cast<AzOptionStringVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionStringVec& operator=(const OptionStringVec& other) {
        AzOptionStringVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionStringVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionStringVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionStringVec& operator=(Proxy p) {
        AzOptionStringVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionJsonVec {
public:
    struct Proxy { AzOptionJsonVec inner; Proxy(AzOptionJsonVec p) : inner(p) {} };

private:
    mutable AzOptionJsonVec inner_;

public:
    explicit OptionJsonVec(AzOptionJsonVec inner) : inner_(inner) {}
    OptionJsonVec(const OptionJsonVec& other) : inner_(other.inner_) { memset(const_cast<AzOptionJsonVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionJsonVec& operator=(const OptionJsonVec& other) {
        AzOptionJsonVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionJsonVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionJsonVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionJsonVec& operator=(Proxy p) {
        AzOptionJsonVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionJsonKeyValueVec {
public:
    struct Proxy { AzOptionJsonKeyValueVec inner; Proxy(AzOptionJsonKeyValueVec p) : inner(p) {} };

private:
    mutable AzOptionJsonKeyValueVec inner_;

public:
    explicit OptionJsonKeyValueVec(AzOptionJsonKeyValueVec inner) : inner_(inner) {}
    OptionJsonKeyValueVec(const OptionJsonKeyValueVec& other) : inner_(other.inner_) { memset(const_cast<AzOptionJsonKeyValueVec*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionJsonKeyValueVec& operator=(const OptionJsonKeyValueVec& other) {
        AzOptionJsonKeyValueVec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionJsonKeyValueVec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionJsonKeyValueVec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionJsonKeyValueVec& operator=(Proxy p) {
        AzOptionJsonKeyValueVec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCalcAstItem {
public:
    struct Proxy { AzOptionCalcAstItem inner; Proxy(AzOptionCalcAstItem p) : inner(p) {} };

private:
    mutable AzOptionCalcAstItem inner_;

public:
    explicit OptionCalcAstItem(AzOptionCalcAstItem inner) : inner_(inner) {}
    OptionCalcAstItem(const OptionCalcAstItem& other) : inner_(other.inner_) { memset(const_cast<AzOptionCalcAstItem*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionCalcAstItem& operator=(const OptionCalcAstItem& other) {
        AzOptionCalcAstItem_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionCalcAstItem*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionCalcAstItem(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionCalcAstItem& operator=(Proxy p) {
        AzOptionCalcAstItem_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionSvgPathElement {
private:
    AzOptionSvgPathElement inner_;

public:
    OptionSvgPathElement(AzOptionSvgPathElement inner) : inner_(inner) {}
    OptionSvgPathElement(const OptionSvgPathElement& other) : inner_(other.inner_) {}
    OptionSvgPathElement& operator=(const OptionSvgPathElement& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionU8Vec {
public:
    struct Proxy { AzOptionU8Vec inner; Proxy(AzOptionU8Vec p) : inner(p) {} };

private:
    mutable AzOptionU8Vec inner_;

public:
    explicit OptionU8Vec(AzOptionU8Vec inner) : inner_(inner) {}
    OptionU8Vec(const OptionU8Vec& other) : inner_(other.inner_) { memset(const_cast<AzOptionU8Vec*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionU8Vec& operator=(const OptionU8Vec& other) {
        AzOptionU8Vec_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionU8Vec*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionU8Vec(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionU8Vec& operator=(Proxy p) {
        AzOptionU8Vec_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class ResultU8VecEncodeImageError {
public:
    struct Proxy { AzResultU8VecEncodeImageError inner; Proxy(AzResultU8VecEncodeImageError p) : inner(p) {} };

private:
    mutable AzResultU8VecEncodeImageError inner_;

public:
    explicit ResultU8VecEncodeImageError(AzResultU8VecEncodeImageError inner) : inner_(inner) {}
    ResultU8VecEncodeImageError(const ResultU8VecEncodeImageError& other) : inner_(other.inner_) { memset(const_cast<AzResultU8VecEncodeImageError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultU8VecEncodeImageError& operator=(const ResultU8VecEncodeImageError& other) {
        AzResultU8VecEncodeImageError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultU8VecEncodeImageError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultU8VecEncodeImageError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultU8VecEncodeImageError& operator=(Proxy p) {
        AzResultU8VecEncodeImageError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class OptionMenu {
public:
    struct Proxy { AzOptionMenu inner; Proxy(AzOptionMenu p) : inner(p) {} };

private:
    mutable AzOptionMenu inner_;

public:
    explicit OptionMenu(AzOptionMenu inner) : inner_(inner) {}
    OptionMenu(const OptionMenu& other) : inner_(other.inner_) { memset(const_cast<AzOptionMenu*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionMenu& operator=(const OptionMenu& other) {
        AzOptionMenu_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionMenu*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionMenu(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionMenu& operator=(Proxy p) {
        AzOptionMenu_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionVirtualKeyCodeCombo {
public:
    struct Proxy { AzOptionVirtualKeyCodeCombo inner; Proxy(AzOptionVirtualKeyCodeCombo p) : inner(p) {} };

private:
    mutable AzOptionVirtualKeyCodeCombo inner_;

public:
    explicit OptionVirtualKeyCodeCombo(AzOptionVirtualKeyCodeCombo inner) : inner_(inner) {}
    OptionVirtualKeyCodeCombo(const OptionVirtualKeyCodeCombo& other) : inner_(other.inner_) { memset(const_cast<AzOptionVirtualKeyCodeCombo*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionVirtualKeyCodeCombo& operator=(const OptionVirtualKeyCodeCombo& other) {
        AzOptionVirtualKeyCodeCombo_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionVirtualKeyCodeCombo*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionVirtualKeyCodeCombo(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionVirtualKeyCodeCombo& operator=(Proxy p) {
        AzOptionVirtualKeyCodeCombo_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionString {
public:
    struct Proxy { AzOptionString inner; Proxy(AzOptionString p) : inner(p) {} };

private:
    mutable AzOptionString inner_;

public:
    explicit OptionString(AzOptionString inner) : inner_(inner) {}
    OptionString(const OptionString& other) : inner_(other.inner_) { memset(const_cast<AzOptionString*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionString& operator=(const OptionString& other) {
        AzOptionString_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionString*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionString(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionString& operator=(Proxy p) {
        AzOptionString_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCallback {
public:
    struct Proxy { AzOptionCallback inner; Proxy(AzOptionCallback p) : inner(p) {} };

private:
    mutable AzOptionCallback inner_;

public:
    explicit OptionCallback(AzOptionCallback inner) : inner_(inner) {}
    OptionCallback(const OptionCallback& other) : inner_(other.inner_) { memset(const_cast<AzOptionCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionCallback& operator=(const OptionCallback& other) {
        AzOptionCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionCallback& operator=(Proxy p) {
        AzOptionCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionTaskBarIcon {
public:
    struct Proxy { AzOptionTaskBarIcon inner; Proxy(AzOptionTaskBarIcon p) : inner(p) {} };

private:
    mutable AzOptionTaskBarIcon inner_;

public:
    explicit OptionTaskBarIcon(AzOptionTaskBarIcon inner) : inner_(inner) {}
    OptionTaskBarIcon(const OptionTaskBarIcon& other) : inner_(other.inner_) { memset(const_cast<AzOptionTaskBarIcon*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionTaskBarIcon& operator=(const OptionTaskBarIcon& other) {
        AzOptionTaskBarIcon_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionTaskBarIcon*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionTaskBarIcon(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionTaskBarIcon& operator=(Proxy p) {
        AzOptionTaskBarIcon_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionInstant {
public:
    struct Proxy { AzOptionInstant inner; Proxy(AzOptionInstant p) : inner(p) {} };

private:
    mutable AzOptionInstant inner_;

public:
    explicit OptionInstant(AzOptionInstant inner) : inner_(inner) {}
    OptionInstant(const OptionInstant& other) : inner_(other.inner_) { memset(const_cast<AzOptionInstant*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionInstant& operator=(const OptionInstant& other) {
        AzOptionInstant_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionInstant*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionInstant(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionInstant& operator=(Proxy p) {
        AzOptionInstant_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionKeyboardState {
public:
    struct Proxy { AzOptionKeyboardState inner; Proxy(AzOptionKeyboardState p) : inner(p) {} };

private:
    mutable AzOptionKeyboardState inner_;

public:
    explicit OptionKeyboardState(AzOptionKeyboardState inner) : inner_(inner) {}
    OptionKeyboardState(const OptionKeyboardState& other) : inner_(other.inner_) { memset(const_cast<AzOptionKeyboardState*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionKeyboardState& operator=(const OptionKeyboardState& other) {
        AzOptionKeyboardState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionKeyboardState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionKeyboardState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionKeyboardState& operator=(Proxy p) {
        AzOptionKeyboardState_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionSelectionState {
public:
    struct Proxy { AzOptionSelectionState inner; Proxy(AzOptionSelectionState p) : inner(p) {} };

private:
    mutable AzOptionSelectionState inner_;

public:
    explicit OptionSelectionState(AzOptionSelectionState inner) : inner_(inner) {}
    OptionSelectionState(const OptionSelectionState& other) : inner_(other.inner_) { memset(const_cast<AzOptionSelectionState*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionSelectionState& operator=(const OptionSelectionState& other) {
        AzOptionSelectionState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionSelectionState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionSelectionState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionSelectionState& operator=(Proxy p) {
        AzOptionSelectionState_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDatasetMergeCallback {
public:
    struct Proxy { AzOptionDatasetMergeCallback inner; Proxy(AzOptionDatasetMergeCallback p) : inner(p) {} };

private:
    mutable AzOptionDatasetMergeCallback inner_;

public:
    explicit OptionDatasetMergeCallback(AzOptionDatasetMergeCallback inner) : inner_(inner) {}
    OptionDatasetMergeCallback(const OptionDatasetMergeCallback& other) : inner_(other.inner_) { memset(const_cast<AzOptionDatasetMergeCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionDatasetMergeCallback& operator=(const OptionDatasetMergeCallback& other) {
        AzOptionDatasetMergeCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionDatasetMergeCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionDatasetMergeCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionDatasetMergeCallback& operator=(Proxy p) {
        AzOptionDatasetMergeCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionStyleTransform {
private:
    AzOptionStyleTransform inner_;

public:
    OptionStyleTransform(AzOptionStyleTransform inner) : inner_(inner) {}
    OptionStyleTransform(const OptionStyleTransform& other) : inner_(other.inner_) {}
    OptionStyleTransform& operator=(const OptionStyleTransform& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionStyleBackgroundPosition {
private:
    AzOptionStyleBackgroundPosition inner_;

public:
    OptionStyleBackgroundPosition(AzOptionStyleBackgroundPosition inner) : inner_(inner) {}
    OptionStyleBackgroundPosition(const OptionStyleBackgroundPosition& other) : inner_(other.inner_) {}
    OptionStyleBackgroundPosition& operator=(const OptionStyleBackgroundPosition& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCss {
public:
    struct Proxy { AzOptionCss inner; Proxy(AzOptionCss p) : inner(p) {} };

private:
    mutable AzOptionCss inner_;

public:
    explicit OptionCss(AzOptionCss inner) : inner_(inner) {}
    OptionCss(const OptionCss& other) : inner_(other.inner_) { memset(const_cast<AzOptionCss*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionCss& operator=(const OptionCss& other) {
        AzOptionCss_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionCss*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionCss(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionCss& operator=(Proxy p) {
        AzOptionCss_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionStyleBackgroundSize {
public:
    struct Proxy { AzOptionStyleBackgroundSize inner; Proxy(AzOptionStyleBackgroundSize p) : inner(p) {} };

private:
    mutable AzOptionStyleBackgroundSize inner_;

public:
    explicit OptionStyleBackgroundSize(AzOptionStyleBackgroundSize inner) : inner_(inner) {}
    OptionStyleBackgroundSize(const OptionStyleBackgroundSize& other) : inner_(other.inner_) { memset(const_cast<AzOptionStyleBackgroundSize*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionStyleBackgroundSize& operator=(const OptionStyleBackgroundSize& other) {
        AzOptionStyleBackgroundSize_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionStyleBackgroundSize*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionStyleBackgroundSize(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionStyleBackgroundSize& operator=(Proxy p) {
        AzOptionStyleBackgroundSize_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionSelection {
private:
    AzOptionSelection inner_;

public:
    OptionSelection(AzOptionSelection inner) : inner_(inner) {}
    OptionSelection(const OptionSelection& other) : inner_(other.inner_) {}
    OptionSelection& operator=(const OptionSelection& other) { 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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionContentGroup {
public:
    struct Proxy { AzOptionContentGroup inner; Proxy(AzOptionContentGroup p) : inner(p) {} };

private:
    mutable AzOptionContentGroup inner_;

public:
    explicit OptionContentGroup(AzOptionContentGroup inner) : inner_(inner) {}
    OptionContentGroup(const OptionContentGroup& other) : inner_(other.inner_) { memset(const_cast<AzOptionContentGroup*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionContentGroup& operator=(const OptionContentGroup& other) {
        AzOptionContentGroup_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionContentGroup*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionContentGroup(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionContentGroup& operator=(Proxy p) {
        AzOptionContentGroup_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionSvgPath {
public:
    struct Proxy { AzOptionSvgPath inner; Proxy(AzOptionSvgPath p) : inner(p) {} };

private:
    mutable AzOptionSvgPath inner_;

public:
    explicit OptionSvgPath(AzOptionSvgPath inner) : inner_(inner) {}
    OptionSvgPath(const OptionSvgPath& other) : inner_(other.inner_) { memset(const_cast<AzOptionSvgPath*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionSvgPath& operator=(const OptionSvgPath& other) {
        AzOptionSvgPath_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionSvgPath*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionSvgPath(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionSvgPath& operator=(Proxy p) {
        AzOptionSvgPath_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionVideoFrame {
public:
    struct Proxy { AzOptionVideoFrame inner; Proxy(AzOptionVideoFrame p) : inner(p) {} };

private:
    mutable AzOptionVideoFrame inner_;

public:
    explicit OptionVideoFrame(AzOptionVideoFrame inner) : inner_(inner) {}
    OptionVideoFrame(const OptionVideoFrame& other) : inner_(other.inner_) { memset(const_cast<AzOptionVideoFrame*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionVideoFrame& operator=(const OptionVideoFrame& other) {
        AzOptionVideoFrame_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionVideoFrame*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionVideoFrame(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionVideoFrame& operator=(Proxy p) {
        AzOptionVideoFrame_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class ResultRefAnyString {
public:
    struct Proxy { AzResultRefAnyString inner; Proxy(AzResultRefAnyString p) : inner(p) {} };

private:
    mutable AzResultRefAnyString inner_;

public:
    explicit ResultRefAnyString(AzResultRefAnyString inner) : inner_(inner) {}
    ResultRefAnyString(const ResultRefAnyString& other) : inner_(other.inner_) { memset(const_cast<AzResultRefAnyString*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultRefAnyString& operator=(const ResultRefAnyString& other) {
        AzResultRefAnyString_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultRefAnyString*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultRefAnyString(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultRefAnyString& operator=(Proxy p) {
        AzResultRefAnyString_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultU8VecString {
public:
    struct Proxy { AzResultU8VecString inner; Proxy(AzResultU8VecString p) : inner(p) {} };

private:
    mutable AzResultU8VecString inner_;

public:
    explicit ResultU8VecString(AzResultU8VecString inner) : inner_(inner) {}
    ResultU8VecString(const ResultU8VecString& other) : inner_(other.inner_) { memset(const_cast<AzResultU8VecString*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultU8VecString& operator=(const ResultU8VecString& other) {
        AzResultU8VecString_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultU8VecString*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultU8VecString(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultU8VecString& operator=(Proxy p) {
        AzResultU8VecString_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultVoidString {
public:
    struct Proxy { AzResultVoidString inner; Proxy(AzResultVoidString p) : inner(p) {} };

private:
    mutable AzResultVoidString inner_;

public:
    explicit ResultVoidString(AzResultVoidString inner) : inner_(inner) {}
    ResultVoidString(const ResultVoidString& other) : inner_(other.inner_) { memset(const_cast<AzResultVoidString*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultVoidString& operator=(const ResultVoidString& other) {
        AzResultVoidString_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultVoidString*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultVoidString(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultVoidString& operator=(Proxy p) {
        AzResultVoidString_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultStringString {
public:
    struct Proxy { AzResultStringString inner; Proxy(AzResultStringString p) : inner(p) {} };

private:
    mutable AzResultStringString inner_;

public:
    explicit ResultStringString(AzResultStringString inner) : inner_(inner) {}
    ResultStringString(const ResultStringString& other) : inner_(other.inner_) { memset(const_cast<AzResultStringString*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultStringString& operator=(const ResultStringString& other) {
        AzResultStringString_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultStringString*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultStringString(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultStringString& operator=(Proxy p) {
        AzResultStringString_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class OptionListViewOnRowClick {
public:
    struct Proxy { AzOptionListViewOnRowClick inner; Proxy(AzOptionListViewOnRowClick p) : inner(p) {} };

private:
    mutable AzOptionListViewOnRowClick inner_;

public:
    explicit OptionListViewOnRowClick(AzOptionListViewOnRowClick inner) : inner_(inner) {}
    OptionListViewOnRowClick(const OptionListViewOnRowClick& other) : inner_(other.inner_) { memset(const_cast<AzOptionListViewOnRowClick*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionListViewOnRowClick& operator=(const OptionListViewOnRowClick& other) {
        AzOptionListViewOnRowClick_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionListViewOnRowClick*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionListViewOnRowClick(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionListViewOnRowClick& operator=(Proxy p) {
        AzOptionListViewOnRowClick_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionListViewOnColumnClick {
public:
    struct Proxy { AzOptionListViewOnColumnClick inner; Proxy(AzOptionListViewOnColumnClick p) : inner(p) {} };

private:
    mutable AzOptionListViewOnColumnClick inner_;

public:
    explicit OptionListViewOnColumnClick(AzOptionListViewOnColumnClick inner) : inner_(inner) {}
    OptionListViewOnColumnClick(const OptionListViewOnColumnClick& other) : inner_(other.inner_) { memset(const_cast<AzOptionListViewOnColumnClick*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionListViewOnColumnClick& operator=(const OptionListViewOnColumnClick& other) {
        AzOptionListViewOnColumnClick_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionListViewOnColumnClick*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionListViewOnColumnClick(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionListViewOnColumnClick& operator=(Proxy p) {
        AzOptionListViewOnColumnClick_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionListViewOnLazyLoadScroll {
public:
    struct Proxy { AzOptionListViewOnLazyLoadScroll inner; Proxy(AzOptionListViewOnLazyLoadScroll p) : inner(p) {} };

private:
    mutable AzOptionListViewOnLazyLoadScroll inner_;

public:
    explicit OptionListViewOnLazyLoadScroll(AzOptionListViewOnLazyLoadScroll inner) : inner_(inner) {}
    OptionListViewOnLazyLoadScroll(const OptionListViewOnLazyLoadScroll& other) : inner_(other.inner_) { memset(const_cast<AzOptionListViewOnLazyLoadScroll*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionListViewOnLazyLoadScroll& operator=(const OptionListViewOnLazyLoadScroll& other) {
        AzOptionListViewOnLazyLoadScroll_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionListViewOnLazyLoadScroll*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionListViewOnLazyLoadScroll(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionListViewOnLazyLoadScroll& operator=(Proxy p) {
        AzOptionListViewOnLazyLoadScroll_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionColorInputOnValueChange {
public:
    struct Proxy { AzOptionColorInputOnValueChange inner; Proxy(AzOptionColorInputOnValueChange p) : inner(p) {} };

private:
    mutable AzOptionColorInputOnValueChange inner_;

public:
    explicit OptionColorInputOnValueChange(AzOptionColorInputOnValueChange inner) : inner_(inner) {}
    OptionColorInputOnValueChange(const OptionColorInputOnValueChange& other) : inner_(other.inner_) { memset(const_cast<AzOptionColorInputOnValueChange*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionColorInputOnValueChange& operator=(const OptionColorInputOnValueChange& other) {
        AzOptionColorInputOnValueChange_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionColorInputOnValueChange*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionColorInputOnValueChange(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionColorInputOnValueChange& operator=(Proxy p) {
        AzOptionColorInputOnValueChange_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionButtonOnClick {
public:
    struct Proxy { AzOptionButtonOnClick inner; Proxy(AzOptionButtonOnClick p) : inner(p) {} };

private:
    mutable AzOptionButtonOnClick inner_;

public:
    explicit OptionButtonOnClick(AzOptionButtonOnClick inner) : inner_(inner) {}
    OptionButtonOnClick(const OptionButtonOnClick& other) : inner_(other.inner_) { memset(const_cast<AzOptionButtonOnClick*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionButtonOnClick& operator=(const OptionButtonOnClick& other) {
        AzOptionButtonOnClick_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionButtonOnClick*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionButtonOnClick(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionButtonOnClick& operator=(Proxy p) {
        AzOptionButtonOnClick_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionTabOnClick {
public:
    struct Proxy { AzOptionTabOnClick inner; Proxy(AzOptionTabOnClick p) : inner(p) {} };

private:
    mutable AzOptionTabOnClick inner_;

public:
    explicit OptionTabOnClick(AzOptionTabOnClick inner) : inner_(inner) {}
    OptionTabOnClick(const OptionTabOnClick& other) : inner_(other.inner_) { memset(const_cast<AzOptionTabOnClick*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionTabOnClick& operator=(const OptionTabOnClick& other) {
        AzOptionTabOnClick_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionTabOnClick*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionTabOnClick(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionTabOnClick& operator=(Proxy p) {
        AzOptionTabOnClick_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionFileInputOnPathChange {
public:
    struct Proxy { AzOptionFileInputOnPathChange inner; Proxy(AzOptionFileInputOnPathChange p) : inner(p) {} };

private:
    mutable AzOptionFileInputOnPathChange inner_;

public:
    explicit OptionFileInputOnPathChange(AzOptionFileInputOnPathChange inner) : inner_(inner) {}
    OptionFileInputOnPathChange(const OptionFileInputOnPathChange& other) : inner_(other.inner_) { memset(const_cast<AzOptionFileInputOnPathChange*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionFileInputOnPathChange& operator=(const OptionFileInputOnPathChange& other) {
        AzOptionFileInputOnPathChange_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionFileInputOnPathChange*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionFileInputOnPathChange(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionFileInputOnPathChange& operator=(Proxy p) {
        AzOptionFileInputOnPathChange_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCheckBoxOnToggle {
public:
    struct Proxy { AzOptionCheckBoxOnToggle inner; Proxy(AzOptionCheckBoxOnToggle p) : inner(p) {} };

private:
    mutable AzOptionCheckBoxOnToggle inner_;

public:
    explicit OptionCheckBoxOnToggle(AzOptionCheckBoxOnToggle inner) : inner_(inner) {}
    OptionCheckBoxOnToggle(const OptionCheckBoxOnToggle& other) : inner_(other.inner_) { memset(const_cast<AzOptionCheckBoxOnToggle*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionCheckBoxOnToggle& operator=(const OptionCheckBoxOnToggle& other) {
        AzOptionCheckBoxOnToggle_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionCheckBoxOnToggle*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionCheckBoxOnToggle(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionCheckBoxOnToggle& operator=(Proxy p) {
        AzOptionCheckBoxOnToggle_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDropDownOnChoiceChange {
public:
    struct Proxy { AzOptionDropDownOnChoiceChange inner; Proxy(AzOptionDropDownOnChoiceChange p) : inner(p) {} };

private:
    mutable AzOptionDropDownOnChoiceChange inner_;

public:
    explicit OptionDropDownOnChoiceChange(AzOptionDropDownOnChoiceChange inner) : inner_(inner) {}
    OptionDropDownOnChoiceChange(const OptionDropDownOnChoiceChange& other) : inner_(other.inner_) { memset(const_cast<AzOptionDropDownOnChoiceChange*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionDropDownOnChoiceChange& operator=(const OptionDropDownOnChoiceChange& other) {
        AzOptionDropDownOnChoiceChange_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionDropDownOnChoiceChange*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionDropDownOnChoiceChange(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionDropDownOnChoiceChange& operator=(Proxy p) {
        AzOptionDropDownOnChoiceChange_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionTextInputOnTextInput {
public:
    struct Proxy { AzOptionTextInputOnTextInput inner; Proxy(AzOptionTextInputOnTextInput p) : inner(p) {} };

private:
    mutable AzOptionTextInputOnTextInput inner_;

public:
    explicit OptionTextInputOnTextInput(AzOptionTextInputOnTextInput inner) : inner_(inner) {}
    OptionTextInputOnTextInput(const OptionTextInputOnTextInput& other) : inner_(other.inner_) { memset(const_cast<AzOptionTextInputOnTextInput*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionTextInputOnTextInput& operator=(const OptionTextInputOnTextInput& other) {
        AzOptionTextInputOnTextInput_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionTextInputOnTextInput*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionTextInputOnTextInput(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionTextInputOnTextInput& operator=(Proxy p) {
        AzOptionTextInputOnTextInput_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionTextInputOnVirtualKeyDown {
public:
    struct Proxy { AzOptionTextInputOnVirtualKeyDown inner; Proxy(AzOptionTextInputOnVirtualKeyDown p) : inner(p) {} };

private:
    mutable AzOptionTextInputOnVirtualKeyDown inner_;

public:
    explicit OptionTextInputOnVirtualKeyDown(AzOptionTextInputOnVirtualKeyDown inner) : inner_(inner) {}
    OptionTextInputOnVirtualKeyDown(const OptionTextInputOnVirtualKeyDown& other) : inner_(other.inner_) { memset(const_cast<AzOptionTextInputOnVirtualKeyDown*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionTextInputOnVirtualKeyDown& operator=(const OptionTextInputOnVirtualKeyDown& other) {
        AzOptionTextInputOnVirtualKeyDown_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionTextInputOnVirtualKeyDown*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionTextInputOnVirtualKeyDown(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionTextInputOnVirtualKeyDown& operator=(Proxy p) {
        AzOptionTextInputOnVirtualKeyDown_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionTextInputOnFocusLost {
public:
    struct Proxy { AzOptionTextInputOnFocusLost inner; Proxy(AzOptionTextInputOnFocusLost p) : inner(p) {} };

private:
    mutable AzOptionTextInputOnFocusLost inner_;

public:
    explicit OptionTextInputOnFocusLost(AzOptionTextInputOnFocusLost inner) : inner_(inner) {}
    OptionTextInputOnFocusLost(const OptionTextInputOnFocusLost& other) : inner_(other.inner_) { memset(const_cast<AzOptionTextInputOnFocusLost*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionTextInputOnFocusLost& operator=(const OptionTextInputOnFocusLost& other) {
        AzOptionTextInputOnFocusLost_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionTextInputOnFocusLost*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionTextInputOnFocusLost(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionTextInputOnFocusLost& operator=(Proxy p) {
        AzOptionTextInputOnFocusLost_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionNumberInputOnFocusLost {
public:
    struct Proxy { AzOptionNumberInputOnFocusLost inner; Proxy(AzOptionNumberInputOnFocusLost p) : inner(p) {} };

private:
    mutable AzOptionNumberInputOnFocusLost inner_;

public:
    explicit OptionNumberInputOnFocusLost(AzOptionNumberInputOnFocusLost inner) : inner_(inner) {}
    OptionNumberInputOnFocusLost(const OptionNumberInputOnFocusLost& other) : inner_(other.inner_) { memset(const_cast<AzOptionNumberInputOnFocusLost*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionNumberInputOnFocusLost& operator=(const OptionNumberInputOnFocusLost& other) {
        AzOptionNumberInputOnFocusLost_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionNumberInputOnFocusLost*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionNumberInputOnFocusLost(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionNumberInputOnFocusLost& operator=(Proxy p) {
        AzOptionNumberInputOnFocusLost_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionNumberInputOnValueChange {
public:
    struct Proxy { AzOptionNumberInputOnValueChange inner; Proxy(AzOptionNumberInputOnValueChange p) : inner(p) {} };

private:
    mutable AzOptionNumberInputOnValueChange inner_;

public:
    explicit OptionNumberInputOnValueChange(AzOptionNumberInputOnValueChange inner) : inner_(inner) {}
    OptionNumberInputOnValueChange(const OptionNumberInputOnValueChange& other) : inner_(other.inner_) { memset(const_cast<AzOptionNumberInputOnValueChange*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionNumberInputOnValueChange& operator=(const OptionNumberInputOnValueChange& other) {
        AzOptionNumberInputOnValueChange_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionNumberInputOnValueChange*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionNumberInputOnValueChange(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionNumberInputOnValueChange& operator=(Proxy p) {
        AzOptionNumberInputOnValueChange_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionRawImage {
public:
    struct Proxy { AzOptionRawImage inner; Proxy(AzOptionRawImage p) : inner(p) {} };

private:
    mutable AzOptionRawImage inner_;

public:
    explicit OptionRawImage(AzOptionRawImage inner) : inner_(inner) {}
    OptionRawImage(const OptionRawImage& other) : inner_(other.inner_) { memset(const_cast<AzOptionRawImage*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionRawImage& operator=(const OptionRawImage& other) {
        AzOptionRawImage_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionRawImage*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionRawImage(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionRawImage& operator=(Proxy p) {
        AzOptionRawImage_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCoreMenuCallback {
public:
    struct Proxy { AzOptionCoreMenuCallback inner; Proxy(AzOptionCoreMenuCallback p) : inner(p) {} };

private:
    mutable AzOptionCoreMenuCallback inner_;

public:
    explicit OptionCoreMenuCallback(AzOptionCoreMenuCallback inner) : inner_(inner) {}
    OptionCoreMenuCallback(const OptionCoreMenuCallback& other) : inner_(other.inner_) { memset(const_cast<AzOptionCoreMenuCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionCoreMenuCallback& operator=(const OptionCoreMenuCallback& other) {
        AzOptionCoreMenuCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionCoreMenuCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionCoreMenuCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionCoreMenuCallback& operator=(Proxy p) {
        AzOptionCoreMenuCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionWaylandTheme {
public:
    struct Proxy { AzOptionWaylandTheme inner; Proxy(AzOptionWaylandTheme p) : inner(p) {} };

private:
    mutable AzOptionWaylandTheme inner_;

public:
    explicit OptionWaylandTheme(AzOptionWaylandTheme inner) : inner_(inner) {}
    OptionWaylandTheme(const OptionWaylandTheme& other) : inner_(other.inner_) { memset(const_cast<AzOptionWaylandTheme*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionWaylandTheme& operator=(const OptionWaylandTheme& other) {
        AzOptionWaylandTheme_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionWaylandTheme*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionWaylandTheme(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionWaylandTheme& operator=(Proxy p) {
        AzOptionWaylandTheme_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionWindowIcon {
public:
    struct Proxy { AzOptionWindowIcon inner; Proxy(AzOptionWindowIcon p) : inner(p) {} };

private:
    mutable AzOptionWindowIcon inner_;

public:
    explicit OptionWindowIcon(AzOptionWindowIcon inner) : inner_(inner) {}
    OptionWindowIcon(const OptionWindowIcon& other) : inner_(other.inner_) { memset(const_cast<AzOptionWindowIcon*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionWindowIcon& operator=(const OptionWindowIcon& other) {
        AzOptionWindowIcon_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionWindowIcon*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionWindowIcon(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionWindowIcon& operator=(Proxy p) {
        AzOptionWindowIcon_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCoreImageCallback {
public:
    struct Proxy { AzOptionCoreImageCallback inner; Proxy(AzOptionCoreImageCallback p) : inner(p) {} };

private:
    mutable AzOptionCoreImageCallback inner_;

public:
    explicit OptionCoreImageCallback(AzOptionCoreImageCallback inner) : inner_(inner) {}
    OptionCoreImageCallback(const OptionCoreImageCallback& other) : inner_(other.inner_) { memset(const_cast<AzOptionCoreImageCallback*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionCoreImageCallback& operator=(const OptionCoreImageCallback& other) {
        AzOptionCoreImageCallback_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionCoreImageCallback*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionCoreImageCallback(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionCoreImageCallback& operator=(Proxy p) {
        AzOptionCoreImageCallback_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionSelectAllResult {
public:
    struct Proxy { AzOptionSelectAllResult inner; Proxy(AzOptionSelectAllResult p) : inner(p) {} };

private:
    mutable AzOptionSelectAllResult inner_;

public:
    explicit OptionSelectAllResult(AzOptionSelectAllResult inner) : inner_(inner) {}
    OptionSelectAllResult(const OptionSelectAllResult& other) : inner_(other.inner_) { memset(const_cast<AzOptionSelectAllResult*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionSelectAllResult& operator=(const OptionSelectAllResult& other) {
        AzOptionSelectAllResult_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionSelectAllResult*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionSelectAllResult(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionSelectAllResult& operator=(Proxy p) {
        AzOptionSelectAllResult_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDeleteResult {
public:
    struct Proxy { AzOptionDeleteResult inner; Proxy(AzOptionDeleteResult p) : inner(p) {} };

private:
    mutable AzOptionDeleteResult inner_;

public:
    explicit OptionDeleteResult(AzOptionDeleteResult inner) : inner_(inner) {}
    OptionDeleteResult(const OptionDeleteResult& other) : inner_(other.inner_) { memset(const_cast<AzOptionDeleteResult*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionDeleteResult& operator=(const OptionDeleteResult& other) {
        AzOptionDeleteResult_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionDeleteResult*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionDeleteResult(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionDeleteResult& operator=(Proxy p) {
        AzOptionDeleteResult_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionClipboardContent {
public:
    struct Proxy { AzOptionClipboardContent inner; Proxy(AzOptionClipboardContent p) : inner(p) {} };

private:
    mutable AzOptionClipboardContent inner_;

public:
    explicit OptionClipboardContent(AzOptionClipboardContent inner) : inner_(inner) {}
    OptionClipboardContent(const OptionClipboardContent& other) : inner_(other.inner_) { memset(const_cast<AzOptionClipboardContent*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionClipboardContent& operator=(const OptionClipboardContent& other) {
        AzOptionClipboardContent_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionClipboardContent*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionClipboardContent(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionClipboardContent& operator=(Proxy p) {
        AzOptionClipboardContent_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionFilePath {
public:
    struct Proxy { AzOptionFilePath inner; Proxy(AzOptionFilePath p) : inner(p) {} };

private:
    mutable AzOptionFilePath inner_;

public:
    explicit OptionFilePath(AzOptionFilePath inner) : inner_(inner) {}
    OptionFilePath(const OptionFilePath& other) : inner_(other.inner_) { memset(const_cast<AzOptionFilePath*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionFilePath& operator=(const OptionFilePath& other) {
        AzOptionFilePath_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionFilePath*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionFilePath(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionFilePath& operator=(Proxy p) {
        AzOptionFilePath_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionPendingTextEdit {
public:
    struct Proxy { AzOptionPendingTextEdit inner; Proxy(AzOptionPendingTextEdit p) : inner(p) {} };

private:
    mutable AzOptionPendingTextEdit inner_;

public:
    explicit OptionPendingTextEdit(AzOptionPendingTextEdit inner) : inner_(inner) {}
    OptionPendingTextEdit(const OptionPendingTextEdit& other) : inner_(other.inner_) { memset(const_cast<AzOptionPendingTextEdit*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionPendingTextEdit& operator=(const OptionPendingTextEdit& other) {
        AzOptionPendingTextEdit_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionPendingTextEdit*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionPendingTextEdit(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionPendingTextEdit& operator=(Proxy p) {
        AzOptionPendingTextEdit_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionMimeTypeHint {
public:
    struct Proxy { AzOptionMimeTypeHint inner; Proxy(AzOptionMimeTypeHint p) : inner(p) {} };

private:
    mutable AzOptionMimeTypeHint inner_;

public:
    explicit OptionMimeTypeHint(AzOptionMimeTypeHint inner) : inner_(inner) {}
    OptionMimeTypeHint(const OptionMimeTypeHint& other) : inner_(other.inner_) { memset(const_cast<AzOptionMimeTypeHint*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionMimeTypeHint& operator=(const OptionMimeTypeHint& other) {
        AzOptionMimeTypeHint_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionMimeTypeHint*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionMimeTypeHint(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionMimeTypeHint& operator=(Proxy p) {
        AzOptionMimeTypeHint_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionAccessibilityAction {
public:
    struct Proxy { AzOptionAccessibilityAction inner; Proxy(AzOptionAccessibilityAction p) : inner(p) {} };

private:
    mutable AzOptionAccessibilityAction inner_;

public:
    explicit OptionAccessibilityAction(AzOptionAccessibilityAction inner) : inner_(inner) {}
    OptionAccessibilityAction(const OptionAccessibilityAction& other) : inner_(other.inner_) { memset(const_cast<AzOptionAccessibilityAction*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionAccessibilityAction& operator=(const OptionAccessibilityAction& other) {
        AzOptionAccessibilityAction_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionAccessibilityAction*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionAccessibilityAction(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionAccessibilityAction& operator=(Proxy p) {
        AzOptionAccessibilityAction_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDirEntry {
public:
    struct Proxy { AzOptionDirEntry inner; Proxy(AzOptionDirEntry p) : inner(p) {} };

private:
    mutable AzOptionDirEntry inner_;

public:
    explicit OptionDirEntry(AzOptionDirEntry inner) : inner_(inner) {}
    OptionDirEntry(const OptionDirEntry& other) : inner_(other.inner_) { memset(const_cast<AzOptionDirEntry*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionDirEntry& operator=(const OptionDirEntry& other) {
        AzOptionDirEntry_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionDirEntry*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionDirEntry(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionDirEntry& operator=(Proxy p) {
        AzOptionDirEntry_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionNamedFont {
public:
    struct Proxy { AzOptionNamedFont inner; Proxy(AzOptionNamedFont p) : inner(p) {} };

private:
    mutable AzOptionNamedFont inner_;

public:
    explicit OptionNamedFont(AzOptionNamedFont inner) : inner_(inner) {}
    OptionNamedFont(const OptionNamedFont& other) : inner_(other.inner_) { memset(const_cast<AzOptionNamedFont*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionNamedFont& operator=(const OptionNamedFont& other) {
        AzOptionNamedFont_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionNamedFont*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionNamedFont(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionNamedFont& operator=(Proxy p) {
        AzOptionNamedFont_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionStyleFilter {
public:
    struct Proxy { AzOptionStyleFilter inner; Proxy(AzOptionStyleFilter p) : inner(p) {} };

private:
    mutable AzOptionStyleFilter inner_;

public:
    explicit OptionStyleFilter(AzOptionStyleFilter inner) : inner_(inner) {}
    OptionStyleFilter(const OptionStyleFilter& other) : inner_(other.inner_) { memset(const_cast<AzOptionStyleFilter*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionStyleFilter& operator=(const OptionStyleFilter& other) {
        AzOptionStyleFilter_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionStyleFilter*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionStyleFilter(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionStyleFilter& operator=(Proxy p) {
        AzOptionStyleFilter_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionHttpHeader {
public:
    struct Proxy { AzOptionHttpHeader inner; Proxy(AzOptionHttpHeader p) : inner(p) {} };

private:
    mutable AzOptionHttpHeader inner_;

public:
    explicit OptionHttpHeader(AzOptionHttpHeader inner) : inner_(inner) {}
    OptionHttpHeader(const OptionHttpHeader& other) : inner_(other.inner_) { memset(const_cast<AzOptionHttpHeader*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionHttpHeader& operator=(const OptionHttpHeader& other) {
        AzOptionHttpHeader_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionHttpHeader*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionHttpHeader(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionHttpHeader& operator=(Proxy p) {
        AzOptionHttpHeader_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCssRuleBlock {
public:
    struct Proxy { AzOptionCssRuleBlock inner; Proxy(AzOptionCssRuleBlock p) : inner(p) {} };

private:
    mutable AzOptionCssRuleBlock inner_;

public:
    explicit OptionCssRuleBlock(AzOptionCssRuleBlock inner) : inner_(inner) {}
    OptionCssRuleBlock(const OptionCssRuleBlock& other) : inner_(other.inner_) { memset(const_cast<AzOptionCssRuleBlock*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionCssRuleBlock& operator=(const OptionCssRuleBlock& other) {
        AzOptionCssRuleBlock_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionCssRuleBlock*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionCssRuleBlock(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionCssRuleBlock& operator=(Proxy p) {
        AzOptionCssRuleBlock_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCoreCallbackData {
public:
    struct Proxy { AzOptionCoreCallbackData inner; Proxy(AzOptionCoreCallbackData p) : inner(p) {} };

private:
    mutable AzOptionCoreCallbackData inner_;

public:
    explicit OptionCoreCallbackData(AzOptionCoreCallbackData inner) : inner_(inner) {}
    OptionCoreCallbackData(const OptionCoreCallbackData& other) : inner_(other.inner_) { memset(const_cast<AzOptionCoreCallbackData*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionCoreCallbackData& operator=(const OptionCoreCallbackData& other) {
        AzOptionCoreCallbackData_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionCoreCallbackData*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionCoreCallbackData(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionCoreCallbackData& operator=(Proxy p) {
        AzOptionCoreCallbackData_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionVertexAttribute {
public:
    struct Proxy { AzOptionVertexAttribute inner; Proxy(AzOptionVertexAttribute p) : inner(p) {} };

private:
    mutable AzOptionVertexAttribute inner_;

public:
    explicit OptionVertexAttribute(AzOptionVertexAttribute inner) : inner_(inner) {}
    OptionVertexAttribute(const OptionVertexAttribute& other) : inner_(other.inner_) { memset(const_cast<AzOptionVertexAttribute*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionVertexAttribute& operator=(const OptionVertexAttribute& other) {
        AzOptionVertexAttribute_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionVertexAttribute*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionVertexAttribute(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionVertexAttribute& operator=(Proxy p) {
        AzOptionVertexAttribute_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDebugMessage {
public:
    struct Proxy { AzOptionDebugMessage inner; Proxy(AzOptionDebugMessage p) : inner(p) {} };

private:
    mutable AzOptionDebugMessage inner_;

public:
    explicit OptionDebugMessage(AzOptionDebugMessage inner) : inner_(inner) {}
    OptionDebugMessage(const OptionDebugMessage& other) : inner_(other.inner_) { memset(const_cast<AzOptionDebugMessage*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionDebugMessage& operator=(const OptionDebugMessage& other) {
        AzOptionDebugMessage_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionDebugMessage*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionDebugMessage(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionDebugMessage& operator=(Proxy p) {
        AzOptionDebugMessage_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionListViewRow {
public:
    struct Proxy { AzOptionListViewRow inner; Proxy(AzOptionListViewRow p) : inner(p) {} };

private:
    mutable AzOptionListViewRow inner_;

public:
    explicit OptionListViewRow(AzOptionListViewRow inner) : inner_(inner) {}
    OptionListViewRow(const OptionListViewRow& other) : inner_(other.inner_) { memset(const_cast<AzOptionListViewRow*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionListViewRow& operator=(const OptionListViewRow& other) {
        AzOptionListViewRow_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionListViewRow*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionListViewRow(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionListViewRow& operator=(Proxy p) {
        AzOptionListViewRow_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionIdOrClass {
public:
    struct Proxy { AzOptionIdOrClass inner; Proxy(AzOptionIdOrClass p) : inner(p) {} };

private:
    mutable AzOptionIdOrClass inner_;

public:
    explicit OptionIdOrClass(AzOptionIdOrClass inner) : inner_(inner) {}
    OptionIdOrClass(const OptionIdOrClass& other) : inner_(other.inner_) { memset(const_cast<AzOptionIdOrClass*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionIdOrClass& operator=(const OptionIdOrClass& other) {
        AzOptionIdOrClass_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionIdOrClass*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionIdOrClass(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionIdOrClass& operator=(Proxy p) {
        AzOptionIdOrClass_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionStyleFontFamily {
public:
    struct Proxy { AzOptionStyleFontFamily inner; Proxy(AzOptionStyleFontFamily p) : inner(p) {} };

private:
    mutable AzOptionStyleFontFamily inner_;

public:
    explicit OptionStyleFontFamily(AzOptionStyleFontFamily inner) : inner_(inner) {}
    OptionStyleFontFamily(const OptionStyleFontFamily& other) : inner_(other.inner_) { memset(const_cast<AzOptionStyleFontFamily*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionStyleFontFamily& operator=(const OptionStyleFontFamily& other) {
        AzOptionStyleFontFamily_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionStyleFontFamily*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionStyleFontFamily(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionStyleFontFamily& operator=(Proxy p) {
        AzOptionStyleFontFamily_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionStringPair {
public:
    struct Proxy { AzOptionStringPair inner; Proxy(AzOptionStringPair p) : inner(p) {} };

private:
    mutable AzOptionStringPair inner_;

public:
    explicit OptionStringPair(AzOptionStringPair inner) : inner_(inner) {}
    OptionStringPair(const OptionStringPair& other) : inner_(other.inner_) { memset(const_cast<AzOptionStringPair*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionStringPair& operator=(const OptionStringPair& other) {
        AzOptionStringPair_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionStringPair*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionStringPair(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionStringPair& operator=(Proxy p) {
        AzOptionStringPair_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionMimeTypeData {
public:
    struct Proxy { AzOptionMimeTypeData inner; Proxy(AzOptionMimeTypeData p) : inner(p) {} };

private:
    mutable AzOptionMimeTypeData inner_;

public:
    explicit OptionMimeTypeData(AzOptionMimeTypeData inner) : inner_(inner) {}
    OptionMimeTypeData(const OptionMimeTypeData& other) : inner_(other.inner_) { memset(const_cast<AzOptionMimeTypeData*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionMimeTypeData& operator=(const OptionMimeTypeData& other) {
        AzOptionMimeTypeData_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionMimeTypeData*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionMimeTypeData(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionMimeTypeData& operator=(Proxy p) {
        AzOptionMimeTypeData_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionThemeCondition {
public:
    struct Proxy { AzOptionThemeCondition inner; Proxy(AzOptionThemeCondition p) : inner(p) {} };

private:
    mutable AzOptionThemeCondition inner_;

public:
    explicit OptionThemeCondition(AzOptionThemeCondition inner) : inner_(inner) {}
    OptionThemeCondition(const OptionThemeCondition& other) : inner_(other.inner_) { memset(const_cast<AzOptionThemeCondition*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionThemeCondition& operator=(const OptionThemeCondition& other) {
        AzOptionThemeCondition_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionThemeCondition*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionThemeCondition(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionThemeCondition& operator=(Proxy p) {
        AzOptionThemeCondition_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionGridAreaDefinition {
public:
    struct Proxy { AzOptionGridAreaDefinition inner; Proxy(AzOptionGridAreaDefinition p) : inner(p) {} };

private:
    mutable AzOptionGridAreaDefinition inner_;

public:
    explicit OptionGridAreaDefinition(AzOptionGridAreaDefinition inner) : inner_(inner) {}
    OptionGridAreaDefinition(const OptionGridAreaDefinition& other) : inner_(other.inner_) { memset(const_cast<AzOptionGridAreaDefinition*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionGridAreaDefinition& operator=(const OptionGridAreaDefinition& other) {
        AzOptionGridAreaDefinition_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionGridAreaDefinition*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionGridAreaDefinition(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionGridAreaDefinition& operator=(Proxy p) {
        AzOptionGridAreaDefinition_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionComponentLibrary {
public:
    struct Proxy { AzOptionComponentLibrary inner; Proxy(AzOptionComponentLibrary p) : inner(p) {} };

private:
    mutable AzOptionComponentLibrary inner_;

public:
    explicit OptionComponentLibrary(AzOptionComponentLibrary inner) : inner_(inner) {}
    OptionComponentLibrary(const OptionComponentLibrary& other) : inner_(other.inner_) { memset(const_cast<AzOptionComponentLibrary*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionComponentLibrary& operator=(const OptionComponentLibrary& other) {
        AzOptionComponentLibrary_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionComponentLibrary*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionComponentLibrary(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionComponentLibrary& operator=(Proxy p) {
        AzOptionComponentLibrary_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionComponentDataModel {
public:
    struct Proxy { AzOptionComponentDataModel inner; Proxy(AzOptionComponentDataModel p) : inner(p) {} };

private:
    mutable AzOptionComponentDataModel inner_;

public:
    explicit OptionComponentDataModel(AzOptionComponentDataModel inner) : inner_(inner) {}
    OptionComponentDataModel(const OptionComponentDataModel& other) : inner_(other.inner_) { memset(const_cast<AzOptionComponentDataModel*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionComponentDataModel& operator=(const OptionComponentDataModel& other) {
        AzOptionComponentDataModel_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionComponentDataModel*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionComponentDataModel(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionComponentDataModel& operator=(Proxy p) {
        AzOptionComponentDataModel_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionComponentEnumModel {
public:
    struct Proxy { AzOptionComponentEnumModel inner; Proxy(AzOptionComponentEnumModel p) : inner(p) {} };

private:
    mutable AzOptionComponentEnumModel inner_;

public:
    explicit OptionComponentEnumModel(AzOptionComponentEnumModel inner) : inner_(inner) {}
    OptionComponentEnumModel(const OptionComponentEnumModel& other) : inner_(other.inner_) { memset(const_cast<AzOptionComponentEnumModel*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionComponentEnumModel& operator=(const OptionComponentEnumModel& other) {
        AzOptionComponentEnumModel_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionComponentEnumModel*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionComponentEnumModel(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionComponentEnumModel& operator=(Proxy p) {
        AzOptionComponentEnumModel_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionComponentEnumVariant {
public:
    struct Proxy { AzOptionComponentEnumVariant inner; Proxy(AzOptionComponentEnumVariant p) : inner(p) {} };

private:
    mutable AzOptionComponentEnumVariant inner_;

public:
    explicit OptionComponentEnumVariant(AzOptionComponentEnumVariant inner) : inner_(inner) {}
    OptionComponentEnumVariant(const OptionComponentEnumVariant& other) : inner_(other.inner_) { memset(const_cast<AzOptionComponentEnumVariant*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionComponentEnumVariant& operator=(const OptionComponentEnumVariant& other) {
        AzOptionComponentEnumVariant_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionComponentEnumVariant*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionComponentEnumVariant(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionComponentEnumVariant& operator=(Proxy p) {
        AzOptionComponentEnumVariant_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionRibbonOnTabClick {
public:
    struct Proxy { AzOptionRibbonOnTabClick inner; Proxy(AzOptionRibbonOnTabClick p) : inner(p) {} };

private:
    mutable AzOptionRibbonOnTabClick inner_;

public:
    explicit OptionRibbonOnTabClick(AzOptionRibbonOnTabClick inner) : inner_(inner) {}
    OptionRibbonOnTabClick(const OptionRibbonOnTabClick& other) : inner_(other.inner_) { memset(const_cast<AzOptionRibbonOnTabClick*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionRibbonOnTabClick& operator=(const OptionRibbonOnTabClick& other) {
        AzOptionRibbonOnTabClick_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionRibbonOnTabClick*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionRibbonOnTabClick(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionRibbonOnTabClick& operator=(Proxy p) {
        AzOptionRibbonOnTabClick_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionTreeViewOnNodeClick {
public:
    struct Proxy { AzOptionTreeViewOnNodeClick inner; Proxy(AzOptionTreeViewOnNodeClick p) : inner(p) {} };

private:
    mutable AzOptionTreeViewOnNodeClick inner_;

public:
    explicit OptionTreeViewOnNodeClick(AzOptionTreeViewOnNodeClick inner) : inner_(inner) {}
    OptionTreeViewOnNodeClick(const OptionTreeViewOnNodeClick& other) : inner_(other.inner_) { memset(const_cast<AzOptionTreeViewOnNodeClick*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionTreeViewOnNodeClick& operator=(const OptionTreeViewOnNodeClick& other) {
        AzOptionTreeViewOnNodeClick_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionTreeViewOnNodeClick*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionTreeViewOnNodeClick(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionTreeViewOnNodeClick& operator=(Proxy p) {
        AzOptionTreeViewOnNodeClick_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionRibbonTab {
public:
    struct Proxy { AzOptionRibbonTab inner; Proxy(AzOptionRibbonTab p) : inner(p) {} };

private:
    mutable AzOptionRibbonTab inner_;

public:
    explicit OptionRibbonTab(AzOptionRibbonTab inner) : inner_(inner) {}
    OptionRibbonTab(const OptionRibbonTab& other) : inner_(other.inner_) { memset(const_cast<AzOptionRibbonTab*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionRibbonTab& operator=(const OptionRibbonTab& other) {
        AzOptionRibbonTab_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionRibbonTab*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionRibbonTab(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionRibbonTab& operator=(Proxy p) {
        AzOptionRibbonTab_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionTreeViewNode {
public:
    struct Proxy { AzOptionTreeViewNode inner; Proxy(AzOptionTreeViewNode p) : inner(p) {} };

private:
    mutable AzOptionTreeViewNode inner_;

public:
    explicit OptionTreeViewNode(AzOptionTreeViewNode inner) : inner_(inner) {}
    OptionTreeViewNode(const OptionTreeViewNode& other) : inner_(other.inner_) { memset(const_cast<AzOptionTreeViewNode*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionTreeViewNode& operator=(const OptionTreeViewNode& other) {
        AzOptionTreeViewNode_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionTreeViewNode*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionTreeViewNode(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionTreeViewNode& operator=(Proxy p) {
        AzOptionTreeViewNode_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionRoute {
public:
    struct Proxy { AzOptionRoute inner; Proxy(AzOptionRoute p) : inner(p) {} };

private:
    mutable AzOptionRoute inner_;

public:
    explicit OptionRoute(AzOptionRoute inner) : inner_(inner) {}
    OptionRoute(const OptionRoute& other) : inner_(other.inner_) { memset(const_cast<AzOptionRoute*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionRoute& operator=(const OptionRoute& other) {
        AzOptionRoute_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionRoute*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionRoute(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionRoute& operator=(Proxy p) {
        AzOptionRoute_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionRouteMatch {
public:
    struct Proxy { AzOptionRouteMatch inner; Proxy(AzOptionRouteMatch p) : inner(p) {} };

private:
    mutable AzOptionRouteMatch inner_;

public:
    explicit OptionRouteMatch(AzOptionRouteMatch inner) : inner_(inner) {}
    OptionRouteMatch(const OptionRouteMatch& other) : inner_(other.inner_) { memset(const_cast<AzOptionRouteMatch*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionRouteMatch& operator=(const OptionRouteMatch& other) {
        AzOptionRouteMatch_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionRouteMatch*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionRouteMatch(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionRouteMatch& operator=(Proxy p) {
        AzOptionRouteMatch_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionFileTypeList {
public:
    struct Proxy { AzOptionFileTypeList inner; Proxy(AzOptionFileTypeList p) : inner(p) {} };

private:
    mutable AzOptionFileTypeList inner_;

public:
    explicit OptionFileTypeList(AzOptionFileTypeList inner) : inner_(inner) {}
    OptionFileTypeList(const OptionFileTypeList& other) : inner_(other.inner_) { memset(const_cast<AzOptionFileTypeList*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionFileTypeList& operator=(const OptionFileTypeList& other) {
        AzOptionFileTypeList_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionFileTypeList*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionFileTypeList(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionFileTypeList& operator=(Proxy p) {
        AzOptionFileTypeList_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionKeyringResult {
public:
    struct Proxy { AzOptionKeyringResult inner; Proxy(AzOptionKeyringResult p) : inner(p) {} };

private:
    mutable AzOptionKeyringResult inner_;

public:
    explicit OptionKeyringResult(AzOptionKeyringResult inner) : inner_(inner) {}
    OptionKeyringResult(const OptionKeyringResult& other) : inner_(other.inner_) { memset(const_cast<AzOptionKeyringResult*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionKeyringResult& operator=(const OptionKeyringResult& other) {
        AzOptionKeyringResult_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionKeyringResult*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionKeyringResult(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionKeyringResult& operator=(Proxy p) {
        AzOptionKeyringResult_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDbValue {
public:
    struct Proxy { AzOptionDbValue inner; Proxy(AzOptionDbValue p) : inner(p) {} };

private:
    mutable AzOptionDbValue inner_;

public:
    explicit OptionDbValue(AzOptionDbValue inner) : inner_(inner) {}
    OptionDbValue(const OptionDbValue& other) : inner_(other.inner_) { memset(const_cast<AzOptionDbValue*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionDbValue& operator=(const OptionDbValue& other) {
        AzOptionDbValue_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionDbValue*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionDbValue(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionDbValue& operator=(Proxy p) {
        AzOptionDbValue_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionOnVideoFrame {
public:
    struct Proxy { AzOptionOnVideoFrame inner; Proxy(AzOptionOnVideoFrame p) : inner(p) {} };

private:
    mutable AzOptionOnVideoFrame inner_;

public:
    explicit OptionOnVideoFrame(AzOptionOnVideoFrame inner) : inner_(inner) {}
    OptionOnVideoFrame(const OptionOnVideoFrame& other) : inner_(other.inner_) { memset(const_cast<AzOptionOnVideoFrame*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionOnVideoFrame& operator=(const OptionOnVideoFrame& other) {
        AzOptionOnVideoFrame_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionOnVideoFrame*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionOnVideoFrame(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionOnVideoFrame& operator=(Proxy p) {
        AzOptionOnVideoFrame_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionMapViewportChanged {
public:
    struct Proxy { AzOptionMapViewportChanged inner; Proxy(AzOptionMapViewportChanged p) : inner(p) {} };

private:
    mutable AzOptionMapViewportChanged inner_;

public:
    explicit OptionMapViewportChanged(AzOptionMapViewportChanged inner) : inner_(inner) {}
    OptionMapViewportChanged(const OptionMapViewportChanged& other) : inner_(other.inner_) { memset(const_cast<AzOptionMapViewportChanged*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionMapViewportChanged& operator=(const OptionMapViewportChanged& other) {
        AzOptionMapViewportChanged_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionMapViewportChanged*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionMapViewportChanged(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionMapViewportChanged& operator=(Proxy p) {
        AzOptionMapViewportChanged_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionMapPinTap {
public:
    struct Proxy { AzOptionMapPinTap inner; Proxy(AzOptionMapPinTap p) : inner(p) {} };

private:
    mutable AzOptionMapPinTap inner_;

public:
    explicit OptionMapPinTap(AzOptionMapPinTap inner) : inner_(inner) {}
    OptionMapPinTap(const OptionMapPinTap& other) : inner_(other.inner_) { memset(const_cast<AzOptionMapPinTap*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionMapPinTap& operator=(const OptionMapPinTap& other) {
        AzOptionMapPinTap_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionMapPinTap*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionMapPinTap(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionMapPinTap& operator=(Proxy p) {
        AzOptionMapPinTap_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionOnAudioFrame {
public:
    struct Proxy { AzOptionOnAudioFrame inner; Proxy(AzOptionOnAudioFrame p) : inner(p) {} };

private:
    mutable AzOptionOnAudioFrame inner_;

public:
    explicit OptionOnAudioFrame(AzOptionOnAudioFrame inner) : inner_(inner) {}
    OptionOnAudioFrame(const OptionOnAudioFrame& other) : inner_(other.inner_) { memset(const_cast<AzOptionOnAudioFrame*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionOnAudioFrame& operator=(const OptionOnAudioFrame& other) {
        AzOptionOnAudioFrame_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionOnAudioFrame*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionOnAudioFrame(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionOnAudioFrame& operator=(Proxy p) {
        AzOptionOnAudioFrame_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionLoadedFont {
public:
    struct Proxy { AzOptionLoadedFont inner; Proxy(AzOptionLoadedFont p) : inner(p) {} };

private:
    mutable AzOptionLoadedFont inner_;

public:
    explicit OptionLoadedFont(AzOptionLoadedFont inner) : inner_(inner) {}
    OptionLoadedFont(const OptionLoadedFont& other) : inner_(other.inner_) { memset(const_cast<AzOptionLoadedFont*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionLoadedFont& operator=(const OptionLoadedFont& other) {
        AzOptionLoadedFont_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionLoadedFont*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionLoadedFont(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionLoadedFont& operator=(Proxy p) {
        AzOptionLoadedFont_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class ResultRawImageDecodeImageError {
public:
    struct Proxy { AzResultRawImageDecodeImageError inner; Proxy(AzResultRawImageDecodeImageError p) : inner(p) {} };

private:
    mutable AzResultRawImageDecodeImageError inner_;

public:
    explicit ResultRawImageDecodeImageError(AzResultRawImageDecodeImageError inner) : inner_(inner) {}
    ResultRawImageDecodeImageError(const ResultRawImageDecodeImageError& other) : inner_(other.inner_) { memset(const_cast<AzResultRawImageDecodeImageError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultRawImageDecodeImageError& operator=(const ResultRawImageDecodeImageError& other) {
        AzResultRawImageDecodeImageError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultRawImageDecodeImageError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultRawImageDecodeImageError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultRawImageDecodeImageError& operator=(Proxy p) {
        AzResultRawImageDecodeImageError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultEmptyStructFileError {
public:
    struct Proxy { AzResultEmptyStructFileError inner; Proxy(AzResultEmptyStructFileError p) : inner(p) {} };

private:
    mutable AzResultEmptyStructFileError inner_;

public:
    explicit ResultEmptyStructFileError(AzResultEmptyStructFileError inner) : inner_(inner) {}
    ResultEmptyStructFileError(const ResultEmptyStructFileError& other) : inner_(other.inner_) { memset(const_cast<AzResultEmptyStructFileError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultEmptyStructFileError& operator=(const ResultEmptyStructFileError& other) {
        AzResultEmptyStructFileError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultEmptyStructFileError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultEmptyStructFileError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultEmptyStructFileError& operator=(Proxy p) {
        AzResultEmptyStructFileError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class Resultu64FileError {
public:
    struct Proxy { AzResultu64FileError inner; Proxy(AzResultu64FileError p) : inner(p) {} };

private:
    mutable AzResultu64FileError inner_;

public:
    explicit Resultu64FileError(AzResultu64FileError inner) : inner_(inner) {}
    Resultu64FileError(const Resultu64FileError& other) : inner_(other.inner_) { memset(const_cast<AzResultu64FileError*>(&other.inner_), 0, sizeof(other.inner_)); }
    Resultu64FileError& operator=(const Resultu64FileError& other) {
        AzResultu64FileError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultu64FileError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    Resultu64FileError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    Resultu64FileError& operator=(Proxy p) {
        AzResultu64FileError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultU8VecFileError {
public:
    struct Proxy { AzResultU8VecFileError inner; Proxy(AzResultU8VecFileError p) : inner(p) {} };

private:
    mutable AzResultU8VecFileError inner_;

public:
    explicit ResultU8VecFileError(AzResultU8VecFileError inner) : inner_(inner) {}
    ResultU8VecFileError(const ResultU8VecFileError& other) : inner_(other.inner_) { memset(const_cast<AzResultU8VecFileError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultU8VecFileError& operator=(const ResultU8VecFileError& other) {
        AzResultU8VecFileError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultU8VecFileError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultU8VecFileError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultU8VecFileError& operator=(Proxy p) {
        AzResultU8VecFileError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultFileMetadataFileError {
public:
    struct Proxy { AzResultFileMetadataFileError inner; Proxy(AzResultFileMetadataFileError p) : inner(p) {} };

private:
    mutable AzResultFileMetadataFileError inner_;

public:
    explicit ResultFileMetadataFileError(AzResultFileMetadataFileError inner) : inner_(inner) {}
    ResultFileMetadataFileError(const ResultFileMetadataFileError& other) : inner_(other.inner_) { memset(const_cast<AzResultFileMetadataFileError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultFileMetadataFileError& operator=(const ResultFileMetadataFileError& other) {
        AzResultFileMetadataFileError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultFileMetadataFileError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultFileMetadataFileError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultFileMetadataFileError& operator=(Proxy p) {
        AzResultFileMetadataFileError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultStringFileError {
public:
    struct Proxy { AzResultStringFileError inner; Proxy(AzResultStringFileError p) : inner(p) {} };

private:
    mutable AzResultStringFileError inner_;

public:
    explicit ResultStringFileError(AzResultStringFileError inner) : inner_(inner) {}
    ResultStringFileError(const ResultStringFileError& other) : inner_(other.inner_) { memset(const_cast<AzResultStringFileError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultStringFileError& operator=(const ResultStringFileError& other) {
        AzResultStringFileError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultStringFileError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultStringFileError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultStringFileError& operator=(Proxy p) {
        AzResultStringFileError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultDirEntryVecFileError {
public:
    struct Proxy { AzResultDirEntryVecFileError inner; Proxy(AzResultDirEntryVecFileError p) : inner(p) {} };

private:
    mutable AzResultDirEntryVecFileError inner_;

public:
    explicit ResultDirEntryVecFileError(AzResultDirEntryVecFileError inner) : inner_(inner) {}
    ResultDirEntryVecFileError(const ResultDirEntryVecFileError& other) : inner_(other.inner_) { memset(const_cast<AzResultDirEntryVecFileError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultDirEntryVecFileError& operator=(const ResultDirEntryVecFileError& other) {
        AzResultDirEntryVecFileError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultDirEntryVecFileError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultDirEntryVecFileError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultDirEntryVecFileError& operator=(Proxy p) {
        AzResultDirEntryVecFileError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultFilePathFileError {
public:
    struct Proxy { AzResultFilePathFileError inner; Proxy(AzResultFilePathFileError p) : inner(p) {} };

private:
    mutable AzResultFilePathFileError inner_;

public:
    explicit ResultFilePathFileError(AzResultFilePathFileError inner) : inner_(inner) {}
    ResultFilePathFileError(const ResultFilePathFileError& other) : inner_(other.inner_) { memset(const_cast<AzResultFilePathFileError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultFilePathFileError& operator=(const ResultFilePathFileError& other) {
        AzResultFilePathFileError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultFilePathFileError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultFilePathFileError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultFilePathFileError& operator=(Proxy p) {
        AzResultFilePathFileError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultUrlUrlParseError {
public:
    struct Proxy { AzResultUrlUrlParseError inner; Proxy(AzResultUrlUrlParseError p) : inner(p) {} };

private:
    mutable AzResultUrlUrlParseError inner_;

public:
    explicit ResultUrlUrlParseError(AzResultUrlUrlParseError inner) : inner_(inner) {}
    ResultUrlUrlParseError(const ResultUrlUrlParseError& other) : inner_(other.inner_) { memset(const_cast<AzResultUrlUrlParseError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultUrlUrlParseError& operator=(const ResultUrlUrlParseError& other) {
        AzResultUrlUrlParseError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultUrlUrlParseError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultUrlUrlParseError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultUrlUrlParseError& operator=(Proxy p) {
        AzResultUrlUrlParseError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class OptionTimer {
public:
    struct Proxy { AzOptionTimer inner; Proxy(AzOptionTimer p) : inner(p) {} };

private:
    mutable AzOptionTimer inner_;

public:
    explicit OptionTimer(AzOptionTimer inner) : inner_(inner) {}
    OptionTimer(const OptionTimer& other) : inner_(other.inner_) { memset(const_cast<AzOptionTimer*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionTimer& operator=(const OptionTimer& other) {
        AzOptionTimer_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionTimer*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionTimer(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionTimer& operator=(Proxy p) {
        AzOptionTimer_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDragState {
public:
    struct Proxy { AzOptionDragState inner; Proxy(AzOptionDragState p) : inner(p) {} };

private:
    mutable AzOptionDragState inner_;

public:
    explicit OptionDragState(AzOptionDragState inner) : inner_(inner) {}
    OptionDragState(const OptionDragState& other) : inner_(other.inner_) { memset(const_cast<AzOptionDragState*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionDragState& operator=(const OptionDragState& other) {
        AzOptionDragState_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionDragState*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionDragState(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionDragState& operator=(Proxy p) {
        AzOptionDragState_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionJson {
public:
    struct Proxy { AzOptionJson inner; Proxy(AzOptionJson p) : inner(p) {} };

private:
    mutable AzOptionJson inner_;

public:
    explicit OptionJson(AzOptionJson inner) : inner_(inner) {}
    OptionJson(const OptionJson& other) : inner_(other.inner_) { memset(const_cast<AzOptionJson*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionJson& operator=(const OptionJson& other) {
        AzOptionJson_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionJson*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionJson(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionJson& operator=(Proxy p) {
        AzOptionJson_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionFmtArg {
public:
    struct Proxy { AzOptionFmtArg inner; Proxy(AzOptionFmtArg p) : inner(p) {} };

private:
    mutable AzOptionFmtArg inner_;

public:
    explicit OptionFmtArg(AzOptionFmtArg inner) : inner_(inner) {}
    OptionFmtArg(const OptionFmtArg& other) : inner_(other.inner_) { memset(const_cast<AzOptionFmtArg*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionFmtArg& operator=(const OptionFmtArg& other) {
        AzOptionFmtArg_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionFmtArg*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionFmtArg(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionFmtArg& operator=(Proxy p) {
        AzOptionFmtArg_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionMonitor {
public:
    struct Proxy { AzOptionMonitor inner; Proxy(AzOptionMonitor p) : inner(p) {} };

private:
    mutable AzOptionMonitor inner_;

public:
    explicit OptionMonitor(AzOptionMonitor inner) : inner_(inner) {}
    OptionMonitor(const OptionMonitor& other) : inner_(other.inner_) { memset(const_cast<AzOptionMonitor*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionMonitor& operator=(const OptionMonitor& other) {
        AzOptionMonitor_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionMonitor*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionMonitor(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionMonitor& operator=(Proxy p) {
        AzOptionMonitor_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionStyleBackgroundContent {
public:
    struct Proxy { AzOptionStyleBackgroundContent inner; Proxy(AzOptionStyleBackgroundContent p) : inner(p) {} };

private:
    mutable AzOptionStyleBackgroundContent inner_;

public:
    explicit OptionStyleBackgroundContent(AzOptionStyleBackgroundContent inner) : inner_(inner) {}
    OptionStyleBackgroundContent(const OptionStyleBackgroundContent& other) : inner_(other.inner_) { memset(const_cast<AzOptionStyleBackgroundContent*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionStyleBackgroundContent& operator=(const OptionStyleBackgroundContent& other) {
        AzOptionStyleBackgroundContent_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionStyleBackgroundContent*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionStyleBackgroundContent(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionStyleBackgroundContent& operator=(Proxy p) {
        AzOptionStyleBackgroundContent_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionStyledTextRun {
public:
    struct Proxy { AzOptionStyledTextRun inner; Proxy(AzOptionStyledTextRun p) : inner(p) {} };

private:
    mutable AzOptionStyledTextRun inner_;

public:
    explicit OptionStyledTextRun(AzOptionStyledTextRun inner) : inner_(inner) {}
    OptionStyledTextRun(const OptionStyledTextRun& other) : inner_(other.inner_) { memset(const_cast<AzOptionStyledTextRun*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionStyledTextRun& operator=(const OptionStyledTextRun& other) {
        AzOptionStyledTextRun_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionStyledTextRun*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionStyledTextRun(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionStyledTextRun& operator=(Proxy p) {
        AzOptionStyledTextRun_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDynamicSelector {
public:
    struct Proxy { AzOptionDynamicSelector inner; Proxy(AzOptionDynamicSelector p) : inner(p) {} };

private:
    mutable AzOptionDynamicSelector inner_;

public:
    explicit OptionDynamicSelector(AzOptionDynamicSelector inner) : inner_(inner) {}
    OptionDynamicSelector(const OptionDynamicSelector& other) : inner_(other.inner_) { memset(const_cast<AzOptionDynamicSelector*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionDynamicSelector& operator=(const OptionDynamicSelector& other) {
        AzOptionDynamicSelector_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionDynamicSelector*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionDynamicSelector(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionDynamicSelector& operator=(Proxy p) {
        AzOptionDynamicSelector_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionAttributeType {
public:
    struct Proxy { AzOptionAttributeType inner; Proxy(AzOptionAttributeType p) : inner(p) {} };

private:
    mutable AzOptionAttributeType inner_;

public:
    explicit OptionAttributeType(AzOptionAttributeType inner) : inner_(inner) {}
    OptionAttributeType(const OptionAttributeType& other) : inner_(other.inner_) { memset(const_cast<AzOptionAttributeType*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionAttributeType& operator=(const OptionAttributeType& other) {
        AzOptionAttributeType_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionAttributeType*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionAttributeType(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionAttributeType& operator=(Proxy p) {
        AzOptionAttributeType_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionComponentDef {
public:
    struct Proxy { AzOptionComponentDef inner; Proxy(AzOptionComponentDef p) : inner(p) {} };

private:
    mutable AzOptionComponentDef inner_;

public:
    explicit OptionComponentDef(AzOptionComponentDef inner) : inner_(inner) {}
    OptionComponentDef(const OptionComponentDef& other) : inner_(other.inner_) { memset(const_cast<AzOptionComponentDef*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionComponentDef& operator=(const OptionComponentDef& other) {
        AzOptionComponentDef_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionComponentDef*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionComponentDef(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionComponentDef& operator=(Proxy p) {
        AzOptionComponentDef_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionComponentDefaultValue {
public:
    struct Proxy { AzOptionComponentDefaultValue inner; Proxy(AzOptionComponentDefaultValue p) : inner(p) {} };

private:
    mutable AzOptionComponentDefaultValue inner_;

public:
    explicit OptionComponentDefaultValue(AzOptionComponentDefaultValue inner) : inner_(inner) {}
    OptionComponentDefaultValue(const OptionComponentDefaultValue& other) : inner_(other.inner_) { memset(const_cast<AzOptionComponentDefaultValue*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionComponentDefaultValue& operator=(const OptionComponentDefaultValue& other) {
        AzOptionComponentDefaultValue_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionComponentDefaultValue*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionComponentDefaultValue(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionComponentDefaultValue& operator=(Proxy p) {
        AzOptionComponentDefaultValue_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionComponentFieldOverride {
public:
    struct Proxy { AzOptionComponentFieldOverride inner; Proxy(AzOptionComponentFieldOverride p) : inner(p) {} };

private:
    mutable AzOptionComponentFieldOverride inner_;

public:
    explicit OptionComponentFieldOverride(AzOptionComponentFieldOverride inner) : inner_(inner) {}
    OptionComponentFieldOverride(const OptionComponentFieldOverride& other) : inner_(other.inner_) { memset(const_cast<AzOptionComponentFieldOverride*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionComponentFieldOverride& operator=(const OptionComponentFieldOverride& other) {
        AzOptionComponentFieldOverride_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionComponentFieldOverride*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionComponentFieldOverride(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionComponentFieldOverride& operator=(Proxy p) {
        AzOptionComponentFieldOverride_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class ResultHttpResponseHttpError {
public:
    struct Proxy { AzResultHttpResponseHttpError inner; Proxy(AzResultHttpResponseHttpError p) : inner(p) {} };

private:
    mutable AzResultHttpResponseHttpError inner_;

public:
    explicit ResultHttpResponseHttpError(AzResultHttpResponseHttpError inner) : inner_(inner) {}
    ResultHttpResponseHttpError(const ResultHttpResponseHttpError& other) : inner_(other.inner_) { memset(const_cast<AzResultHttpResponseHttpError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultHttpResponseHttpError& operator=(const ResultHttpResponseHttpError& other) {
        AzResultHttpResponseHttpError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultHttpResponseHttpError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultHttpResponseHttpError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultHttpResponseHttpError& operator=(Proxy p) {
        AzResultHttpResponseHttpError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultU8VecHttpError {
public:
    struct Proxy { AzResultU8VecHttpError inner; Proxy(AzResultU8VecHttpError p) : inner(p) {} };

private:
    mutable AzResultU8VecHttpError inner_;

public:
    explicit ResultU8VecHttpError(AzResultU8VecHttpError inner) : inner_(inner) {}
    ResultU8VecHttpError(const ResultU8VecHttpError& other) : inner_(other.inner_) { memset(const_cast<AzResultU8VecHttpError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultU8VecHttpError& operator=(const ResultU8VecHttpError& other) {
        AzResultU8VecHttpError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultU8VecHttpError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultU8VecHttpError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultU8VecHttpError& operator=(Proxy p) {
        AzResultU8VecHttpError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultJsonJsonParseError {
public:
    struct Proxy { AzResultJsonJsonParseError inner; Proxy(AzResultJsonJsonParseError p) : inner(p) {} };

private:
    mutable AzResultJsonJsonParseError inner_;

public:
    explicit ResultJsonJsonParseError(AzResultJsonJsonParseError inner) : inner_(inner) {}
    ResultJsonJsonParseError(const ResultJsonJsonParseError& other) : inner_(other.inner_) { memset(const_cast<AzResultJsonJsonParseError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultJsonJsonParseError& operator=(const ResultJsonJsonParseError& other) {
        AzResultJsonJsonParseError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultJsonJsonParseError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultJsonJsonParseError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultJsonJsonParseError& operator=(Proxy p) {
        AzResultJsonJsonParseError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class OptionExternalResource {
public:
    struct Proxy { AzOptionExternalResource inner; Proxy(AzOptionExternalResource p) : inner(p) {} };

private:
    mutable AzOptionExternalResource inner_;

public:
    explicit OptionExternalResource(AzOptionExternalResource inner) : inner_(inner) {}
    OptionExternalResource(const OptionExternalResource& other) : inner_(other.inner_) { memset(const_cast<AzOptionExternalResource*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionExternalResource& operator=(const OptionExternalResource& other) {
        AzOptionExternalResource_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionExternalResource*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionExternalResource(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionExternalResource& operator=(Proxy p) {
        AzOptionExternalResource_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionJsonKeyValue {
public:
    struct Proxy { AzOptionJsonKeyValue inner; Proxy(AzOptionJsonKeyValue p) : inner(p) {} };

private:
    mutable AzOptionJsonKeyValue inner_;

public:
    explicit OptionJsonKeyValue(AzOptionJsonKeyValue inner) : inner_(inner) {}
    OptionJsonKeyValue(const OptionJsonKeyValue& other) : inner_(other.inner_) { memset(const_cast<AzOptionJsonKeyValue*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionJsonKeyValue& operator=(const OptionJsonKeyValue& other) {
        AzOptionJsonKeyValue_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionJsonKeyValue*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionJsonKeyValue(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionJsonKeyValue& operator=(Proxy p) {
        AzOptionJsonKeyValue_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionXmlNodeChild {
public:
    struct Proxy { AzOptionXmlNodeChild inner; Proxy(AzOptionXmlNodeChild p) : inner(p) {} };

private:
    mutable AzOptionXmlNodeChild inner_;

public:
    explicit OptionXmlNodeChild(AzOptionXmlNodeChild inner) : inner_(inner) {}
    OptionXmlNodeChild(const OptionXmlNodeChild& other) : inner_(other.inner_) { memset(const_cast<AzOptionXmlNodeChild*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionXmlNodeChild& operator=(const OptionXmlNodeChild& other) {
        AzOptionXmlNodeChild_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionXmlNodeChild*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionXmlNodeChild(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionXmlNodeChild& operator=(Proxy p) {
        AzOptionXmlNodeChild_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCssPathSelector {
public:
    struct Proxy { AzOptionCssPathSelector inner; Proxy(AzOptionCssPathSelector p) : inner(p) {} };

private:
    mutable AzOptionCssPathSelector inner_;

public:
    explicit OptionCssPathSelector(AzOptionCssPathSelector inner) : inner_(inner) {}
    OptionCssPathSelector(const OptionCssPathSelector& other) : inner_(other.inner_) { memset(const_cast<AzOptionCssPathSelector*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionCssPathSelector& operator=(const OptionCssPathSelector& other) {
        AzOptionCssPathSelector_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionCssPathSelector*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionCssPathSelector(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionCssPathSelector& operator=(Proxy p) {
        AzOptionCssPathSelector_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionNodeData {
public:
    struct Proxy { AzOptionNodeData inner; Proxy(AzOptionNodeData p) : inner(p) {} };

private:
    mutable AzOptionNodeData inner_;

public:
    explicit OptionNodeData(AzOptionNodeData inner) : inner_(inner) {}
    OptionNodeData(const OptionNodeData& other) : inner_(other.inner_) { memset(const_cast<AzOptionNodeData*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionNodeData& operator=(const OptionNodeData& other) {
        AzOptionNodeData_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionNodeData*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionNodeData(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionNodeData& operator=(Proxy p) {
        AzOptionNodeData_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCssMockEnvironment {
public:
    struct Proxy { AzOptionCssMockEnvironment inner; Proxy(AzOptionCssMockEnvironment p) : inner(p) {} };

private:
    mutable AzOptionCssMockEnvironment inner_;

public:
    explicit OptionCssMockEnvironment(AzOptionCssMockEnvironment inner) : inner_(inner) {}
    OptionCssMockEnvironment(const OptionCssMockEnvironment& other) : inner_(other.inner_) { memset(const_cast<AzOptionCssMockEnvironment*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionCssMockEnvironment& operator=(const OptionCssMockEnvironment& other) {
        AzOptionCssMockEnvironment_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionCssMockEnvironment*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionCssMockEnvironment(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionCssMockEnvironment& operator=(Proxy p) {
        AzOptionCssMockEnvironment_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionComponentCallbackArg {
public:
    struct Proxy { AzOptionComponentCallbackArg inner; Proxy(AzOptionComponentCallbackArg p) : inner(p) {} };

private:
    mutable AzOptionComponentCallbackArg inner_;

public:
    explicit OptionComponentCallbackArg(AzOptionComponentCallbackArg inner) : inner_(inner) {}
    OptionComponentCallbackArg(const OptionComponentCallbackArg& other) : inner_(other.inner_) { memset(const_cast<AzOptionComponentCallbackArg*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionComponentCallbackArg& operator=(const OptionComponentCallbackArg& other) {
        AzOptionComponentCallbackArg_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionComponentCallbackArg*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionComponentCallbackArg(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionComponentCallbackArg& operator=(Proxy p) {
        AzOptionComponentCallbackArg_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionDom {
public:
    struct Proxy { AzOptionDom inner; Proxy(AzOptionDom p) : inner(p) {} };

private:
    mutable AzOptionDom inner_;

public:
    explicit OptionDom(AzOptionDom inner) : inner_(inner) {}
    OptionDom(const OptionDom& other) : inner_(other.inner_) { memset(const_cast<AzOptionDom*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionDom& operator=(const OptionDom& other) {
        AzOptionDom_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionDom*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionDom(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionDom& operator=(Proxy p) {
        AzOptionDom_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionMenuItem {
public:
    struct Proxy { AzOptionMenuItem inner; Proxy(AzOptionMenuItem p) : inner(p) {} };

private:
    mutable AzOptionMenuItem inner_;

public:
    explicit OptionMenuItem(AzOptionMenuItem inner) : inner_(inner) {}
    OptionMenuItem(const OptionMenuItem& other) : inner_(other.inner_) { memset(const_cast<AzOptionMenuItem*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionMenuItem& operator=(const OptionMenuItem& other) {
        AzOptionMenuItem_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionMenuItem*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionMenuItem(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionMenuItem& operator=(Proxy p) {
        AzOptionMenuItem_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionComponentDataField {
public:
    struct Proxy { AzOptionComponentDataField inner; Proxy(AzOptionComponentDataField p) : inner(p) {} };

private:
    mutable AzOptionComponentDataField inner_;

public:
    explicit OptionComponentDataField(AzOptionComponentDataField inner) : inner_(inner) {}
    OptionComponentDataField(const OptionComponentDataField& other) : inner_(other.inner_) { memset(const_cast<AzOptionComponentDataField*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionComponentDataField& operator=(const OptionComponentDataField& other) {
        AzOptionComponentDataField_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionComponentDataField*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionComponentDataField(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionComponentDataField& operator=(Proxy p) {
        AzOptionComponentDataField_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCssProperty {
public:
    struct Proxy { AzOptionCssProperty inner; Proxy(AzOptionCssProperty p) : inner(p) {} };

private:
    mutable AzOptionCssProperty inner_;

public:
    explicit OptionCssProperty(AzOptionCssProperty inner) : inner_(inner) {}
    OptionCssProperty(const OptionCssProperty& other) : inner_(other.inner_) { memset(const_cast<AzOptionCssProperty*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionCssProperty& operator=(const OptionCssProperty& other) {
        AzOptionCssProperty_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionCssProperty*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionCssProperty(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionCssProperty& operator=(Proxy p) {
        AzOptionCssProperty_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionUndoableOperation {
public:
    struct Proxy { AzOptionUndoableOperation inner; Proxy(AzOptionUndoableOperation p) : inner(p) {} };

private:
    mutable AzOptionUndoableOperation inner_;

public:
    explicit OptionUndoableOperation(AzOptionUndoableOperation inner) : inner_(inner) {}
    OptionUndoableOperation(const OptionUndoableOperation& other) : inner_(other.inner_) { memset(const_cast<AzOptionUndoableOperation*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionUndoableOperation& operator=(const OptionUndoableOperation& other) {
        AzOptionUndoableOperation_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionUndoableOperation*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionUndoableOperation(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionUndoableOperation& operator=(Proxy p) {
        AzOptionUndoableOperation_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionRibbonSection {
public:
    struct Proxy { AzOptionRibbonSection inner; Proxy(AzOptionRibbonSection p) : inner(p) {} };

private:
    mutable AzOptionRibbonSection inner_;

public:
    explicit OptionRibbonSection(AzOptionRibbonSection inner) : inner_(inner) {}
    OptionRibbonSection(const OptionRibbonSection& other) : inner_(other.inner_) { memset(const_cast<AzOptionRibbonSection*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionRibbonSection& operator=(const OptionRibbonSection& other) {
        AzOptionRibbonSection_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionRibbonSection*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionRibbonSection(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionRibbonSection& operator=(Proxy p) {
        AzOptionRibbonSection_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class OptionCssPropertyWithConditions {
public:
    struct Proxy { AzOptionCssPropertyWithConditions inner; Proxy(AzOptionCssPropertyWithConditions p) : inner(p) {} };

private:
    mutable AzOptionCssPropertyWithConditions inner_;

public:
    explicit OptionCssPropertyWithConditions(AzOptionCssPropertyWithConditions inner) : inner_(inner) {}
    OptionCssPropertyWithConditions(const OptionCssPropertyWithConditions& other) : inner_(other.inner_) { memset(const_cast<AzOptionCssPropertyWithConditions*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionCssPropertyWithConditions& operator=(const OptionCssPropertyWithConditions& other) {
        AzOptionCssPropertyWithConditions_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionCssPropertyWithConditions*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionCssPropertyWithConditions(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionCssPropertyWithConditions& operator=(Proxy p) {
        AzOptionCssPropertyWithConditions_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class ResultSvgSvgParseError {
public:
    struct Proxy { AzResultSvgSvgParseError inner; Proxy(AzResultSvgSvgParseError p) : inner(p) {} };

private:
    mutable AzResultSvgSvgParseError inner_;

public:
    explicit ResultSvgSvgParseError(AzResultSvgSvgParseError inner) : inner_(inner) {}
    ResultSvgSvgParseError(const ResultSvgSvgParseError& other) : inner_(other.inner_) { memset(const_cast<AzResultSvgSvgParseError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultSvgSvgParseError& operator=(const ResultSvgSvgParseError& other) {
        AzResultSvgSvgParseError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultSvgSvgParseError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultSvgSvgParseError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultSvgSvgParseError& operator=(Proxy p) {
        AzResultSvgSvgParseError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultParsedSvgSvgParseError {
public:
    struct Proxy { AzResultParsedSvgSvgParseError inner; Proxy(AzResultParsedSvgSvgParseError p) : inner(p) {} };

private:
    mutable AzResultParsedSvgSvgParseError inner_;

public:
    explicit ResultParsedSvgSvgParseError(AzResultParsedSvgSvgParseError inner) : inner_(inner) {}
    ResultParsedSvgSvgParseError(const ResultParsedSvgSvgParseError& other) : inner_(other.inner_) { memset(const_cast<AzResultParsedSvgSvgParseError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultParsedSvgSvgParseError& operator=(const ResultParsedSvgSvgParseError& other) {
        AzResultParsedSvgSvgParseError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultParsedSvgSvgParseError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultParsedSvgSvgParseError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultParsedSvgSvgParseError& operator=(Proxy p) {
        AzResultParsedSvgSvgParseError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class OptionCssDeclaration {
public:
    struct Proxy { AzOptionCssDeclaration inner; Proxy(AzOptionCssDeclaration p) : inner(p) {} };

private:
    mutable AzOptionCssDeclaration inner_;

public:
    explicit OptionCssDeclaration(AzOptionCssDeclaration inner) : inner_(inner) {}
    OptionCssDeclaration(const OptionCssDeclaration& other) : inner_(other.inner_) { memset(const_cast<AzOptionCssDeclaration*>(&other.inner_), 0, sizeof(other.inner_)); }
    OptionCssDeclaration& operator=(const OptionCssDeclaration& other) {
        AzOptionCssDeclaration_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzOptionCssDeclaration*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    OptionCssDeclaration(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    OptionCssDeclaration& operator=(Proxy p) {
        AzOptionCssDeclaration_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
    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; }
};

class ResultStyledDomRenderDomError {
public:
    struct Proxy { AzResultStyledDomRenderDomError inner; Proxy(AzResultStyledDomRenderDomError p) : inner(p) {} };

private:
    mutable AzResultStyledDomRenderDomError inner_;

public:
    explicit ResultStyledDomRenderDomError(AzResultStyledDomRenderDomError inner) : inner_(inner) {}
    ResultStyledDomRenderDomError(const ResultStyledDomRenderDomError& other) : inner_(other.inner_) { memset(const_cast<AzResultStyledDomRenderDomError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultStyledDomRenderDomError& operator=(const ResultStyledDomRenderDomError& other) {
        AzResultStyledDomRenderDomError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultStyledDomRenderDomError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultStyledDomRenderDomError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultStyledDomRenderDomError& operator=(Proxy p) {
        AzResultStyledDomRenderDomError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

class ResultStringCompileError {
public:
    struct Proxy { AzResultStringCompileError inner; Proxy(AzResultStringCompileError p) : inner(p) {} };

private:
    mutable AzResultStringCompileError inner_;

public:
    explicit ResultStringCompileError(AzResultStringCompileError inner) : inner_(inner) {}
    ResultStringCompileError(const ResultStringCompileError& other) : inner_(other.inner_) { memset(const_cast<AzResultStringCompileError*>(&other.inner_), 0, sizeof(other.inner_)); }
    ResultStringCompileError& operator=(const ResultStringCompileError& other) {
        AzResultStringCompileError_delete(&inner_);
        inner_ = other.inner_;
        memset(const_cast<AzResultStringCompileError*>(&other.inner_), 0, sizeof(other.inner_));
        return *this;
    }
    ResultStringCompileError(Proxy p) : inner_(p.inner) {}
    operator Proxy() {
        Proxy p(inner_);
        memset(&inner_, 0, sizeof(inner_));
        return p;
    }
    ResultStringCompileError& operator=(Proxy p) {
        AzResultStringCompileError_delete(&inner_);
        inner_ = p.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_; memset(&inner_, 0, sizeof(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; }
};

typedef AzStyleCursor StyleCursor;

typedef AzWindowEventFilter WindowEventFilter;

typedef AzWindowTheme WindowTheme;

typedef AzMouseCursorType MouseCursorType;

typedef AzWindowFrame WindowFrame;

typedef AzUserAttentionType UserAttentionType;

typedef AzHwAcceleration HwAcceleration;

typedef AzVsync Vsync;

typedef AzXWindowType XWindowType;

typedef AzWindowType WindowType;

typedef AzCursorAffinity CursorAffinity;

typedef AzCursorMovement CursorMovement;

typedef AzTheme Theme;

typedef AzFullScreenMode FullScreenMode;

typedef AzMsgBoxIcon MsgBoxIcon;

typedef AzUpdate Update;

typedef AzEdgeType EdgeType;

typedef AzAccessibilityRole AccessibilityRole;

typedef AzAccessibilityState AccessibilityState;

// TabIndex is a tagged union - use C API
typedef AzTabIndex TabIndex;

typedef AzNodeTypeTag NodeTypeTag;

typedef AzVertexAttributeType VertexAttributeType;

typedef AzVirtualKeyCode VirtualKeyCode;

typedef AzSelectionDirection SelectionDirection;

typedef AzDragType DragType;

typedef AzFocusBehavior FocusBehavior;

typedef AzDropEffect DropEffect;

typedef AzDragEffect DragEffect;

typedef AzScrollIntoViewBehavior ScrollIntoViewBehavior;

typedef AzAttributeMatchOp AttributeMatchOp;

typedef AzContextMenuMouseButton ContextMenuMouseButton;

typedef AzMenuPopupPosition MenuPopupPosition;

typedef AzMenuItemState MenuItemState;

typedef AzSizeMetric SizeMetric;

typedef AzBoxShadowClipMode BoxShadowClipMode;

typedef AzStyleMixBlendMode StyleMixBlendMode;

typedef AzLayoutAlignContent LayoutAlignContent;

typedef AzLayoutAlignItems LayoutAlignItems;

typedef AzLayoutBoxSizing LayoutBoxSizing;

typedef AzLayoutFlexDirection LayoutFlexDirection;

typedef AzLayoutAxis LayoutAxis;

typedef AzLayoutDisplay LayoutDisplay;

typedef AzLayoutFloat LayoutFloat;

typedef AzLayoutJustifyContent LayoutJustifyContent;

typedef AzLayoutPosition LayoutPosition;

typedef AzLayoutFlexWrap LayoutFlexWrap;

typedef AzLayoutOverflow LayoutOverflow;

typedef AzAngleMetric AngleMetric;

typedef AzDirectionCorner DirectionCorner;

typedef AzShape Shape;

typedef AzRadialGradientSize RadialGradientSize;

typedef AzStyleBackgroundRepeat StyleBackgroundRepeat;

typedef AzBorderStyle BorderStyle;

typedef AzStyleBackfaceVisibility StyleBackfaceVisibility;

typedef AzStyleTextAlign StyleTextAlign;

// LayoutZIndex is a tagged union - use C API
typedef AzLayoutZIndex LayoutZIndex;

typedef AzLayoutJustifyItems LayoutJustifyItems;

typedef AzColumnSpan ColumnSpan;

typedef AzLayoutClear LayoutClear;

typedef AzStyleWhiteSpace StyleWhiteSpace;

typedef AzBreakInside BreakInside;

typedef AzLayoutAlignSelf LayoutAlignSelf;

// ColumnCount is a tagged union - use C API
typedef AzColumnCount ColumnCount;

typedef AzLayoutWritingMode LayoutWritingMode;

typedef AzStyleUserSelect StyleUserSelect;

typedef AzLayoutJustifySelf LayoutJustifySelf;

typedef AzStyleHyphens StyleHyphens;

typedef AzStyleDirection StyleDirection;

typedef AzLayoutTextJustify LayoutTextJustify;

typedef AzBoxDecorationBreak BoxDecorationBreak;

typedef AzStyleVisibility StyleVisibility;

typedef AzLayoutGridAutoFlow LayoutGridAutoFlow;

typedef AzStyleTextDecoration StyleTextDecoration;

typedef AzColumnFill ColumnFill;

typedef AzPageBreak PageBreak;

typedef AzLayoutScrollbarWidth LayoutScrollbarWidth;

typedef AzStyleFontWeight StyleFontWeight;

typedef AzStyleListStyleType StyleListStyleType;

typedef AzStyleListStylePosition StyleListStylePosition;

typedef AzStyleBorderCollapse StyleBorderCollapse;

typedef AzStyleCaptionSide StyleCaptionSide;

typedef AzLayoutTableLayout LayoutTableLayout;

typedef AzStyleEmptyCells StyleEmptyCells;

typedef AzStyleFontStyle StyleFontStyle;

// StyleTextCombineUpright is a tagged union - use C API
typedef AzStyleTextCombineUpright StyleTextCombineUpright;

typedef AzHoverEventFilter HoverEventFilter;

typedef AzShapeRendering ShapeRendering;

typedef AzApplicationEventFilter ApplicationEventFilter;

typedef AzTextRendering TextRendering;

typedef AzFocusEventFilter FocusEventFilter;

typedef AzFontDatabase FontDatabase;

typedef AzWindowBackgroundMaterial WindowBackgroundMaterial;

typedef AzWindowDecorations WindowDecorations;

typedef AzSrgb Srgb;

typedef AzCssPropertyType CssPropertyType;

typedef AzExtendMode ExtendMode;

typedef AzLinuxDesktopEnv LinuxDesktopEnv;

typedef AzScrollLogicalPosition ScrollLogicalPosition;

typedef AzSystemColorRef SystemColorRef;

typedef AzSystemFontType SystemFontType;

typedef AzScrollbarTrackClick ScrollbarTrackClick;

typedef AzSubpixelType SubpixelType;

typedef AzScrollbarVisibility ScrollbarVisibility;

typedef AzToolbarStyle ToolbarStyle;

typedef AzCombinedCssPropertyType CombinedCssPropertyType;

typedef AzScrollbarVisibilityMode ScrollbarVisibilityMode;

typedef AzStyleLineBreak StyleLineBreak;

typedef AzStyleTextAlignLast StyleTextAlignLast;

typedef AzStyleOverflowWrap StyleOverflowWrap;

typedef AzStyleWordBreak StyleWordBreak;

typedef AzStyleTextOrientation StyleTextOrientation;

typedef AzStyleObjectFit StyleObjectFit;

typedef AzStyleInitialLetterWrap StyleInitialLetterWrap;

typedef AzVisualBox VisualBox;

typedef AzStyleInitialLetterAlign StyleInitialLetterAlign;

typedef AzStyleTextBoxEdge StyleTextBoxEdge;

typedef AzStyleAlignmentBaseline StyleAlignmentBaseline;

typedef AzStyleDominantBaseline StyleDominantBaseline;

typedef AzStyleTextBoxTrim StyleTextBoxTrim;

typedef AzStyleScrollbarGutter StyleScrollbarGutter;

typedef AzStyleUnicodeBidi StyleUnicodeBidi;

typedef AzMediaType MediaType;

typedef AzOrientationType OrientationType;

typedef AzSystemMetricRef SystemMetricRef;

typedef AzPseudoStateType PseudoStateType;

typedef AzOsCondition OsCondition;

typedef AzOsFamily OsFamily;

typedef AzBoolCondition BoolCondition;

typedef AzRelayoutReason RelayoutReason;

typedef AzGestureDirection GestureDirection;

typedef AzButtonType ButtonType;

typedef AzTextInputValid TextInputValid;

typedef AzTitlebarButtonSide TitlebarButtonSide;

typedef AzGamepadButton GamepadButton;

typedef AzGlType GlType;

typedef AzIndexBufferFormat IndexBufferFormat;

typedef AzRawImageFormat RawImageFormat;

typedef AzImageRendering ImageRendering;

// SvgFitTo is a tagged union - use C API
typedef AzSvgFitTo SvgFitTo;

typedef AzSvgLineJoin SvgLineJoin;

typedef AzSvgFillRule SvgFillRule;

typedef AzSvgLineCap SvgLineCap;

typedef AzEncodeImageError EncodeImageError;

typedef AzDecodeImageError DecodeImageError;

typedef AzFileErrorKind FileErrorKind;

typedef AzParseFloatError ParseFloatError;

typedef AzParseIntError ParseIntError;

typedef AzBiometricResult BiometricResult;

typedef AzAppTerminationBehavior AppTerminationBehavior;

typedef AzAppLogLevel AppLogLevel;

typedef AzRendererType RendererType;

typedef AzTerminateTimer TerminateTimer;

typedef AzJsonType JsonType;

typedef AzFileType FileType;

typedef AzExternalResourceKind ExternalResourceKind;

typedef AzYesNo YesNo;

typedef AzOkCancel OkCancel;

typedef AzBiometricKind BiometricKind;

typedef AzSensorKind SensorKind;

typedef AzGamepadAxis GamepadAxis;

typedef AzCameraFacing CameraFacing;

// ScreenCaptureSource is a tagged union - use C API
typedef AzScreenCaptureSource ScreenCaptureSource;

typedef AzPluralCategory PluralCategory;

typedef AzFormatLength FormatLength;

typedef AzComponentSource ComponentSource;

typedef AzCompileTarget CompileTarget;

typedef AzComponentEventFilter ComponentEventFilter;

typedef AzCssColorComponent CssColorComponent;

// RawWindowHandle is a tagged union - use C API
typedef AzRawWindowHandle RawWindowHandle;

// TextInputSelection is a tagged union - use C API
typedef AzTextInputSelection TextInputSelection;

// VirtualViewCallbackReason is a tagged union - use C API
typedef AzVirtualViewCallbackReason VirtualViewCallbackReason;

// MenuItemIcon is a tagged union - use C API
typedef AzMenuItemIcon MenuItemIcon;

// CssNthChildSelector is a tagged union - use C API
typedef AzCssNthChildSelector CssNthChildSelector;

// EventFilter is a tagged union - use C API
typedef AzEventFilter EventFilter;

// WindowPosition is a tagged union - use C API
typedef AzWindowPosition WindowPosition;

// CursorPosition is a tagged union - use C API
typedef AzCursorPosition CursorPosition;

// ColorOrSystem is a tagged union - use C API
typedef AzColorOrSystem ColorOrSystem;

// StyleAspectRatio is a tagged union - use C API
typedef AzStyleAspectRatio StyleAspectRatio;

// Duration is a tagged union - use C API
typedef AzDuration Duration;

// StyleFilterVecDestructor is a tagged union - use C API
typedef AzStyleFilterVecDestructor StyleFilterVecDestructor;

// StyleTransformVecDestructor is a tagged union - use C API
typedef AzStyleTransformVecDestructor StyleTransformVecDestructor;

// GLuintVecDestructor is a tagged union - use C API
typedef AzGLuintVecDestructor GLuintVecDestructor;

// XmlNodeChildVecDestructor is a tagged union - use C API
typedef AzXmlNodeChildVecDestructor XmlNodeChildVecDestructor;

// StyleBackgroundContentVecDestructor is a tagged union - use C API
typedef AzStyleBackgroundContentVecDestructor StyleBackgroundContentVecDestructor;

// CascadeInfoVecDestructor is a tagged union - use C API
typedef AzCascadeInfoVecDestructor CascadeInfoVecDestructor;

// AccessibilityStateVecDestructor is a tagged union - use C API
typedef AzAccessibilityStateVecDestructor AccessibilityStateVecDestructor;

// DomVecDestructor is a tagged union - use C API
typedef AzDomVecDestructor DomVecDestructor;

// StringVecDestructor is a tagged union - use C API
typedef AzStringVecDestructor StringVecDestructor;

// NodeDataVecDestructor is a tagged union - use C API
typedef AzNodeDataVecDestructor NodeDataVecDestructor;

// MenuItemVecDestructor is a tagged union - use C API
typedef AzMenuItemVecDestructor MenuItemVecDestructor;

// ListViewRowVecDestructor is a tagged union - use C API
typedef AzListViewRowVecDestructor ListViewRowVecDestructor;

// SvgVertexVecDestructor is a tagged union - use C API
typedef AzSvgVertexVecDestructor SvgVertexVecDestructor;

// CssVecDestructor is a tagged union - use C API
typedef AzCssVecDestructor CssVecDestructor;

// U32VecDestructor is a tagged union - use C API
typedef AzU32VecDestructor U32VecDestructor;

// CssRuleBlockVecDestructor is a tagged union - use C API
typedef AzCssRuleBlockVecDestructor CssRuleBlockVecDestructor;

// NormalizedLinearColorStopVecDestructor is a tagged union - use C API
typedef AzNormalizedLinearColorStopVecDestructor NormalizedLinearColorStopVecDestructor;

// StyleFontFamilyVecDestructor is a tagged union - use C API
typedef AzStyleFontFamilyVecDestructor StyleFontFamilyVecDestructor;

// CssPathSelectorVecDestructor is a tagged union - use C API
typedef AzCssPathSelectorVecDestructor CssPathSelectorVecDestructor;

// NodeHierarchyItemVecDestructor is a tagged union - use C API
typedef AzNodeHierarchyItemVecDestructor NodeHierarchyItemVecDestructor;

// VirtualKeyCodeVecDestructor is a tagged union - use C API
typedef AzVirtualKeyCodeVecDestructor VirtualKeyCodeVecDestructor;

// F32VecDestructor is a tagged union - use C API
typedef AzF32VecDestructor F32VecDestructor;

// StyleBackgroundRepeatVecDestructor is a tagged union - use C API
typedef AzStyleBackgroundRepeatVecDestructor StyleBackgroundRepeatVecDestructor;

// AccessibilityActionVecDestructor is a tagged union - use C API
typedef AzAccessibilityActionVecDestructor AccessibilityActionVecDestructor;

// U16VecDestructor is a tagged union - use C API
typedef AzU16VecDestructor U16VecDestructor;

// TagIdToNodeIdMappingVecDestructor is a tagged union - use C API
typedef AzTagIdToNodeIdMappingVecDestructor TagIdToNodeIdMappingVecDestructor;

// ParentWithNodeDepthVecDestructor is a tagged union - use C API
typedef AzParentWithNodeDepthVecDestructor ParentWithNodeDepthVecDestructor;

// GLintVecDestructor is a tagged union - use C API
typedef AzGLintVecDestructor GLintVecDestructor;

// CssPropertyWithConditionsVecDestructor is a tagged union - use C API
typedef AzCssPropertyWithConditionsVecDestructor CssPropertyWithConditionsVecDestructor;

// DynamicSelectorVecDestructor is a tagged union - use C API
typedef AzDynamicSelectorVecDestructor DynamicSelectorVecDestructor;

// NormalizedRadialColorStopVecDestructor is a tagged union - use C API
typedef AzNormalizedRadialColorStopVecDestructor NormalizedRadialColorStopVecDestructor;

// StyleBackgroundPositionVecDestructor is a tagged union - use C API
typedef AzStyleBackgroundPositionVecDestructor StyleBackgroundPositionVecDestructor;

// AttributeTypeVecDestructor is a tagged union - use C API
typedef AzAttributeTypeVecDestructor AttributeTypeVecDestructor;

// CssDeclarationVecDestructor is a tagged union - use C API
typedef AzCssDeclarationVecDestructor CssDeclarationVecDestructor;

// IdOrClassVecDestructor is a tagged union - use C API
typedef AzIdOrClassVecDestructor IdOrClassVecDestructor;

// StyleBackgroundSizeVecDestructor is a tagged union - use C API
typedef AzStyleBackgroundSizeVecDestructor StyleBackgroundSizeVecDestructor;

// StringPairVecDestructor is a tagged union - use C API
typedef AzStringPairVecDestructor StringPairVecDestructor;

// MimeTypeDataVecDestructor is a tagged union - use C API
typedef AzMimeTypeDataVecDestructor MimeTypeDataVecDestructor;

// CoreCallbackDataVecDestructor is a tagged union - use C API
typedef AzCoreCallbackDataVecDestructor CoreCallbackDataVecDestructor;

// U8VecDestructor is a tagged union - use C API
typedef AzU8VecDestructor U8VecDestructor;

// GridTrackSizingVecDestructor is a tagged union - use C API
typedef AzGridTrackSizingVecDestructor GridTrackSizingVecDestructor;

// VertexAttributeVecDestructor is a tagged union - use C API
typedef AzVertexAttributeVecDestructor VertexAttributeVecDestructor;

// DebugMessageVecDestructor is a tagged union - use C API
typedef AzDebugMessageVecDestructor DebugMessageVecDestructor;

// ShapePointVecDestructor is a tagged union - use C API
typedef AzShapePointVecDestructor ShapePointVecDestructor;

// XWindowTypeVecDestructor is a tagged union - use C API
typedef AzXWindowTypeVecDestructor XWindowTypeVecDestructor;

// MonitorVecDestructor is a tagged union - use C API
typedef AzMonitorVecDestructor MonitorVecDestructor;

// VideoModeVecDestructor is a tagged union - use C API
typedef AzVideoModeVecDestructor VideoModeVecDestructor;

// ScanCodeVecDestructor is a tagged union - use C API
typedef AzScanCodeVecDestructor ScanCodeVecDestructor;

// StyledNodeVecDestructor is a tagged union - use C API
typedef AzStyledNodeVecDestructor StyledNodeVecDestructor;

// ContentGroupVecDestructor is a tagged union - use C API
typedef AzContentGroupVecDestructor ContentGroupVecDestructor;

// DomIdVecDestructor is a tagged union - use C API
typedef AzDomIdVecDestructor DomIdVecDestructor;

// TimerIdVecDestructor is a tagged union - use C API
typedef AzTimerIdVecDestructor TimerIdVecDestructor;

// ThreadIdVecDestructor is a tagged union - use C API
typedef AzThreadIdVecDestructor ThreadIdVecDestructor;

// SelectionRangeVecDestructor is a tagged union - use C API
typedef AzSelectionRangeVecDestructor SelectionRangeVecDestructor;

// StyledTextRunVecDestructor is a tagged union - use C API
typedef AzStyledTextRunVecDestructor StyledTextRunVecDestructor;

// SelectionVecDestructor is a tagged union - use C API
typedef AzSelectionVecDestructor SelectionVecDestructor;

// FmtArgVecDestructor is a tagged union - use C API
typedef AzFmtArgVecDestructor FmtArgVecDestructor;

// HttpHeaderVecDestructor is a tagged union - use C API
typedef AzHttpHeaderVecDestructor HttpHeaderVecDestructor;

// JsonVecDestructor is a tagged union - use C API
typedef AzJsonVecDestructor JsonVecDestructor;

// DirEntryVecDestructor is a tagged union - use C API
typedef AzDirEntryVecDestructor DirEntryVecDestructor;

// JsonKeyValueVecDestructor is a tagged union - use C API
typedef AzJsonKeyValueVecDestructor JsonKeyValueVecDestructor;

// NamedFontVecDestructor is a tagged union - use C API
typedef AzNamedFontVecDestructor NamedFontVecDestructor;

// ExternalResourceVecDestructor is a tagged union - use C API
typedef AzExternalResourceVecDestructor ExternalResourceVecDestructor;

// NodeHierarchyItemIdVecDestructor is a tagged union - use C API
typedef AzNodeHierarchyItemIdVecDestructor NodeHierarchyItemIdVecDestructor;

// CalcAstItemVecDestructor is a tagged union - use C API
typedef AzCalcAstItemVecDestructor CalcAstItemVecDestructor;

// GridAreaDefinitionVecDestructor is a tagged union - use C API
typedef AzGridAreaDefinitionVecDestructor GridAreaDefinitionVecDestructor;

// ComponentDataFieldVecDestructor is a tagged union - use C API
typedef AzComponentDataFieldVecDestructor ComponentDataFieldVecDestructor;

// ComponentDefVecDestructor is a tagged union - use C API
typedef AzComponentDefVecDestructor ComponentDefVecDestructor;

// ComponentLibraryVecDestructor is a tagged union - use C API
typedef AzComponentLibraryVecDestructor ComponentLibraryVecDestructor;

// ComponentDataModelVecDestructor is a tagged union - use C API
typedef AzComponentDataModelVecDestructor ComponentDataModelVecDestructor;

// ComponentEnumVariantVecDestructor is a tagged union - use C API
typedef AzComponentEnumVariantVecDestructor ComponentEnumVariantVecDestructor;

// ComponentEnumModelVecDestructor is a tagged union - use C API
typedef AzComponentEnumModelVecDestructor ComponentEnumModelVecDestructor;

// ComponentFieldOverrideVecDestructor is a tagged union - use C API
typedef AzComponentFieldOverrideVecDestructor ComponentFieldOverrideVecDestructor;

// ComponentCallbackArgVecDestructor is a tagged union - use C API
typedef AzComponentCallbackArgVecDestructor ComponentCallbackArgVecDestructor;

// SvgPathElementVecDestructor is a tagged union - use C API
typedef AzSvgPathElementVecDestructor SvgPathElementVecDestructor;

// SvgPathVecDestructor is a tagged union - use C API
typedef AzSvgPathVecDestructor SvgPathVecDestructor;

// RibbonTabVecDestructor is a tagged union - use C API
typedef AzRibbonTabVecDestructor RibbonTabVecDestructor;

// RibbonSectionVecDestructor is a tagged union - use C API
typedef AzRibbonSectionVecDestructor RibbonSectionVecDestructor;

// TreeViewNodeVecDestructor is a tagged union - use C API
typedef AzTreeViewNodeVecDestructor TreeViewNodeVecDestructor;

// RouteVecDestructor is a tagged union - use C API
typedef AzRouteVecDestructor RouteVecDestructor;

// TouchPointVecDestructor is a tagged union - use C API
typedef AzTouchPointVecDestructor TouchPointVecDestructor;

// LayoutRectVecDestructor is a tagged union - use C API
typedef AzLayoutRectVecDestructor LayoutRectVecDestructor;

// DbValueVecDestructor is a tagged union - use C API
typedef AzDbValueVecDestructor DbValueVecDestructor;

// LoadedFontVecDestructor is a tagged union - use C API
typedef AzLoadedFontVecDestructor LoadedFontVecDestructor;

// PixelValueOrSystem is a tagged union - use C API
typedef AzPixelValueOrSystem PixelValueOrSystem;

// StyleCompositeFilter is a tagged union - use C API
typedef AzStyleCompositeFilter StyleCompositeFilter;

// Direction is a tagged union - use C API
typedef AzDirection Direction;

// BackgroundPositionHorizontal is a tagged union - use C API
typedef AzBackgroundPositionHorizontal BackgroundPositionHorizontal;

// BackgroundPositionVertical is a tagged union - use C API
typedef AzBackgroundPositionVertical BackgroundPositionVertical;

// LayoutFlexBasis is a tagged union - use C API
typedef AzLayoutFlexBasis LayoutFlexBasis;

// ColumnWidth is a tagged union - use C API
typedef AzColumnWidth ColumnWidth;

// StyleScrollbarColor is a tagged union - use C API
typedef AzStyleScrollbarColor StyleScrollbarColor;

// StyleVerticalAlign is a tagged union - use C API
typedef AzStyleVerticalAlign StyleVerticalAlign;

// GridTrackSizing is a tagged union - use C API
typedef AzGridTrackSizing GridTrackSizing;

// ImePosition is a tagged union - use C API
typedef AzImePosition ImePosition;

// CalcAstItem is a tagged union - use C API
typedef AzCalcAstItem CalcAstItem;

// OsVersionCondition is a tagged union - use C API
typedef AzOsVersionCondition OsVersionCondition;

// SvgPathElement is a tagged union - use C API
typedef AzSvgPathElement SvgPathElement;

// CssSyntaxError is a tagged union - use C API
typedef AzCssSyntaxError CssSyntaxError;

// ThreadSendMsg is a tagged union - use C API
typedef AzThreadSendMsg ThreadSendMsg;

// Selection is a tagged union - use C API
typedef AzSelection Selection;

// LayoutHeight is a tagged union - use C API
typedef AzLayoutHeight LayoutHeight;

// LayoutWidth is a tagged union - use C API
typedef AzLayoutWidth LayoutWidth;

// StyleBackgroundSize is a tagged union - use C API
typedef AzStyleBackgroundSize StyleBackgroundSize;

// StyleTransform is a tagged union - use C API
typedef AzStyleTransform StyleTransform;

// FontLoadingConfig is a tagged union - use C API
typedef AzFontLoadingConfig FontLoadingConfig;

// RawImageData is a tagged union - use C API
typedef AzRawImageData RawImageData;

// Instant is a tagged union - use C API
typedef AzInstant Instant;

// FluentSyntaxCheckResult is a tagged union - use C API
typedef AzFluentSyntaxCheckResult FluentSyntaxCheckResult;

// WindowIcon is a tagged union - use C API
typedef AzWindowIcon WindowIcon;

// ThemeCondition is a tagged union - use C API
typedef AzThemeCondition ThemeCondition;

// AccessibilityAction is a tagged union - use C API
typedef AzAccessibilityAction AccessibilityAction;

// IdOrClass is a tagged union - use C API
typedef AzIdOrClass IdOrClass;

// StyleFilter is a tagged union - use C API
typedef AzStyleFilter StyleFilter;

// StyleFontFamily is a tagged union - use C API
typedef AzStyleFontFamily StyleFontFamily;

// FlowFrom is a tagged union - use C API
typedef AzFlowFrom FlowFrom;

// FlowInto is a tagged union - use C API
typedef AzFlowInto FlowInto;

// DesktopEnvironment is a tagged union - use C API
typedef AzDesktopEnvironment DesktopEnvironment;

// CssBorderStyleParseErrorOwned is a tagged union - use C API
typedef AzCssBorderStyleParseErrorOwned CssBorderStyleParseErrorOwned;

// StyleExclusionMarginParseErrorOwned is a tagged union - use C API
typedef AzStyleExclusionMarginParseErrorOwned StyleExclusionMarginParseErrorOwned;

// StyleInitialLetterParseErrorOwned is a tagged union - use C API
typedef AzStyleInitialLetterParseErrorOwned StyleInitialLetterParseErrorOwned;

// JustifyContentParseErrorOwned is a tagged union - use C API
typedef AzJustifyContentParseErrorOwned JustifyContentParseErrorOwned;

// AlignItemsParseErrorOwned is a tagged union - use C API
typedef AzAlignItemsParseErrorOwned AlignItemsParseErrorOwned;

// AlignContentParseErrorOwned is a tagged union - use C API
typedef AzAlignContentParseErrorOwned AlignContentParseErrorOwned;

// LayoutDisplayParseErrorOwned is a tagged union - use C API
typedef AzLayoutDisplayParseErrorOwned LayoutDisplayParseErrorOwned;

// AlignSelfParseErrorOwned is a tagged union - use C API
typedef AzAlignSelfParseErrorOwned AlignSelfParseErrorOwned;

// TextJustifyParseErrorOwned is a tagged union - use C API
typedef AzTextJustifyParseErrorOwned TextJustifyParseErrorOwned;

// JustifySelfParseErrorOwned is a tagged union - use C API
typedef AzJustifySelfParseErrorOwned JustifySelfParseErrorOwned;

// LayoutBoxSizingParseErrorOwned is a tagged union - use C API
typedef AzLayoutBoxSizingParseErrorOwned LayoutBoxSizingParseErrorOwned;

// LayoutClearParseErrorOwned is a tagged union - use C API
typedef AzLayoutClearParseErrorOwned LayoutClearParseErrorOwned;

// ColumnCountParseErrorOwned is a tagged union - use C API
typedef AzColumnCountParseErrorOwned ColumnCountParseErrorOwned;

// StyleTextCombineUprightParseErrorOwned is a tagged union - use C API
typedef AzStyleTextCombineUprightParseErrorOwned StyleTextCombineUprightParseErrorOwned;

// PercentageParseErrorOwned is a tagged union - use C API
typedef AzPercentageParseErrorOwned PercentageParseErrorOwned;

// LayoutPositionParseErrorOwned is a tagged union - use C API
typedef AzLayoutPositionParseErrorOwned LayoutPositionParseErrorOwned;

// LayoutFloatParseErrorOwned is a tagged union - use C API
typedef AzLayoutFloatParseErrorOwned LayoutFloatParseErrorOwned;

// FlexDirectionParseErrorOwned is a tagged union - use C API
typedef AzFlexDirectionParseErrorOwned FlexDirectionParseErrorOwned;

// CssBackfaceVisibilityParseErrorOwned is a tagged union - use C API
typedef AzCssBackfaceVisibilityParseErrorOwned CssBackfaceVisibilityParseErrorOwned;

// StyleHyphenationLanguageParseErrorOwned is a tagged union - use C API
typedef AzStyleHyphenationLanguageParseErrorOwned StyleHyphenationLanguageParseErrorOwned;

// StyleListStyleTypeParseErrorOwned is a tagged union - use C API
typedef AzStyleListStyleTypeParseErrorOwned StyleListStyleTypeParseErrorOwned;

// LayoutWritingModeParseErrorOwned is a tagged union - use C API
typedef AzLayoutWritingModeParseErrorOwned LayoutWritingModeParseErrorOwned;

// JustifyItemsParseErrorOwned is a tagged union - use C API
typedef AzJustifyItemsParseErrorOwned JustifyItemsParseErrorOwned;

// BoxDecorationBreakParseErrorOwned is a tagged union - use C API
typedef AzBoxDecorationBreakParseErrorOwned BoxDecorationBreakParseErrorOwned;

// PageBreakParseErrorOwned is a tagged union - use C API
typedef AzPageBreakParseErrorOwned PageBreakParseErrorOwned;

// StyleLineClampParseErrorOwned is a tagged union - use C API
typedef AzStyleLineClampParseErrorOwned StyleLineClampParseErrorOwned;

// BreakInsideParseErrorOwned is a tagged union - use C API
typedef AzBreakInsideParseErrorOwned BreakInsideParseErrorOwned;

// LayoutScrollbarWidthParseErrorOwned is a tagged union - use C API
typedef AzLayoutScrollbarWidthParseErrorOwned LayoutScrollbarWidthParseErrorOwned;

// LayoutOverflowParseErrorOwned is a tagged union - use C API
typedef AzLayoutOverflowParseErrorOwned LayoutOverflowParseErrorOwned;

// CssDirectionCornerParseErrorOwned is a tagged union - use C API
typedef AzCssDirectionCornerParseErrorOwned CssDirectionCornerParseErrorOwned;

// CssStyleFontFamilyParseErrorOwned is a tagged union - use C API
typedef AzCssStyleFontFamilyParseErrorOwned CssStyleFontFamilyParseErrorOwned;

// StyleHangingPunctuationParseErrorOwned is a tagged union - use C API
typedef AzStyleHangingPunctuationParseErrorOwned StyleHangingPunctuationParseErrorOwned;

// StyleListStylePositionParseErrorOwned is a tagged union - use C API
typedef AzStyleListStylePositionParseErrorOwned StyleListStylePositionParseErrorOwned;

// ColumnFillParseErrorOwned is a tagged union - use C API
typedef AzColumnFillParseErrorOwned ColumnFillParseErrorOwned;

// ColumnSpanParseErrorOwned is a tagged union - use C API
typedef AzColumnSpanParseErrorOwned ColumnSpanParseErrorOwned;

// ScrollbarVisibilityModeParseErrorOwned is a tagged union - use C API
typedef AzScrollbarVisibilityModeParseErrorOwned ScrollbarVisibilityModeParseErrorOwned;

// ScrollbarFadeDurationParseErrorOwned is a tagged union - use C API
typedef AzScrollbarFadeDurationParseErrorOwned ScrollbarFadeDurationParseErrorOwned;

// ScrollbarFadeDelayParseErrorOwned is a tagged union - use C API
typedef AzScrollbarFadeDelayParseErrorOwned ScrollbarFadeDelayParseErrorOwned;

// StyleTextOrientationParseErrorOwned is a tagged union - use C API
typedef AzStyleTextOrientationParseErrorOwned StyleTextOrientationParseErrorOwned;

// StyleObjectFitParseErrorOwned is a tagged union - use C API
typedef AzStyleObjectFitParseErrorOwned StyleObjectFitParseErrorOwned;

// StyleAspectRatioParseErrorOwned is a tagged union - use C API
typedef AzStyleAspectRatioParseErrorOwned StyleAspectRatioParseErrorOwned;

// StyleObjectPositionParseErrorOwned is a tagged union - use C API
typedef AzStyleObjectPositionParseErrorOwned StyleObjectPositionParseErrorOwned;

// StyleScrollbarGutterParseErrorOwned is a tagged union - use C API
typedef AzStyleScrollbarGutterParseErrorOwned StyleScrollbarGutterParseErrorOwned;

// StyleOverflowClipMarginParseErrorOwned is a tagged union - use C API
typedef AzStyleOverflowClipMarginParseErrorOwned StyleOverflowClipMarginParseErrorOwned;

// LanguageCondition is a tagged union - use C API
typedef AzLanguageCondition LanguageCondition;

// StyleClipRectParseErrorOwned is a tagged union - use C API
typedef AzStyleClipRectParseErrorOwned StyleClipRectParseErrorOwned;

// CssImageParseErrorOwned is a tagged union - use C API
typedef AzCssImageParseErrorOwned CssImageParseErrorOwned;

// CssPathPseudoSelector is a tagged union - use C API
typedef AzCssPathPseudoSelector CssPathPseudoSelector;

// GridAutoFlowParseErrorOwned is a tagged union - use C API
typedef AzGridAutoFlowParseErrorOwned GridAutoFlowParseErrorOwned;

// ParenthesisParseErrorOwned is a tagged union - use C API
typedef AzParenthesisParseErrorOwned ParenthesisParseErrorOwned;

// NodeTypeTagParseErrorOwned is a tagged union - use C API
typedef AzNodeTypeTagParseErrorOwned NodeTypeTagParseErrorOwned;

// FlexWrapParseErrorOwned is a tagged union - use C API
typedef AzFlexWrapParseErrorOwned FlexWrapParseErrorOwned;

// GridParseErrorOwned is a tagged union - use C API
typedef AzGridParseErrorOwned GridParseErrorOwned;

// FlexBasisParseErrorOwned is a tagged union - use C API
typedef AzFlexBasisParseErrorOwned FlexBasisParseErrorOwned;

// FlowIntoParseErrorOwned is a tagged union - use C API
typedef AzFlowIntoParseErrorOwned FlowIntoParseErrorOwned;

// FlowFromParseErrorOwned is a tagged union - use C API
typedef AzFlowFromParseErrorOwned FlowFromParseErrorOwned;

// DurationParseErrorOwned is a tagged union - use C API
typedef AzDurationParseErrorOwned DurationParseErrorOwned;

// PercentageParseError is a tagged union - use C API
typedef AzPercentageParseError PercentageParseError;

// KeyringResult is a tagged union - use C API
typedef AzKeyringResult KeyringResult;

// FmtValue is a tagged union - use C API
typedef AzFmtValue FmtValue;

// DbValue is a tagged union - use C API
typedef AzDbValue DbValue;

// ComponentFieldValueSource is a tagged union - use C API
typedef AzComponentFieldValueSource ComponentFieldValueSource;

// Platform is a tagged union - use C API
typedef AzPlatform Platform;

// CursorParseErrorOwned is a tagged union - use C API
typedef AzCursorParseErrorOwned CursorParseErrorOwned;

// NodeType is a tagged union - use C API
typedef AzNodeType NodeType;

// AttributeType is a tagged union - use C API
typedef AzAttributeType AttributeType;

// StyleBackgroundContent is a tagged union - use C API
typedef AzStyleBackgroundContent StyleBackgroundContent;

// GridLine is a tagged union - use C API
typedef AzGridLine GridLine;

// CssShape is a tagged union - use C API
typedef AzCssShape CssShape;

// CssPixelValueParseErrorOwned is a tagged union - use C API
typedef AzCssPixelValueParseErrorOwned CssPixelValueParseErrorOwned;

// StyleVisibilityParseErrorOwned is a tagged union - use C API
typedef AzStyleVisibilityParseErrorOwned StyleVisibilityParseErrorOwned;

// StyleTextDecorationParseErrorOwned is a tagged union - use C API
typedef AzStyleTextDecorationParseErrorOwned StyleTextDecorationParseErrorOwned;

// LayoutZIndexParseErrorOwned is a tagged union - use C API
typedef AzLayoutZIndexParseErrorOwned LayoutZIndexParseErrorOwned;

// StyleWhiteSpaceParseErrorOwned is a tagged union - use C API
typedef AzStyleWhiteSpaceParseErrorOwned StyleWhiteSpaceParseErrorOwned;

// StyleDirectionParseErrorOwned is a tagged union - use C API
typedef AzStyleDirectionParseErrorOwned StyleDirectionParseErrorOwned;

// StyleVerticalAlignParseErrorOwned is a tagged union - use C API
typedef AzStyleVerticalAlignParseErrorOwned StyleVerticalAlignParseErrorOwned;

// CssStyleCompositeFilterParseErrorOwned is a tagged union - use C API
typedef AzCssStyleCompositeFilterParseErrorOwned CssStyleCompositeFilterParseErrorOwned;

// CssShapeParseErrorOwned is a tagged union - use C API
typedef AzCssShapeParseErrorOwned CssShapeParseErrorOwned;

// StyleHyphensParseErrorOwned is a tagged union - use C API
typedef AzStyleHyphensParseErrorOwned StyleHyphensParseErrorOwned;

// CssAngleValueParseErrorOwned is a tagged union - use C API
typedef AzCssAngleValueParseErrorOwned CssAngleValueParseErrorOwned;

// MixBlendModeParseErrorOwned is a tagged union - use C API
typedef AzMixBlendModeParseErrorOwned MixBlendModeParseErrorOwned;

// ColumnRuleStyleParseErrorOwned is a tagged union - use C API
typedef AzColumnRuleStyleParseErrorOwned ColumnRuleStyleParseErrorOwned;

// CssFontStyleParseErrorOwned is a tagged union - use C API
typedef AzCssFontStyleParseErrorOwned CssFontStyleParseErrorOwned;

// StyleUserSelectParseErrorOwned is a tagged union - use C API
typedef AzStyleUserSelectParseErrorOwned StyleUserSelectParseErrorOwned;

// StyleTextAlignParseErrorOwned is a tagged union - use C API
typedef AzStyleTextAlignParseErrorOwned StyleTextAlignParseErrorOwned;

// CssStyleColorMatrixParseErrorOwned is a tagged union - use C API
typedef AzCssStyleColorMatrixParseErrorOwned CssStyleColorMatrixParseErrorOwned;

// OrphansParseErrorOwned is a tagged union - use C API
typedef AzOrphansParseErrorOwned OrphansParseErrorOwned;

// WidowsParseErrorOwned is a tagged union - use C API
typedef AzWidowsParseErrorOwned WidowsParseErrorOwned;

// StyleTextAlignLastParseErrorOwned is a tagged union - use C API
typedef AzStyleTextAlignLastParseErrorOwned StyleTextAlignLastParseErrorOwned;

// StyleWordBreakParseErrorOwned is a tagged union - use C API
typedef AzStyleWordBreakParseErrorOwned StyleWordBreakParseErrorOwned;

// StyleOverflowWrapParseErrorOwned is a tagged union - use C API
typedef AzStyleOverflowWrapParseErrorOwned StyleOverflowWrapParseErrorOwned;

// StyleLineBreakParseErrorOwned is a tagged union - use C API
typedef AzStyleLineBreakParseErrorOwned StyleLineBreakParseErrorOwned;

// StyleAlignmentBaselineParseErrorOwned is a tagged union - use C API
typedef AzStyleAlignmentBaselineParseErrorOwned StyleAlignmentBaselineParseErrorOwned;

// StyleUnicodeBidiParseErrorOwned is a tagged union - use C API
typedef AzStyleUnicodeBidiParseErrorOwned StyleUnicodeBidiParseErrorOwned;

// StyleTextBoxEdgeParseErrorOwned is a tagged union - use C API
typedef AzStyleTextBoxEdgeParseErrorOwned StyleTextBoxEdgeParseErrorOwned;

// StyleTextBoxTrimParseErrorOwned is a tagged union - use C API
typedef AzStyleTextBoxTrimParseErrorOwned StyleTextBoxTrimParseErrorOwned;

// StyleDominantBaselineParseErrorOwned is a tagged union - use C API
typedef AzStyleDominantBaselineParseErrorOwned StyleDominantBaselineParseErrorOwned;

// StyleInitialLetterWrapParseErrorOwned is a tagged union - use C API
typedef AzStyleInitialLetterWrapParseErrorOwned StyleInitialLetterWrapParseErrorOwned;

// StyleInitialLetterAlignParseErrorOwned is a tagged union - use C API
typedef AzStyleInitialLetterAlignParseErrorOwned StyleInitialLetterAlignParseErrorOwned;

// DynamicSelector is a tagged union - use C API
typedef AzDynamicSelector DynamicSelector;

// CssFontWeightParseErrorOwned is a tagged union - use C API
typedef AzCssFontWeightParseErrorOwned CssFontWeightParseErrorOwned;

// FlexGrowParseErrorOwned is a tagged union - use C API
typedef AzFlexGrowParseErrorOwned FlexGrowParseErrorOwned;

// FlexShrinkParseErrorOwned is a tagged union - use C API
typedef AzFlexShrinkParseErrorOwned FlexShrinkParseErrorOwned;

// XmlStreamError is a tagged union - use C API
typedef AzXmlStreamError XmlStreamError;

// IcuResult is a tagged union - use C API
typedef AzIcuResult IcuResult;

// HttpError is a tagged union - use C API
typedef AzHttpError HttpError;

// ComponentError is a tagged union - use C API
typedef AzComponentError ComponentError;

// StyleLineHeightParseError is a tagged union - use C API
typedef AzStyleLineHeightParseError StyleLineHeightParseError;

// ThreadReceiveMsg is a tagged union - use C API
typedef AzThreadReceiveMsg ThreadReceiveMsg;

// ComponentFieldType is a tagged union - use C API
typedef AzComponentFieldType ComponentFieldType;

// ComponentDefaultValue is a tagged union - use C API
typedef AzComponentDefaultValue ComponentDefaultValue;

// XmlNodeChild is a tagged union - use C API
typedef AzXmlNodeChild XmlNodeChild;

// ShapeOutside is a tagged union - use C API
typedef AzShapeOutside ShapeOutside;

// ShapeInside is a tagged union - use C API
typedef AzShapeInside ShapeInside;

// ClipPath is a tagged union - use C API
typedef AzClipPath ClipPath;

// TextOperation is a tagged union - use C API
typedef AzTextOperation TextOperation;

// LayoutMarginParseErrorOwned is a tagged union - use C API
typedef AzLayoutMarginParseErrorOwned LayoutMarginParseErrorOwned;

// StyleTabSizeParseErrorOwned is a tagged union - use C API
typedef AzStyleTabSizeParseErrorOwned StyleTabSizeParseErrorOwned;

// CssStylePerspectiveOriginParseErrorOwned is a tagged union - use C API
typedef AzCssStylePerspectiveOriginParseErrorOwned CssStylePerspectiveOriginParseErrorOwned;

// StyleTextIndentParseErrorOwned is a tagged union - use C API
typedef AzStyleTextIndentParseErrorOwned StyleTextIndentParseErrorOwned;

// StyleLetterSpacingParseErrorOwned is a tagged union - use C API
typedef AzStyleLetterSpacingParseErrorOwned StyleLetterSpacingParseErrorOwned;

// OpacityParseErrorOwned is a tagged union - use C API
typedef AzOpacityParseErrorOwned OpacityParseErrorOwned;

// CssStyleTransformParseErrorOwned is a tagged union - use C API
typedef AzCssStyleTransformParseErrorOwned CssStyleTransformParseErrorOwned;

// CssStyleFontSizeParseErrorOwned is a tagged union - use C API
typedef AzCssStyleFontSizeParseErrorOwned CssStyleFontSizeParseErrorOwned;

// CssStyleFilterOffsetParseErrorOwned is a tagged union - use C API
typedef AzCssStyleFilterOffsetParseErrorOwned CssStyleFilterOffsetParseErrorOwned;

// ColumnWidthParseErrorOwned is a tagged union - use C API
typedef AzColumnWidthParseErrorOwned ColumnWidthParseErrorOwned;

// ColumnRuleWidthParseErrorOwned is a tagged union - use C API
typedef AzColumnRuleWidthParseErrorOwned ColumnRuleWidthParseErrorOwned;

// StyleWordSpacingParseErrorOwned is a tagged union - use C API
typedef AzStyleWordSpacingParseErrorOwned StyleWordSpacingParseErrorOwned;

// LayoutHeightParseErrorOwned is a tagged union - use C API
typedef AzLayoutHeightParseErrorOwned LayoutHeightParseErrorOwned;

// CssDirectionParseErrorOwned is a tagged union - use C API
typedef AzCssDirectionParseErrorOwned CssDirectionParseErrorOwned;

// LayoutPaddingParseErrorOwned is a tagged union - use C API
typedef AzLayoutPaddingParseErrorOwned LayoutPaddingParseErrorOwned;

// CssStyleBlurParseErrorOwned is a tagged union - use C API
typedef AzCssStyleBlurParseErrorOwned CssStyleBlurParseErrorOwned;

// LayoutWidthParseErrorOwned is a tagged union - use C API
typedef AzLayoutWidthParseErrorOwned LayoutWidthParseErrorOwned;

// CssBorderRadiusParseErrorOwned is a tagged union - use C API
typedef AzCssBorderRadiusParseErrorOwned CssBorderRadiusParseErrorOwned;

// CssStyleTransformOriginParseErrorOwned is a tagged union - use C API
typedef AzCssStyleTransformOriginParseErrorOwned CssStyleTransformOriginParseErrorOwned;

// CssBackgroundPositionParseErrorOwned is a tagged union - use C API
typedef AzCssBackgroundPositionParseErrorOwned CssBackgroundPositionParseErrorOwned;

// StyleBorderBottomRightRadiusParseErrorOwned is a tagged union - use C API
typedef AzStyleBorderBottomRightRadiusParseErrorOwned StyleBorderBottomRightRadiusParseErrorOwned;

// StyleBorderBottomLeftRadiusParseErrorOwned is a tagged union - use C API
typedef AzStyleBorderBottomLeftRadiusParseErrorOwned StyleBorderBottomLeftRadiusParseErrorOwned;

// LayoutMaxWidthParseErrorOwned is a tagged union - use C API
typedef AzLayoutMaxWidthParseErrorOwned LayoutMaxWidthParseErrorOwned;

// StyleBorderTopLeftRadiusParseErrorOwned is a tagged union - use C API
typedef AzStyleBorderTopLeftRadiusParseErrorOwned StyleBorderTopLeftRadiusParseErrorOwned;

// LayoutMinHeightParseErrorOwned is a tagged union - use C API
typedef AzLayoutMinHeightParseErrorOwned LayoutMinHeightParseErrorOwned;

// LayoutMinWidthParseErrorOwned is a tagged union - use C API
typedef AzLayoutMinWidthParseErrorOwned LayoutMinWidthParseErrorOwned;

// LayoutMaxHeightParseErrorOwned is a tagged union - use C API
typedef AzLayoutMaxHeightParseErrorOwned LayoutMaxHeightParseErrorOwned;

// StyleBorderTopRightRadiusParseErrorOwned is a tagged union - use C API
typedef AzStyleBorderTopRightRadiusParseErrorOwned StyleBorderTopRightRadiusParseErrorOwned;

// LayoutLeftParseErrorOwned is a tagged union - use C API
typedef AzLayoutLeftParseErrorOwned LayoutLeftParseErrorOwned;

// LayoutTopParseErrorOwned is a tagged union - use C API
typedef AzLayoutTopParseErrorOwned LayoutTopParseErrorOwned;

// LayoutInsetBottomParseErrorOwned is a tagged union - use C API
typedef AzLayoutInsetBottomParseErrorOwned LayoutInsetBottomParseErrorOwned;

// LayoutRightParseErrorOwned is a tagged union - use C API
typedef AzLayoutRightParseErrorOwned LayoutRightParseErrorOwned;

// CssPathSelector is a tagged union - use C API
typedef AzCssPathSelector CssPathSelector;

// CssPseudoSelectorParseErrorOwned is a tagged union - use C API
typedef AzCssPseudoSelectorParseErrorOwned CssPseudoSelectorParseErrorOwned;

// MenuItem is a tagged union - use C API
typedef AzMenuItem MenuItem;

// CssColorParseErrorOwned is a tagged union - use C API
typedef AzCssColorParseErrorOwned CssColorParseErrorOwned;

// CssConicGradientParseErrorOwned is a tagged union - use C API
typedef AzCssConicGradientParseErrorOwned CssConicGradientParseErrorOwned;

// XmlParseError is a tagged union - use C API
typedef AzXmlParseError XmlParseError;

// CssProperty is a tagged union - use C API
typedef AzCssProperty CssProperty;

// StyleTextColorParseErrorOwned is a tagged union - use C API
typedef AzStyleTextColorParseErrorOwned StyleTextColorParseErrorOwned;

// ColumnRuleColorParseErrorOwned is a tagged union - use C API
typedef AzColumnRuleColorParseErrorOwned ColumnRuleColorParseErrorOwned;

// CssBorderSideParseErrorOwned is a tagged union - use C API
typedef AzCssBorderSideParseErrorOwned CssBorderSideParseErrorOwned;

// CssGradientStopParseErrorOwned is a tagged union - use C API
typedef AzCssGradientStopParseErrorOwned CssGradientStopParseErrorOwned;

// CssShadowParseErrorOwned is a tagged union - use C API
typedef AzCssShadowParseErrorOwned CssShadowParseErrorOwned;

// StyleScrollbarColorParseErrorOwned is a tagged union - use C API
typedef AzStyleScrollbarColorParseErrorOwned StyleScrollbarColorParseErrorOwned;

// XmlError is a tagged union - use C API
typedef AzXmlError XmlError;

// CssBackgroundParseErrorOwned is a tagged union - use C API
typedef AzCssBackgroundParseErrorOwned CssBackgroundParseErrorOwned;

// CssStyleFilterParseErrorOwned is a tagged union - use C API
typedef AzCssStyleFilterParseErrorOwned CssStyleFilterParseErrorOwned;

// ResultXmlXmlError is a tagged union - use C API
typedef AzResultXmlXmlError ResultXmlXmlError;

// SvgParseError is a tagged union - use C API
typedef AzSvgParseError SvgParseError;

// CssDeclaration is a tagged union - use C API
typedef AzCssDeclaration CssDeclaration;

// CssParsingErrorOwned is a tagged union - use C API
typedef AzCssParsingErrorOwned CssParsingErrorOwned;

// DynamicCssParseErrorOwned is a tagged union - use C API
typedef AzDynamicCssParseErrorOwned DynamicCssParseErrorOwned;

// CssParseErrorInnerOwned is a tagged union - use C API
typedef AzCssParseErrorInnerOwned CssParseErrorInnerOwned;

// RenderDomError is a tagged union - use C API
typedef AzRenderDomError RenderDomError;

// ComponentParseError is a tagged union - use C API
typedef AzComponentParseError ComponentParseError;

// DomXmlParseError is a tagged union - use C API
typedef AzDomXmlParseError DomXmlParseError;

// CompileError is a tagged union - use C API
typedef AzCompileError CompileError;

// 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 {
    String::Proxy _p(AzMonitorId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzWasmWindowOptions_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzIconKey_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMacWindowOptions_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzIOSHandle_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMacOSHandle_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzXcbHandle_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzXlibHandle_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzWaylandHandle_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzWindowsHandle_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzWebHandle_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzAndroidHandle_toDbgString(&inner_));
    return _p;
}

inline IconProviderHandle IconProviderHandle::create() {
    IconProviderHandle::Proxy _p(AzIconProviderHandle_create());
    return _p;
}

inline IconProviderHandle IconProviderHandle::with_resolver(AzIconResolverCallbackType resolver) {
    IconProviderHandle::Proxy _p(AzIconProviderHandle_withResolver(resolver));
    return _p;
}

inline IconProviderHandle IconProviderHandle::default_() {
    IconProviderHandle::Proxy _p(AzIconProviderHandle_default());
    return _p;
}

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 {
    String::Proxy _p(AzIconProviderHandle_debugLookup(&inner_, icon_name.release()));
    return _p;
}

inline void IconProviderHandle::delete_() {
    AzIconProviderHandle_delete(&inner_);
}

inline IconProviderHandle IconProviderHandle::clone() const {
    IconProviderHandle::Proxy _p(AzIconProviderHandle_clone(&inner_));
    return _p;
}

inline String IconProviderHandle::toDbgString() const {
    String::Proxy _p(AzIconProviderHandle_toDbgString(&inner_));
    return _p;
}

inline String VideoModeVecSlice::toDbgString() const {
    String::Proxy _p(AzVideoModeVecSlice_toDbgString(&inner_));
    return _p;
}

inline String MonitorVecSlice::toDbgString() const {
    String::Proxy _p(AzMonitorVecSlice_toDbgString(&inner_));
    return _p;
}

inline String MimeTypeDataVecSlice::toDbgString() const {
    String::Proxy _p(AzMimeTypeDataVecSlice_toDbgString(&inner_));
    return _p;
}

inline String TouchPointVecSlice::toDbgString() const {
    String::Proxy _p(AzTouchPointVecSlice_toDbgString(&inner_));
    return _p;
}

inline AudioSink AudioSink::open(AudioConfig config) {
    AudioSink::Proxy _p(AzAudioSink_open(config.release()));
    return _p;
}

inline AudioSink AudioSink::default_() {
    AudioSink::Proxy _p(AzAudioSink_default());
    return _p;
}

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 {
    AudioSink::Proxy _p(AzAudioSink_clone(&inner_));
    return _p;
}

inline String HttpHeaderVecSlice::toDbgString() const {
    String::Proxy _p(AzHttpHeaderVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMsgBox_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzFileDialog_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzColorPickerDialog_toDbgString(&inner_));
    return _p;
}

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 {
    RefCount::Proxy _p(AzRefCount_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzRefCount_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGraphemeClusterId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzPenTilt_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNodeFlags_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDomId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNodeHierarchyItemId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNodeHierarchyItem_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTagId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDebugState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGeolocationProbeConfig_toDbgString(&inner_));
    return _p;
}

inline bool LocationFix::partialEq(const LocationFix& b) const {
    return AzLocationFix_partialEq(&inner_, b.ptr());
}

inline String LocationFix::toDbgString() const {
    String::Proxy _p(AzLocationFix_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNodeId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSelectionId_toDbgString(&inner_));
    return _p;
}

inline void TextInputSelectionRange::delete_() {
    AzTextInputSelectionRange_delete(&inner_);
}

inline TextInputSelectionRange TextInputSelectionRange::clone() const {
    TextInputSelectionRange::Proxy _p(AzTextInputSelectionRange_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTextInputSelectionRange_toDbgString(&inner_));
    return _p;
}

inline void TextSelectionStartEnd::delete_() {
    AzTextSelectionStartEnd_delete(&inner_);
}

inline TextSelectionStartEnd TextSelectionStartEnd::clone() const {
    TextSelectionStartEnd::Proxy _p(AzTextSelectionStartEnd_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTextSelectionStartEnd_toDbgString(&inner_));
    return _p;
}

inline String NodeDataVecSlice::toDbgString() const {
    String::Proxy _p(AzNodeDataVecSlice_toDbgString(&inner_));
    return _p;
}

inline String NodeHierarchyItemVecSlice::toDbgString() const {
    String::Proxy _p(AzNodeHierarchyItemVecSlice_toDbgString(&inner_));
    return _p;
}

inline String DomIdVecSlice::toDbgString() const {
    String::Proxy _p(AzDomIdVecSlice_toDbgString(&inner_));
    return _p;
}

inline String TagIdToNodeIdMappingVecSlice::toDbgString() const {
    String::Proxy _p(AzTagIdToNodeIdMappingVecSlice_toDbgString(&inner_));
    return _p;
}

inline String VertexAttributeVecSlice::toDbgString() const {
    String::Proxy _p(AzVertexAttributeVecSlice_toDbgString(&inner_));
    return _p;
}

inline String NodeHierarchyItemIdVecSlice::toDbgString() const {
    String::Proxy _p(AzNodeHierarchyItemIdVecSlice_toDbgString(&inner_));
    return _p;
}

inline String IdOrClassVecSlice::toDbgString() const {
    String::Proxy _p(AzIdOrClassVecSlice_toDbgString(&inner_));
    return _p;
}

inline String SelectionRangeVecSlice::toDbgString() const {
    String::Proxy _p(AzSelectionRangeVecSlice_toDbgString(&inner_));
    return _p;
}

inline String SelectionVecSlice::toDbgString() const {
    String::Proxy _p(AzSelectionVecSlice_toDbgString(&inner_));
    return _p;
}

inline String DomVecSlice::toDbgString() const {
    String::Proxy _p(AzDomVecSlice_toDbgString(&inner_));
    return _p;
}

inline String AttributeTypeVecSlice::toDbgString() const {
    String::Proxy _p(AzAttributeTypeVecSlice_toDbgString(&inner_));
    return _p;
}

inline String AccessibilityActionVecSlice::toDbgString() const {
    String::Proxy _p(AzAccessibilityActionVecSlice_toDbgString(&inner_));
    return _p;
}

inline String CoreCallbackDataVecSlice::toDbgString() const {
    String::Proxy _p(AzCoreCallbackDataVecSlice_toDbgString(&inner_));
    return _p;
}

inline String ParentWithNodeDepthVecSlice::toDbgString() const {
    String::Proxy _p(AzParentWithNodeDepthVecSlice_toDbgString(&inner_));
    return _p;
}

inline String XmlNodeChildVecSlice::toDbgString() const {
    String::Proxy _p(AzXmlNodeChildVecSlice_toDbgString(&inner_));
    return _p;
}

inline AccessibilitySettings AccessibilitySettings::default_() {
    AccessibilitySettings::Proxy _p(AzAccessibilitySettings_default());
    return _p;
}

inline void AccessibilitySettings::delete_() {
    AzAccessibilitySettings_delete(&inner_);
}

inline AccessibilitySettings AccessibilitySettings::clone() const {
    AccessibilitySettings::Proxy _p(AzAccessibilitySettings_clone(&inner_));
    return _p;
}

inline bool AccessibilitySettings::partialEq(const AccessibilitySettings& b) const {
    return AzAccessibilitySettings_partialEq(&inner_, b.ptr());
}

inline String AccessibilitySettings::toDbgString() const {
    String::Proxy _p(AzAccessibilitySettings_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzInputMetrics_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDragDelta_toDbgString(&inner_));
    return _p;
}

inline String MenuItemVecSlice::toDbgString() const {
    String::Proxy _p(AzMenuItemVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCssNthChildPattern_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzColorU_toHash(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzColorU_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzFloatValue_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutSize_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleLineClamp_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOrphans_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzWidows_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleHangingPunctuation_toDbgString(&inner_));
    return _p;
}

inline void XmlTextPos::delete_() {
    AzXmlTextPos_delete(&inner_);
}

inline XmlTextPos XmlTextPos::clone() const {
    XmlTextPos::Proxy _p(AzXmlTextPos_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzXmlTextPos_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLogicalSize_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyledNodeState_toDbgString(&inner_));
    return _p;
}

inline void CssPropertyCachePtr::delete_() {
    AzCssPropertyCachePtr_delete(&inner_);
}

inline CssPropertyCachePtr CssPropertyCachePtr::clone() const {
    CssPropertyCachePtr::Proxy _p(AzCssPropertyCachePtr_clone(&inner_));
    return _p;
}

inline bool CssPropertyCachePtr::partialEq(const CssPropertyCachePtr& b) const {
    return AzCssPropertyCachePtr_partialEq(&inner_, b.ptr());
}

inline String CssPropertyCachePtr::toDbgString() const {
    String::Proxy _p(AzCssPropertyCachePtr_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgRenderTransform_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLogicalPosition_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzScreenPosition_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCursorNodePosition_toDbgString(&inner_));
    return _p;
}

inline void GridMinMax::delete_() {
    AzGridMinMax_delete(&inner_);
}

inline GridMinMax GridMinMax::clone() const {
    GridMinMax::Proxy _p(AzGridMinMax_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGridMinMax_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzShapePoint_toDbgString(&inner_));
    return _p;
}

inline String LayoutRectVecSlice::toDbgString() const {
    String::Proxy _p(AzLayoutRectVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutPoint_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLinuxDecorationsState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCascadeInfo_toDbgString(&inner_));
    return _p;
}

inline String GridTrackSizingVecSlice::toDbgString() const {
    String::Proxy _p(AzGridTrackSizingVecSlice_toDbgString(&inner_));
    return _p;
}

inline String ContentGroupVecSlice::toDbgString() const {
    String::Proxy _p(AzContentGroupVecSlice_toDbgString(&inner_));
    return _p;
}

inline String StyledTextRunVecSlice::toDbgString() const {
    String::Proxy _p(AzStyledTextRunVecSlice_toDbgString(&inner_));
    return _p;
}

inline String CssRuleBlockVecSlice::toDbgString() const {
    String::Proxy _p(AzCssRuleBlockVecSlice_toDbgString(&inner_));
    return _p;
}

inline String CascadeInfoVecSlice::toDbgString() const {
    String::Proxy _p(AzCascadeInfoVecSlice_toDbgString(&inner_));
    return _p;
}

inline String NormalizedRadialColorStopVecSlice::toDbgString() const {
    String::Proxy _p(AzNormalizedRadialColorStopVecSlice_toDbgString(&inner_));
    return _p;
}

inline String StyleFontFamilyVecSlice::toDbgString() const {
    String::Proxy _p(AzStyleFontFamilyVecSlice_toDbgString(&inner_));
    return _p;
}

inline String StyleFilterVecSlice::toDbgString() const {
    String::Proxy _p(AzStyleFilterVecSlice_toDbgString(&inner_));
    return _p;
}

inline String StyleBackgroundSizeVecSlice::toDbgString() const {
    String::Proxy _p(AzStyleBackgroundSizeVecSlice_toDbgString(&inner_));
    return _p;
}

inline String StyleBackgroundContentVecSlice::toDbgString() const {
    String::Proxy _p(AzStyleBackgroundContentVecSlice_toDbgString(&inner_));
    return _p;
}

inline String CssDeclarationVecSlice::toDbgString() const {
    String::Proxy _p(AzCssDeclarationVecSlice_toDbgString(&inner_));
    return _p;
}

inline String StyleBackgroundPositionVecSlice::toDbgString() const {
    String::Proxy _p(AzStyleBackgroundPositionVecSlice_toDbgString(&inner_));
    return _p;
}

inline String NormalizedLinearColorStopVecSlice::toDbgString() const {
    String::Proxy _p(AzNormalizedLinearColorStopVecSlice_toDbgString(&inner_));
    return _p;
}

inline String CssPropertyWithConditionsVecSlice::toDbgString() const {
    String::Proxy _p(AzCssPropertyWithConditionsVecSlice_toDbgString(&inner_));
    return _p;
}

inline String CssVecSlice::toDbgString() const {
    String::Proxy _p(AzCssVecSlice_toDbgString(&inner_));
    return _p;
}

inline String StyleTransformVecSlice::toDbgString() const {
    String::Proxy _p(AzStyleTransformVecSlice_toDbgString(&inner_));
    return _p;
}

inline String StyledNodeVecSlice::toDbgString() const {
    String::Proxy _p(AzStyledNodeVecSlice_toDbgString(&inner_));
    return _p;
}

inline String ShapePointVecSlice::toDbgString() const {
    String::Proxy _p(AzShapePointVecSlice_toDbgString(&inner_));
    return _p;
}

inline String NamedFontVecSlice::toDbgString() const {
    String::Proxy _p(AzNamedFontVecSlice_toDbgString(&inner_));
    return _p;
}

inline String GridAreaDefinitionVecSlice::toDbgString() const {
    String::Proxy _p(AzGridAreaDefinitionVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgTransform_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzScrollbarFadeDuration_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzScrollbarFadeDelay_toDbgString(&inner_));
    return _p;
}

inline String U16VecSlice::toDbgString() const {
    String::Proxy _p(AzU16VecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzAudioMetrics_toDbgString(&inner_));
    return _p;
}

inline ScrollPhysics ScrollPhysics::default_() {
    ScrollPhysics::Proxy _p(AzScrollPhysics_default());
    return _p;
}

inline void ScrollPhysics::delete_() {
    AzScrollPhysics_delete(&inner_);
}

inline ScrollPhysics ScrollPhysics::clone() const {
    ScrollPhysics::Proxy _p(AzScrollPhysics_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzScrollPhysics_toDbgString(&inner_));
    return _p;
}

inline String CalcAstItemVecSlice::toDbgString() const {
    String::Proxy _p(AzCalcAstItemVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMinMaxRange_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzAspectRatioValue_toDbgString(&inner_));
    return _p;
}

inline String F32VecSlice::toDbgString() const {
    String::Proxy _p(AzF32VecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzEmptyStruct_toDbgString(&inner_));
    return _p;
}

inline String U32VecSlice::toDbgString() const {
    String::Proxy _p(AzU32VecSlice_toDbgString(&inner_));
    return _p;
}

inline String DynamicSelectorVecSlice::toDbgString() const {
    String::Proxy _p(AzDynamicSelectorVecSlice_toDbgString(&inner_));
    return _p;
}

inline String U8VecSlice::toDbgString() const {
    String::Proxy _p(AzU8VecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMapTileId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMapViewport_toDbgString(&inner_));
    return _p;
}

inline CheckBoxState CheckBoxState::default_() {
    CheckBoxState::Proxy _p(AzCheckBoxState_default());
    return _p;
}

inline void CheckBoxState::delete_() {
    AzCheckBoxState_delete(&inner_);
}

inline CheckBoxState CheckBoxState::clone() const {
    CheckBoxState::Proxy _p(AzCheckBoxState_clone(&inner_));
    return _p;
}

inline bool CheckBoxState::partialEq(const CheckBoxState& b) const {
    return AzCheckBoxState_partialEq(&inner_, b.ptr());
}

inline String CheckBoxState::toDbgString() const {
    String::Proxy _p(AzCheckBoxState_toDbgString(&inner_));
    return _p;
}

inline NumberInputState NumberInputState::default_() {
    NumberInputState::Proxy _p(AzNumberInputState_default());
    return _p;
}

inline void NumberInputState::delete_() {
    AzNumberInputState_delete(&inner_);
}

inline NumberInputState NumberInputState::clone() const {
    NumberInputState::Proxy _p(AzNumberInputState_clone(&inner_));
    return _p;
}

inline bool NumberInputState::partialEq(const NumberInputState& b) const {
    return AzNumberInputState_partialEq(&inner_, b.ptr());
}

inline String NumberInputState::toDbgString() const {
    String::Proxy _p(AzNumberInputState_toDbgString(&inner_));
    return _p;
}

inline void ProgressBarState::delete_() {
    AzProgressBarState_delete(&inner_);
}

inline ProgressBarState ProgressBarState::clone() const {
    ProgressBarState::Proxy _p(AzProgressBarState_clone(&inner_));
    return _p;
}

inline String ProgressBarState::toDbgString() const {
    String::Proxy _p(AzProgressBarState_toDbgString(&inner_));
    return _p;
}

inline bool TabHeaderState::partialEq(const TabHeaderState& b) const {
    return AzTabHeaderState_partialEq(&inner_, b.ptr());
}

inline String TabHeaderState::toDbgString() const {
    String::Proxy _p(AzTabHeaderState_toDbgString(&inner_));
    return _p;
}

inline String ListViewRowVecSlice::toDbgString() const {
    String::Proxy _p(AzListViewRowVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTitlebarButtons_toDbgString(&inner_));
    return _p;
}

inline String RibbonSectionVecSlice::toDbgString() const {
    String::Proxy _p(AzRibbonSectionVecSlice_toDbgString(&inner_));
    return _p;
}

inline String RibbonTabVecSlice::toDbgString() const {
    String::Proxy _p(AzRibbonTabVecSlice_toDbgString(&inner_));
    return _p;
}

inline String TreeViewNodeVecSlice::toDbgString() const {
    String::Proxy _p(AzTreeViewNodeVecSlice_toDbgString(&inner_));
    return _p;
}

inline bool MapLatLon::partialEq(const MapLatLon& b) const {
    return AzMapLatLon_partialEq(&inner_, b.ptr());
}

inline String MapLatLon::toDbgString() const {
    String::Proxy _p(AzMapLatLon_toDbgString(&inner_));
    return _p;
}

inline void GlVoidPtrConst::delete_() {
    AzGlVoidPtrConst_delete(&inner_);
}

inline GlVoidPtrConst GlVoidPtrConst::clone() const {
    GlVoidPtrConst::Proxy _p(AzGlVoidPtrConst_clone(&inner_));
    return _p;
}

inline String GlVoidPtrConst::toDbgString() const {
    String::Proxy _p(AzGlVoidPtrConst_toDbgString(&inner_));
    return _p;
}

inline void GlVoidPtrMut::delete_() {
    AzGlVoidPtrMut_delete(&inner_);
}

inline GlVoidPtrMut GlVoidPtrMut::clone() const {
    GlVoidPtrMut::Proxy _p(AzGlVoidPtrMut_clone(&inner_));
    return _p;
}

inline String GlVoidPtrMut::toDbgString() const {
    String::Proxy _p(AzGlVoidPtrMut_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTextureFlags_toDbgString(&inner_));
    return _p;
}

inline void GLsyncPtr::delete_() {
    AzGLsyncPtr_delete(&inner_);
}

inline GLsyncPtr GLsyncPtr::clone() const {
    GLsyncPtr::Proxy _p(AzGLsyncPtr_clone(&inner_));
    return _p;
}

inline String GLsyncPtr::toDbgString() const {
    String::Proxy _p(AzGLsyncPtr_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgVertex_toDbgString(&inner_));
    return _p;
}

inline String SvgVertexVecSlice::toDbgString() const {
    String::Proxy _p(AzSvgVertexVecSlice_toDbgString(&inner_));
    return _p;
}

inline String DebugMessageVecSlice::toDbgString() const {
    String::Proxy _p(AzDebugMessageVecSlice_toDbgString(&inner_));
    return _p;
}

inline ImageRef ImageRef::gl_texture(Texture texture) {
    ImageRef::Proxy _p(AzImageRef_glTexture(texture.release()));
    return _p;
}

inline ImageRef ImageRef::callback(CoreRenderImageCallback callback, RefAny data) {
    ImageRef::Proxy _p(AzImageRef_callback(callback.release(), data.release()));
    return _p;
}

inline ImageRef ImageRef::new_gltexture(Texture texture) {
    ImageRef::Proxy _p(AzImageRef_newGltexture(texture.release()));
    return _p;
}

inline ImageRef ImageRef::null_image(size_t width, size_t height, AzRawImageFormat format, U8VecRef tag) {
    ImageRef::Proxy _p(AzImageRef_nullImage(width, height, format, tag.release()));
    return _p;
}

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 {
    ImageRef::Proxy _p(AzImageRef_deepCopy(&inner_));
    return _p;
}

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 {
    ImageRef::Proxy _p(AzImageRef_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzImageRef_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzImageDescriptorFlags_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzImageRefHash_toDbgString(&inner_));
    return _p;
}

inline String RouteVecSlice::toDbgString() const {
    String::Proxy _p(AzRouteVecSlice_toDbgString(&inner_));
    return _p;
}

inline VideoEncoder VideoEncoder::open(uint32_t width, uint32_t height, bool h265, uint32_t bitrate_kbps) {
    VideoEncoder::Proxy _p(AzVideoEncoder_open(width, height, h265, bitrate_kbps));
    return _p;
}

inline VideoEncoder VideoEncoder::default_() {
    VideoEncoder::Proxy _p(AzVideoEncoder_default());
    return _p;
}

inline String VideoEncoder::backend_name() {
    String::Proxy _p(AzVideoEncoder_backendName());
    return _p;
}

inline bool VideoEncoder::is_open() const {
    return AzVideoEncoder_isOpen(&inner_);
}

inline U8Vec VideoEncoder::encode(VideoFrame frame, bool force_keyframe) const {
    U8Vec::Proxy _p(AzVideoEncoder_encode(&inner_, frame.release(), force_keyframe));
    return _p;
}

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 {
    VideoEncoder::Proxy _p(AzVideoEncoder_clone(&inner_));
    return _p;
}

inline VideoDecoder VideoDecoder::open(bool h265) {
    VideoDecoder::Proxy _p(AzVideoDecoder_open(h265));
    return _p;
}

inline VideoDecoder VideoDecoder::default_() {
    VideoDecoder::Proxy _p(AzVideoDecoder_default());
    return _p;
}

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 {
    VideoDecoder::Proxy _p(AzVideoDecoder_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzPanose_toDbgString(&inner_));
    return _p;
}

inline String LoadedFontVecSlice::toDbgString() const {
    String::Proxy _p(AzLoadedFontVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    Svg::Proxy _p(AzSvg_clone(&inner_));
    return _p;
}

inline String Svg::toDbgString() const {
    String::Proxy _p(AzSvg_toDbgString(&inner_));
    return _p;
}

inline String CssPathSelectorVecSlice::toDbgString() const {
    String::Proxy _p(AzCssPathSelectorVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgDashPattern_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgVector_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgRect_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgPoint_toDbgString(&inner_));
    return _p;
}

inline String SvgPathVecSlice::toDbgString() const {
    String::Proxy _p(AzSvgPathVecSlice_toDbgString(&inner_));
    return _p;
}

inline String SvgPathElementVecSlice::toDbgString() const {
    String::Proxy _p(AzSvgPathElementVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSystemTickDiff_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSystemTick_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSystemTimeDiff_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCssDuration_toDbgString(&inner_));
    return _p;
}

inline bool IcuTime::partialEq(const IcuTime& b) const {
    return AzIcuTime_partialEq(&inner_, b.ptr());
}

inline String IcuTime::toDbgString() const {
    String::Proxy _p(AzIcuTime_toDbgString(&inner_));
    return _p;
}

inline String StringPairVecSlice::toDbgString() const {
    String::Proxy _p(AzStringPairVecSlice_toDbgString(&inner_));
    return _p;
}

inline String StringVecSlice::toDbgString() const {
    String::Proxy _p(AzStringVecSlice_toDbgString(&inner_));
    return _p;
}

inline void GLbooleanVecRefMut::delete_() {
    AzGLbooleanVecRefMut_delete(&inner_);
}

inline GLbooleanVecRefMut GLbooleanVecRefMut::clone() const {
    GLbooleanVecRefMut::Proxy _p(AzGLbooleanVecRefMut_clone(&inner_));
    return _p;
}

inline String GLbooleanVecRefMut::toDbgString() const {
    String::Proxy _p(AzGLbooleanVecRefMut_toDbgString(&inner_));
    return _p;
}

inline void GLfloatVecRefMut::delete_() {
    AzGLfloatVecRefMut_delete(&inner_);
}

inline GLfloatVecRefMut GLfloatVecRefMut::clone() const {
    GLfloatVecRefMut::Proxy _p(AzGLfloatVecRefMut_clone(&inner_));
    return _p;
}

inline String GLfloatVecRefMut::toDbgString() const {
    String::Proxy _p(AzGLfloatVecRefMut_toDbgString(&inner_));
    return _p;
}

inline void U8VecRefMut::delete_() {
    AzU8VecRefMut_delete(&inner_);
}

inline U8VecRefMut U8VecRefMut::clone() const {
    U8VecRefMut::Proxy _p(AzU8VecRefMut_clone(&inner_));
    return _p;
}

inline String U8VecRefMut::toDbgString() const {
    String::Proxy _p(AzU8VecRefMut_toDbgString(&inner_));
    return _p;
}

inline void TessellatedSvgNodeVecRef::delete_() {
    AzTessellatedSvgNodeVecRef_delete(&inner_);
}

inline TessellatedSvgNodeVecRef TessellatedSvgNodeVecRef::clone() const {
    TessellatedSvgNodeVecRef::Proxy _p(AzTessellatedSvgNodeVecRef_clone(&inner_));
    return _p;
}

inline String TessellatedSvgNodeVecRef::toDbgString() const {
    String::Proxy _p(AzTessellatedSvgNodeVecRef_toDbgString(&inner_));
    return _p;
}

inline void F32VecRef::delete_() {
    AzF32VecRef_delete(&inner_);
}

inline F32VecRef F32VecRef::clone() const {
    F32VecRef::Proxy _p(AzF32VecRef_clone(&inner_));
    return _p;
}

inline String F32VecRef::toDbgString() const {
    String::Proxy _p(AzF32VecRef_toDbgString(&inner_));
    return _p;
}

inline void GLuintVecRef::delete_() {
    AzGLuintVecRef_delete(&inner_);
}

inline GLuintVecRef GLuintVecRef::clone() const {
    GLuintVecRef::Proxy _p(AzGLuintVecRef_clone(&inner_));
    return _p;
}

inline String GLuintVecRef::toDbgString() const {
    String::Proxy _p(AzGLuintVecRef_toDbgString(&inner_));
    return _p;
}

inline void I32VecRef::delete_() {
    AzI32VecRef_delete(&inner_);
}

inline I32VecRef I32VecRef::clone() const {
    I32VecRef::Proxy _p(AzI32VecRef_clone(&inner_));
    return _p;
}

inline String I32VecRef::toDbgString() const {
    String::Proxy _p(AzI32VecRef_toDbgString(&inner_));
    return _p;
}

inline void U8VecRef::delete_() {
    AzU8VecRef_delete(&inner_);
}

inline U8VecRef U8VecRef::clone() const {
    U8VecRef::Proxy _p(AzU8VecRef_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzU8VecRef_toDbgString(&inner_));
    return _p;
}

inline void GLintVecRefMut::delete_() {
    AzGLintVecRefMut_delete(&inner_);
}

inline GLintVecRefMut GLintVecRefMut::clone() const {
    GLintVecRefMut::Proxy _p(AzGLintVecRefMut_clone(&inner_));
    return _p;
}

inline String GLintVecRefMut::toDbgString() const {
    String::Proxy _p(AzGLintVecRefMut_toDbgString(&inner_));
    return _p;
}

inline void GLenumVecRef::delete_() {
    AzGLenumVecRef_delete(&inner_);
}

inline GLenumVecRef GLenumVecRef::clone() const {
    GLenumVecRef::Proxy _p(AzGLenumVecRef_clone(&inner_));
    return _p;
}

inline String GLenumVecRef::toDbgString() const {
    String::Proxy _p(AzGLenumVecRef_toDbgString(&inner_));
    return _p;
}

inline void GLint64VecRefMut::delete_() {
    AzGLint64VecRefMut_delete(&inner_);
}

inline GLint64VecRefMut GLint64VecRefMut::clone() const {
    GLint64VecRefMut::Proxy _p(AzGLint64VecRefMut_clone(&inner_));
    return _p;
}

inline String GLint64VecRefMut::toDbgString() const {
    String::Proxy _p(AzGLint64VecRefMut_toDbgString(&inner_));
    return _p;
}

inline void RefstrVecRef::delete_() {
    AzRefstrVecRef_delete(&inner_);
}

inline RefstrVecRef RefstrVecRef::clone() const {
    RefstrVecRef::Proxy _p(AzRefstrVecRef_clone(&inner_));
    return _p;
}

inline String RefstrVecRef::toDbgString() const {
    String::Proxy _p(AzRefstrVecRef_toDbgString(&inner_));
    return _p;
}

inline void HttpResponseTooLargeError::delete_() {
    AzHttpResponseTooLargeError_delete(&inner_);
}

inline HttpResponseTooLargeError HttpResponseTooLargeError::clone() const {
    HttpResponseTooLargeError::Proxy _p(AzHttpResponseTooLargeError_clone(&inner_));
    return _p;
}

inline bool HttpResponseTooLargeError::partialEq(const HttpResponseTooLargeError& b) const {
    return AzHttpResponseTooLargeError_partialEq(&inner_, b.ptr());
}

inline String HttpResponseTooLargeError::toDbgString() const {
    String::Proxy _p(AzHttpResponseTooLargeError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzErrorLocation_toDbgString(&inner_));
    return _p;
}

inline bool CssSyntaxErrorPos::partialEq(const CssSyntaxErrorPos& b) const {
    return AzCssSyntaxErrorPos_partialEq(&inner_, b.ptr());
}

inline String CssSyntaxErrorPos::toDbgString() const {
    String::Proxy _p(AzCssSyntaxErrorPos_toDbgString(&inner_));
    return _p;
}

inline App App::create(RefAny initial_data, AppConfig app_config) {
    App::Proxy _p(AzApp_create(initial_data.release(), app_config.release()));
    return _p;
}

inline App App::default_() {
    App::Proxy _p(AzApp_default());
    return _p;
}

inline void App::add_window(WindowCreateOptions create_options) {
    AzApp_addWindow(&inner_, create_options.release());
}

inline MonitorVec App::get_monitors() const {
    MonitorVec::Proxy _p(AzApp_getMonitors(&inner_));
    return _p;
}

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 {
    App::Proxy _p(AzApp_clone(&inner_));
    return _p;
}

inline String App::toDbgString() const {
    String::Proxy _p(AzApp_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTimerId_toDbgString(&inner_));
    return _p;
}

inline Thread Thread::create(RefAny thread_initialize_data, RefAny writeback_data, AzThreadCallbackType callback) {
    Thread::Proxy _p(AzThread_create(thread_initialize_data.release(), writeback_data.release(), callback));
    return _p;
}

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 {
    Thread::Proxy _p(AzThread_clone(&inner_));
    return _p;
}

inline String Thread::toDbgString() const {
    String::Proxy _p(AzThread_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzThreadId_toDbgString(&inner_));
    return _p;
}

inline String TimerIdVecSlice::toDbgString() const {
    String::Proxy _p(AzTimerIdVecSlice_toDbgString(&inner_));
    return _p;
}

inline String ThreadIdVecSlice::toDbgString() const {
    String::Proxy _p(AzThreadIdVecSlice_toDbgString(&inner_));
    return _p;
}

inline String ExternalResourceVecSlice::toDbgString() const {
    String::Proxy _p(AzExternalResourceVecSlice_toDbgString(&inner_));
    return _p;
}

inline String DirEntryVecSlice::toDbgString() const {
    String::Proxy _p(AzDirEntryVecSlice_toDbgString(&inner_));
    return _p;
}

inline String FmtArgVecSlice::toDbgString() const {
    String::Proxy _p(AzFmtArgVecSlice_toDbgString(&inner_));
    return _p;
}

inline String JsonKeyValueVecSlice::toDbgString() const {
    String::Proxy _p(AzJsonKeyValueVecSlice_toDbgString(&inner_));
    return _p;
}

inline String JsonVecSlice::toDbgString() const {
    String::Proxy _p(AzJsonVecSlice_toDbgString(&inner_));
    return _p;
}

inline Db Db::open(String path) {
    Db::Proxy _p(AzDb_open(path.release()));
    return _p;
}

inline Db Db::default_() {
    Db::Proxy _p(AzDb_default());
    return _p;
}

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 {
    DbRows::Proxy _p(AzDb_query(&inner_, sql.release(), params.release()));
    return _p;
}

inline void Db::delete_() {
    AzDb_delete(&inner_);
}

inline Db Db::clone() const {
    Db::Proxy _p(AzDb_clone(&inner_));
    return _p;
}

inline String Db::toDbgString() const {
    String::Proxy _p(AzDb_toDbgString(&inner_));
    return _p;
}

inline Pdf Pdf::new_() {
    return Pdf(AzPdf_new());
}

inline Pdf Pdf::default_() {
    return Pdf(AzPdf_default());
}

inline U8Vec Pdf::write_json(Json json) const {
    U8Vec::Proxy _p(AzPdf_writeJson(&inner_, json.release()));
    return _p;
}

inline Json Pdf::read_json(U8Vec bytes) const {
    Json::Proxy _p(AzPdf_readJson(&inner_, bytes.release()));
    return _p;
}

inline U8Vec Pdf::from_dom(Dom dom, float page_width_px, float page_height_px) const {
    U8Vec::Proxy _p(AzPdf_fromDom(&inner_, dom.release(), page_width_px, page_height_px));
    return _p;
}

inline bool Pdf::partialEq(const Pdf& b) const {
    return AzPdf_partialEq(&inner_, b.ptr());
}

inline String Pdf::toDbgString() const {
    String::Proxy _p(AzPdf_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGamepadId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzWacomPadState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzAudioConfig_toDbgString(&inner_));
    return _p;
}

inline Udp Udp::bind(String local_addr) {
    Udp::Proxy _p(AzUdp_bind(local_addr.release()));
    return _p;
}

inline Udp Udp::default_() {
    Udp::Proxy _p(AzUdp_default());
    return _p;
}

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 {
    String::Proxy _p(AzUdp_localAddr(&inner_));
    return _p;
}

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 {
    Udp::Proxy _p(AzUdp_clone(&inner_));
    return _p;
}

inline String DbValueVecSlice::toDbgString() const {
    String::Proxy _p(AzDbValueVecSlice_toDbgString(&inner_));
    return _p;
}

inline bool IcuDate::partialEq(const IcuDate& b) const {
    return AzIcuDate_partialEq(&inner_, b.ptr());
}

inline String IcuDate::toDbgString() const {
    String::Proxy _p(AzIcuDate_toDbgString(&inner_));
    return _p;
}

inline IcuLocalizerHandle IcuLocalizerHandle::from_system_language(String language) {
    IcuLocalizerHandle::Proxy _p(AzIcuLocalizerHandle_fromSystemLanguage(language.release()));
    return _p;
}

inline IcuLocalizerHandle IcuLocalizerHandle::create(String default_locale) {
    IcuLocalizerHandle::Proxy _p(AzIcuLocalizerHandle_create(default_locale.release()));
    return _p;
}

inline IcuLocalizerHandle IcuLocalizerHandle::default_() {
    IcuLocalizerHandle::Proxy _p(AzIcuLocalizerHandle_default());
    return _p;
}

inline String IcuLocalizerHandle::get_default_locale() const {
    String::Proxy _p(AzIcuLocalizerHandle_getDefaultLocale(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzIcuLocalizerHandle_getLanguage(&inner_, locale.release()));
    return _p;
}

inline String IcuLocalizerHandle::format_integer(String locale, int64_t value) const {
    String::Proxy _p(AzIcuLocalizerHandle_formatInteger(&inner_, locale.release(), value));
    return _p;
}

inline String IcuLocalizerHandle::format_decimal(String locale, int64_t integer_part, int16_t decimal_places) const {
    String::Proxy _p(AzIcuLocalizerHandle_formatDecimal(&inner_, locale.release(), integer_part, decimal_places));
    return _p;
}

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 {
    String::Proxy _p(AzIcuLocalizerHandle_pluralize(&inner_, locale.release(), value, zero.release(), one.release(), two.release(), few.release(), many.release(), other.release()));
    return _p;
}

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 {
    String::Proxy _p(AzIcuLocalizerHandle_formatPlural(&inner_, locale.release(), value, zero.release(), one.release(), other.release()));
    return _p;
}

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 {
    IcuLocalizerHandle::Proxy _p(AzIcuLocalizerHandle_clone(&inner_));
    return _p;
}

inline String IcuLocalizerHandle::toDbgString() const {
    String::Proxy _p(AzIcuLocalizerHandle_toDbgString(&inner_));
    return _p;
}

inline FluentLocalizerHandle FluentLocalizerHandle::create(String default_locale) {
    FluentLocalizerHandle::Proxy _p(AzFluentLocalizerHandle_create(default_locale.release()));
    return _p;
}

inline FluentLocalizerHandle FluentLocalizerHandle::default_() {
    FluentLocalizerHandle::Proxy _p(AzFluentLocalizerHandle_default());
    return _p;
}

inline String FluentLocalizerHandle::get_default_locale() const {
    String::Proxy _p(AzFluentLocalizerHandle_getDefaultLocale(&inner_));
    return _p;
}

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 {
    FluentZipLoadResult::Proxy _p(AzFluentLocalizerHandle_loadFromZip(&inner_, data.release()));
    return _p;
}

inline String FluentLocalizerHandle::translate(String locale, String message_id, FmtArgVec args) const {
    String::Proxy _p(AzFluentLocalizerHandle_translate(&inner_, locale.release(), message_id.release(), args.release()));
    return _p;
}

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 {
    StringVec::Proxy _p(AzFluentLocalizerHandle_getLoadedLocales(&inner_));
    return _p;
}

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 {
    FluentLocalizerHandle::Proxy _p(AzFluentLocalizerHandle_clone(&inner_));
    return _p;
}

inline String FluentLocalizerHandle::toDbgString() const {
    String::Proxy _p(AzFluentLocalizerHandle_toDbgString(&inner_));
    return _p;
}

inline String ComponentDataFieldVecSlice::toDbgString() const {
    String::Proxy _p(AzComponentDataFieldVecSlice_toDbgString(&inner_));
    return _p;
}

inline String ComponentLibraryVecSlice::toDbgString() const {
    String::Proxy _p(AzComponentLibraryVecSlice_toDbgString(&inner_));
    return _p;
}

inline String ComponentDefVecSlice::toDbgString() const {
    String::Proxy _p(AzComponentDefVecSlice_toDbgString(&inner_));
    return _p;
}

inline String ComponentDataModelVecSlice::toDbgString() const {
    String::Proxy _p(AzComponentDataModelVecSlice_toDbgString(&inner_));
    return _p;
}

inline String ComponentEnumVariantVecSlice::toDbgString() const {
    String::Proxy _p(AzComponentEnumVariantVecSlice_toDbgString(&inner_));
    return _p;
}

inline void ComponentFieldTypeBox::delete_() {
    AzComponentFieldTypeBox_delete(&inner_);
}

inline ComponentFieldTypeBox ComponentFieldTypeBox::clone() const {
    ComponentFieldTypeBox::Proxy _p(AzComponentFieldTypeBox_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzComponentFieldTypeBox_toDbgString(&inner_));
    return _p;
}

inline String ComponentEnumModelVecSlice::toDbgString() const {
    String::Proxy _p(AzComponentEnumModelVecSlice_toDbgString(&inner_));
    return _p;
}

inline String ComponentFieldOverrideVecSlice::toDbgString() const {
    String::Proxy _p(AzComponentFieldOverrideVecSlice_toDbgString(&inner_));
    return _p;
}

inline String ComponentCallbackArgVecSlice::toDbgString() const {
    String::Proxy _p(AzComponentCallbackArgVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDpiScaleFactor_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzWindowFlags_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzVideoMode_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTextCursor_toDbgString(&inner_));
    return _p;
}

inline String XWindowTypeVecSlice::toDbgString() const {
    String::Proxy _p(AzXWindowTypeVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTouchPoint_toDbgString(&inner_));
    return _p;
}

inline bool DetectedPinch::partialEq(const DetectedPinch& b) const {
    return AzDetectedPinch_partialEq(&inner_, b.ptr());
}

inline String DetectedPinch::toDbgString() const {
    String::Proxy _p(AzDetectedPinch_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTimerCallbackReturn_toDbgString(&inner_));
    return _p;
}

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) {
    RefAny::Proxy _p(AzRefAny_newC(ptr.release(), len, align, type_id, type_name.release(), destructor, serialize_fn, deserialize_fn));
    return _p;
}

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 {
    RefAny::Proxy _p(AzRefAny_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzRefAny_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzPenState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzScrollState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDomNodeId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzParentWithNodeDepth_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSelectionColor_toDbgString(&inner_));
    return _p;
}

inline String VirtualKeyCodeVecSlice::toDbgString() const {
    String::Proxy _p(AzVirtualKeyCodeVecSlice_toDbgString(&inner_));
    return _p;
}

inline String AccessibilityStateVecSlice::toDbgString() const {
    String::Proxy _p(AzAccessibilityStateVecSlice_toDbgString(&inner_));
    return _p;
}

inline String ScanCodeVecSlice::toDbgString() const {
    String::Proxy _p(AzScanCodeVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzPixelValue_toDbgString(&inner_));
    return _p;
}

inline void StyleColorMatrix::delete_() {
    AzStyleColorMatrix_delete(&inner_);
}

inline StyleColorMatrix StyleColorMatrix::clone() const {
    StyleColorMatrix::Proxy _p(AzStyleColorMatrix_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleColorMatrix_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutFlexGrow_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutFlexShrink_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzPercentageValue_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzAngleValue_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDirectionCorners_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleTransformMatrix2D_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleTransformMatrix3D_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleTransformScale2D_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleTransformScale3D_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleTextColor_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSelectionBackgroundColor_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzColumnRuleColor_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCaretAnimationDuration_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzColumnRuleStyle_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzShapeImageThreshold_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCaretColor_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleExclusionMargin_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleInitialLetter_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzScrollbarColorCustom_toDbgString(&inner_));
    return _p;
}

inline void ShapeInset::delete_() {
    AzShapeInset_delete(&inner_);
}

inline ShapeInset ShapeInset::clone() const {
    ShapeInset::Proxy _p(AzShapeInset_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzShapeInset_toDbgString(&inner_));
    return _p;
}

inline void ShapeEllipse::delete_() {
    AzShapeEllipse_delete(&inner_);
}

inline ShapeEllipse ShapeEllipse::clone() const {
    ShapeEllipse::Proxy _p(AzShapeEllipse_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzShapeEllipse_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutRect_toDbgString(&inner_));
    return _p;
}

inline StyledNode StyledNode::default_() {
    StyledNode::Proxy _p(AzStyledNode_default());
    return _p;
}

inline void StyledNode::delete_() {
    AzStyledNode_delete(&inner_);
}

inline StyledNode StyledNode::clone() const {
    StyledNode::Proxy _p(AzStyledNode_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyledNode_toDbgString(&inner_));
    return _p;
}

inline void ArithmeticCoefficients::delete_() {
    AzArithmeticCoefficients_delete(&inner_);
}

inline ArithmeticCoefficients ArithmeticCoefficients::clone() const {
    ArithmeticCoefficients::Proxy _p(AzArithmeticCoefficients_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzArithmeticCoefficients_toDbgString(&inner_));
    return _p;
}

inline String StyleBackgroundRepeatVecSlice::toDbgString() const {
    String::Proxy _p(AzStyleBackgroundRepeatVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzScrollbarPreferences_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTextRenderingHints_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzAnimationMetrics_toDbgString(&inner_));
    return _p;
}

inline bool CssSyntaxInvalidAdvance::partialEq(const CssSyntaxInvalidAdvance& b) const {
    return AzCssSyntaxInvalidAdvance_partialEq(&inner_, b.ptr());
}

inline String CssSyntaxInvalidAdvance::toDbgString() const {
    String::Proxy _p(AzCssSyntaxInvalidAdvance_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgFillStyle_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOsVersion_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzVisualHints_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleClipRect_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDesktopEnvVersion_toDbgString(&inner_));
    return _p;
}

inline ColorInputState ColorInputState::default_() {
    ColorInputState::Proxy _p(AzColorInputState_default());
    return _p;
}

inline void ColorInputState::delete_() {
    AzColorInputState_delete(&inner_);
}

inline ColorInputState ColorInputState::clone() const {
    ColorInputState::Proxy _p(AzColorInputState_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzColorInputState_toDbgString(&inner_));
    return _p;
}

inline bool OnTextInputReturn::partialEq(const OnTextInputReturn& b) const {
    return AzOnTextInputReturn_partialEq(&inner_, b.ptr());
}

inline String OnTextInputReturn::toDbgString() const {
    String::Proxy _p(AzOnTextInputReturn_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGlShaderPrecisionFormatReturn_toDbgString(&inner_));
    return _p;
}

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 {
    GlVoidPtrMut::Proxy _p(AzGlContextPtr_mapBuffer(&inner_, target, access));
    return _p;
}

inline GlVoidPtrMut GlContextPtr::map_buffer_range(AzGLenum target, AzGLintptr offset, AzGLsizeiptr length, AzGLbitfield access) const {
    GlVoidPtrMut::Proxy _p(AzGlContextPtr_mapBufferRange(&inner_, target, offset, length, access));
    return _p;
}

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 {
    U8Vec::Proxy _p(AzGlContextPtr_readPixels(&inner_, x, y, width, height, format, pixel_type));
    return _p;
}

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 {
    GLuintVec::Proxy _p(AzGlContextPtr_genBuffers(&inner_, n));
    return _p;
}

inline GLuintVec GlContextPtr::gen_renderbuffers(AzGLsizei n) const {
    GLuintVec::Proxy _p(AzGlContextPtr_genRenderbuffers(&inner_, n));
    return _p;
}

inline GLuintVec GlContextPtr::gen_framebuffers(AzGLsizei n) const {
    GLuintVec::Proxy _p(AzGlContextPtr_genFramebuffers(&inner_, n));
    return _p;
}

inline GLuintVec GlContextPtr::gen_textures(AzGLsizei n) const {
    GLuintVec::Proxy _p(AzGlContextPtr_genTextures(&inner_, n));
    return _p;
}

inline GLuintVec GlContextPtr::gen_vertex_arrays(AzGLsizei n) const {
    GLuintVec::Proxy _p(AzGlContextPtr_genVertexArrays(&inner_, n));
    return _p;
}

inline GLuintVec GlContextPtr::gen_queries(AzGLsizei n) const {
    GLuintVec::Proxy _p(AzGlContextPtr_genQueries(&inner_, n));
    return _p;
}

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 {
    GetActiveAttribReturn::Proxy _p(AzGlContextPtr_getActiveAttrib(&inner_, program, index));
    return _p;
}

inline GetActiveUniformReturn GlContextPtr::get_active_uniform(AzGLuint program, AzGLuint index) const {
    GetActiveUniformReturn::Proxy _p(AzGlContextPtr_getActiveUniform(&inner_, program, index));
    return _p;
}

inline GLintVec GlContextPtr::get_active_uniforms_iv(AzGLuint program, GLuintVec indices, AzGLenum pname) const {
    GLintVec::Proxy _p(AzGlContextPtr_getActiveUniformsIv(&inner_, program, indices.release(), pname));
    return _p;
}

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 {
    GLintVec::Proxy _p(AzGlContextPtr_getActiveUniformBlockIv(&inner_, program, index, pname));
    return _p;
}

inline String GlContextPtr::get_active_uniform_block_name(AzGLuint program, AzGLuint index) const {
    String::Proxy _p(AzGlContextPtr_getActiveUniformBlockName(&inner_, program, index));
    return _p;
}

inline String GlContextPtr::get_program_info_log(AzGLuint program) const {
    String::Proxy _p(AzGlContextPtr_getProgramInfoLog(&inner_, program));
    return _p;
}

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 {
    GetProgramBinaryReturn::Proxy _p(AzGlContextPtr_getProgramBinary(&inner_, program));
    return _p;
}

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 {
    String::Proxy _p(AzGlContextPtr_getShaderInfoLog(&inner_, shader));
    return _p;
}

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 {
    GLsyncPtr::Proxy _p(AzGlContextPtr_fenceSync(&inner_, condition, flags));
    return _p;
}

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 {
    GLuintVec::Proxy _p(AzGlContextPtr_genFencesApple(&inner_, n));
    return _p;
}

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 {
    DebugMessageVec::Proxy _p(AzGlContextPtr_getDebugMessages(&inner_));
    return _p;
}

inline void GlContextPtr::provoking_vertex_angle(AzGLenum mode) const {
    AzGlContextPtr_provokingVertexAngle(&inner_, mode);
}

inline GLuintVec GlContextPtr::gen_vertex_arrays_apple(AzGLsizei n) const {
    GLuintVec::Proxy _p(AzGlContextPtr_genVertexArraysApple(&inner_, n));
    return _p;
}

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 {
    GLuintVec::Proxy _p(AzGlContextPtr_getUniformIndices(&inner_, program, names.release()));
    return _p;
}

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 {
    String::Proxy _p(AzGlContextPtr_getString(&inner_, which));
    return _p;
}

inline String GlContextPtr::get_string_i(AzGLenum which, AzGLuint index) const {
    String::Proxy _p(AzGlContextPtr_getStringI(&inner_, which, index));
    return _p;
}

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 {
    GlContextPtr::Proxy _p(AzGlContextPtr_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGlContextPtr_toDbgString(&inner_));
    return _p;
}

inline String GLuintVecSlice::toDbgString() const {
    String::Proxy _p(AzGLuintVecSlice_toDbgString(&inner_));
    return _p;
}

inline String GLintVecSlice::toDbgString() const {
    String::Proxy _p(AzGLintVecSlice_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzImageDescriptor_toDbgString(&inner_));
    return _p;
}

inline FontMetrics FontMetrics::zero() {
    FontMetrics::Proxy _p(AzFontMetrics_zero());
    return _p;
}

inline FontMetrics FontMetrics::default_() {
    FontMetrics::Proxy _p(AzFontMetrics_default());
    return _p;
}

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 {
    FontMetrics::Proxy _p(AzFontMetrics_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzFontMetrics_toDbgString(&inner_));
    return _p;
}

inline FontRef FontRef::create(const void* parsed, AzFontRefDestructorCallbackType destructor) {
    FontRef::Proxy _p(AzFontRef_create(parsed, destructor));
    return _p;
}

inline OptionFontRef FontRef::parse(LoadedFontSource source) {
    return OptionFontRef(AzFontRef_parse(source.release()));
}

inline U8Vec FontRef::get_bytes() const {
    U8Vec::Proxy _p(AzFontRef_getBytes(&inner_));
    return _p;
}

inline FontMetrics FontRef::get_font_metrics() const {
    FontMetrics::Proxy _p(AzFontRef_getFontMetrics(&inner_));
    return _p;
}

inline uint64_t FontRef::get_hash() const {
    return AzFontRef_getHash(&inner_);
}

inline void FontRef::delete_() {
    AzFontRef_delete(&inner_);
}

inline FontRef FontRef::clone() const {
    FontRef::Proxy _p(AzFontRef_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzFontRef_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLogicalRect_toDbgString(&inner_));
    return _p;
}

inline void ShapeCircle::delete_() {
    AzShapeCircle_delete(&inner_);
}

inline ShapeCircle ShapeCircle::clone() const {
    ShapeCircle::Proxy _p(AzShapeCircle_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzShapeCircle_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgLine_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgCubicCurve_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgQuadraticCurve_toDbgString(&inner_));
    return _p;
}

inline void GetSystemTimeCallback::delete_() {
    AzGetSystemTimeCallback_delete(&inner_);
}

inline GetSystemTimeCallback GetSystemTimeCallback::clone() const {
    GetSystemTimeCallback::Proxy _p(AzGetSystemTimeCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGetSystemTimeCallback_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzScrollIntoViewOptions_toDbgString(&inner_));
    return _p;
}

inline void NonXmlCharError::delete_() {
    AzNonXmlCharError_delete(&inner_);
}

inline NonXmlCharError NonXmlCharError::clone() const {
    NonXmlCharError::Proxy _p(AzNonXmlCharError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNonXmlCharError_toDbgString(&inner_));
    return _p;
}

inline void InvalidCharError::delete_() {
    AzInvalidCharError_delete(&inner_);
}

inline InvalidCharError InvalidCharError::clone() const {
    InvalidCharError::Proxy _p(AzInvalidCharError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzInvalidCharError_toDbgString(&inner_));
    return _p;
}

inline void InvalidQuoteError::delete_() {
    AzInvalidQuoteError_delete(&inner_);
}

inline InvalidQuoteError InvalidQuoteError::clone() const {
    InvalidQuoteError::Proxy _p(AzInvalidQuoteError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzInvalidQuoteError_toDbgString(&inner_));
    return _p;
}

inline void InvalidSpaceError::delete_() {
    AzInvalidSpaceError_delete(&inner_);
}

inline InvalidSpaceError InvalidSpaceError::clone() const {
    InvalidSpaceError::Proxy _p(AzInvalidSpaceError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzInvalidSpaceError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzErrorLocationRange_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzRendererOptions_toDbgString(&inner_));
    return _p;
}

inline void FileMetadata::delete_() {
    AzFileMetadata_delete(&inner_);
}

inline FileMetadata FileMetadata::clone() const {
    FileMetadata::Proxy _p(AzFileMetadata_clone(&inner_));
    return _p;
}

inline bool FileMetadata::partialEq(const FileMetadata& b) const {
    return AzFileMetadata_partialEq(&inner_, b.ptr());
}

inline String FileMetadata::toDbgString() const {
    String::Proxy _p(AzFileMetadata_toDbgString(&inner_));
    return _p;
}

inline bool SensorReading::partialEq(const SensorReading& b) const {
    return AzSensorReading_partialEq(&inner_, b.ptr());
}

inline String SensorReading::toDbgString() const {
    String::Proxy _p(AzSensorReading_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGamepadState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCameraConfig_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzScreenCaptureConfig_toDbgString(&inner_));
    return _p;
}

inline bool DetectedRotation::partialEq(const DetectedRotation& b) const {
    return AzDetectedRotation_partialEq(&inner_, b.ptr());
}

inline String DetectedRotation::toDbgString() const {
    String::Proxy _p(AzDetectedRotation_toDbgString(&inner_));
    return _p;
}

inline bool DetectedLongPress::partialEq(const DetectedLongPress& b) const {
    return AzDetectedLongPress_partialEq(&inner_, b.ptr());
}

inline String DetectedLongPress::toDbgString() const {
    String::Proxy _p(AzDetectedLongPress_toDbgString(&inner_));
    return _p;
}

inline bool IcuDateTime::partialEq(const IcuDateTime& b) const {
    return AzIcuDateTime_partialEq(&inner_, b.ptr());
}

inline String IcuDateTime::toDbgString() const {
    String::Proxy _p(AzIcuDateTime_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzHidpiAdjustedBounds_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzWindowSize_toDbgString(&inner_));
    return _p;
}

inline void TextOpMoveCursor::delete_() {
    AzTextOpMoveCursor_delete(&inner_);
}

inline TextOpMoveCursor TextOpMoveCursor::clone() const {
    TextOpMoveCursor::Proxy _p(AzTextOpMoveCursor_clone(&inner_));
    return _p;
}

inline String TextOpMoveCursor::toDbgString() const {
    String::Proxy _p(AzTextOpMoveCursor_toDbgString(&inner_));
    return _p;
}

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 {
    KeyboardState::Proxy _p(AzCallbackInfo_getCurrentKeyboardState(&inner_));
    return _p;
}

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 {
    MonitorVec::Proxy _p(AzCallbackInfo_getMonitors(&inner_));
    return _p;
}

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 {
    TimerIdVec::Proxy _p(AzCallbackInfo_getTimerIds(&inner_));
    return _p;
}

inline OptionThread CallbackInfo::get_thread(ThreadId thread_id) const {
    return OptionThread(AzCallbackInfo_getThread(&inner_, thread_id.release()));
}

inline ThreadIdVec CallbackInfo::get_thread_ids() const {
    ThreadIdVec::Proxy _p(AzCallbackInfo_getThreadIds(&inner_));
    return _p;
}

inline DomIdVec CallbackInfo::get_dom_ids() const {
    DomIdVec::Proxy _p(AzCallbackInfo_getDomIds(&inner_));
    return _p;
}

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 {
    SelectionRangeVec::Proxy _p(AzCallbackInfo_getSelectionRanges(&inner_, dom_id.release()));
    return _p;
}

inline FullWindowState CallbackInfo::get_current_window_state() const {
    FullWindowState::Proxy _p(AzCallbackInfo_getCurrentWindowState(&inner_));
    return _p;
}

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 {
    GetSystemTimeCallback::Proxy _p(AzCallbackInfo_getSystemTimeFn(&inner_));
    return _p;
}

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 {
    SelectionRangeVec::Proxy _p(AzCallbackInfo_getNodeSelectionRanges(&inner_, target.release()));
    return _p;
}

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 {
    NodeHierarchyItemIdVec::Proxy _p(AzCallbackInfo_getAllChildrenNodes(&inner_, dom_id.release(), node_id.release()));
    return _p;
}

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 {
    StringVec::Proxy _p(AzCallbackInfo_getNodeClasses(&inner_, node_id.release()));
    return _p;
}

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 {
    StringVec::Proxy _p(AzCallbackInfo_getDragTypes(&inner_));
    return _p;
}

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 {
    LoadedFontVec::Proxy _p(AzCallbackInfo_getLoadedFonts(&inner_));
    return _p;
}

inline OptionU8Vec CallbackInfo::get_loaded_font_bytes(uint64_t font_hash) const {
    return OptionU8Vec(AzCallbackInfo_getLoadedFontBytes(&inner_, font_hash));
}

inline String CallbackInfo::toDbgString() const {
    String::Proxy _p(AzCallbackInfo_toDbgString(&inner_));
    return _p;
}

inline void TagIdToNodeIdMapping::delete_() {
    AzTagIdToNodeIdMapping_delete(&inner_);
}

inline TagIdToNodeIdMapping TagIdToNodeIdMapping::clone() const {
    TagIdToNodeIdMapping::Proxy _p(AzTagIdToNodeIdMapping_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTagIdToNodeIdMapping_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMouseState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSelectionRange_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSelectionRadius_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzPixelValueSize_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzPixelValueNoPercent_toDbgString(&inner_));
    return _p;
}

inline StyleBlur StyleBlur::default_() {
    StyleBlur::Proxy _p(AzStyleBlur_default());
    return _p;
}

inline void StyleBlur::delete_() {
    AzStyleBlur_delete(&inner_);
}

inline StyleBlur StyleBlur::clone() const {
    StyleBlur::Proxy _p(AzStyleBlur_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleBlur_toDbgString(&inner_));
    return _p;
}

inline StyleFilterOffset StyleFilterOffset::default_() {
    StyleFilterOffset::Proxy _p(AzStyleFilterOffset_default());
    return _p;
}

inline void StyleFilterOffset::delete_() {
    AzStyleFilterOffset_delete(&inner_);
}

inline StyleFilterOffset StyleFilterOffset::clone() const {
    StyleFilterOffset::Proxy _p(AzStyleFilterOffset_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleFilterOffset_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutMarginBottom_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutMarginLeft_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutMarginRight_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutMarginTop_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutMaxHeight_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutMaxWidth_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutMinHeight_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutMinWidth_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutPaddingBottom_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutPaddingLeft_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutPaddingRight_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutPaddingTop_toDbgString(&inner_));
    return _p;
}

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 {
    NormalizedLinearColorStop::Proxy _p(AzNormalizedLinearColorStop_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNormalizedLinearColorStop_toDbgString(&inner_));
    return _p;
}

inline void NormalizedRadialColorStop::delete_() {
    AzNormalizedRadialColorStop_delete(&inner_);
}

inline NormalizedRadialColorStop NormalizedRadialColorStop::clone() const {
    NormalizedRadialColorStop::Proxy _p(AzNormalizedRadialColorStop_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNormalizedRadialColorStop_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleFontSize_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleLetterSpacing_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleTransformOrigin_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleTransformTranslate2D_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleTransformTranslate3D_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleTransformRotate3D_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleTransformSkew2D_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleWordSpacing_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStylePerspectiveOrigin_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutGap_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzShapeMargin_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzColumnRuleWidth_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleTextIndent_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutBorderSpacing_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutPaddingInlineStart_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutColumnGap_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutPaddingInlineEnd_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutRowGap_toDbgString(&inner_));
    return _p;
}

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_() {
    SystemColors::Proxy _p(AzSystemColors_default());
    return _p;
}

inline void SystemColors::delete_() {
    AzSystemColors_delete(&inner_);
}

inline SystemColors SystemColors::clone() const {
    SystemColors::Proxy _p(AzSystemColors_clone(&inner_));
    return _p;
}

inline bool SystemColors::partialEq(const SystemColors& b) const {
    return AzSystemColors_partialEq(&inner_, b.ptr());
}

inline String SystemColors::toDbgString() const {
    String::Proxy _p(AzSystemColors_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCaretWidth_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleTabSize_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleOverflowClipMargin_toDbgString(&inner_));
    return _p;
}

inline Texture Texture::create(AzGLuint texture_id, TextureFlags flags, AzPhysicalSizeU32 size, ColorU background_color, GlContextPtr gl_context, AzRawImageFormat format) {
    Texture::Proxy _p(AzTexture_create(texture_id, flags.release(), size, background_color.release(), gl_context.release(), format));
    return _p;
}

inline Texture Texture::allocate_rgba8(GlContextPtr gl_context, AzPhysicalSizeU32 size, ColorU background) {
    Texture::Proxy _p(AzTexture_allocateRgba8(gl_context.release(), size, background.release()));
    return _p;
}

inline Texture Texture::allocate_clip_mask(GlContextPtr gl, AzPhysicalSizeU32 size, ColorU background) {
    Texture::Proxy _p(AzTexture_allocateClipMask(gl.release(), size, background.release()));
    return _p;
}

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 {
    Texture::Proxy _p(AzTexture_clone(&inner_));
    return _p;
}

inline void ImageMask::delete_() {
    AzImageMask_delete(&inner_);
}

inline ImageMask ImageMask::clone() const {
    ImageMask::Proxy _p(AzImageMask_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzImageMask_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgStrokeStyle_toDbgString(&inner_));
    return _p;
}

inline void InstantPtr::delete_() {
    AzInstantPtr_delete(&inner_);
}

inline InstantPtr InstantPtr::clone() const {
    InstantPtr::Proxy _p(AzInstantPtr_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzInstantPtr_toDbgString(&inner_));
    return _p;
}

inline ListViewRowVec ListViewRowVec::create() {
    ListViewRowVec::Proxy _p(AzListViewRowVec_create());
    return _p;
}

inline ListViewRowVec ListViewRowVec::with_capacity(size_t cap) {
    ListViewRowVec::Proxy _p(AzListViewRowVec_withCapacity(cap));
    return _p;
}

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) {
    ListViewRowVec::Proxy _p(AzListViewRowVec_fromItem(item.release()));
    return _p;
}

inline ListViewRowVec ListViewRowVec::copy_from_ptr(const ListViewRow& ptr, size_t len) {
    ListViewRowVec::Proxy _p(AzListViewRowVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ListViewRowVec::Proxy _p(AzListViewRowVec_clone(&inner_));
    return _p;
}

inline String ListViewRowVec::toDbgString() const {
    String::Proxy _p(AzListViewRowVec_toDbgString(&inner_));
    return _p;
}

inline StyleFilterVec StyleFilterVec::create() {
    StyleFilterVec::Proxy _p(AzStyleFilterVec_create());
    return _p;
}

inline StyleFilterVec StyleFilterVec::with_capacity(size_t cap) {
    StyleFilterVec::Proxy _p(AzStyleFilterVec_withCapacity(cap));
    return _p;
}

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) {
    StyleFilterVec::Proxy _p(AzStyleFilterVec_fromItem(item));
    return _p;
}

inline StyleFilterVec StyleFilterVec::copy_from_ptr(const AzStyleFilter* ptr, size_t len) {
    StyleFilterVec::Proxy _p(AzStyleFilterVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    StyleFilterVec::Proxy _p(AzStyleFilterVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleFilterVec_toDbgString(&inner_));
    return _p;
}

inline AccessibilityStateVec AccessibilityStateVec::create() {
    AccessibilityStateVec::Proxy _p(AzAccessibilityStateVec_create());
    return _p;
}

inline AccessibilityStateVec AccessibilityStateVec::with_capacity(size_t cap) {
    AccessibilityStateVec::Proxy _p(AzAccessibilityStateVec_withCapacity(cap));
    return _p;
}

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) {
    AccessibilityStateVec::Proxy _p(AzAccessibilityStateVec_fromItem(item));
    return _p;
}

inline AccessibilityStateVec AccessibilityStateVec::copy_from_ptr(const AzAccessibilityState* ptr, size_t len) {
    AccessibilityStateVec::Proxy _p(AzAccessibilityStateVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    AccessibilityStateVec::Proxy _p(AzAccessibilityStateVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzAccessibilityStateVec_toDbgString(&inner_));
    return _p;
}

inline MenuItemVec MenuItemVec::create() {
    MenuItemVec::Proxy _p(AzMenuItemVec_create());
    return _p;
}

inline MenuItemVec MenuItemVec::with_capacity(size_t cap) {
    MenuItemVec::Proxy _p(AzMenuItemVec_withCapacity(cap));
    return _p;
}

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) {
    MenuItemVec::Proxy _p(AzMenuItemVec_fromItem(item));
    return _p;
}

inline MenuItemVec MenuItemVec::copy_from_ptr(const AzMenuItem* ptr, size_t len) {
    MenuItemVec::Proxy _p(AzMenuItemVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    MenuItemVec::Proxy _p(AzMenuItemVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMenuItemVec_toDbgString(&inner_));
    return _p;
}

inline StyleFontFamilyVec StyleFontFamilyVec::create() {
    StyleFontFamilyVec::Proxy _p(AzStyleFontFamilyVec_create());
    return _p;
}

inline StyleFontFamilyVec StyleFontFamilyVec::with_capacity(size_t cap) {
    StyleFontFamilyVec::Proxy _p(AzStyleFontFamilyVec_withCapacity(cap));
    return _p;
}

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) {
    StyleFontFamilyVec::Proxy _p(AzStyleFontFamilyVec_fromItem(item));
    return _p;
}

inline StyleFontFamilyVec StyleFontFamilyVec::copy_from_ptr(const AzStyleFontFamily* ptr, size_t len) {
    StyleFontFamilyVec::Proxy _p(AzStyleFontFamilyVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    StyleFontFamilyVec::Proxy _p(AzStyleFontFamilyVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleFontFamilyVec_toDbgString(&inner_));
    return _p;
}

inline DomVec DomVec::create() {
    DomVec::Proxy _p(AzDomVec_create());
    return _p;
}

inline DomVec DomVec::with_capacity(size_t cap) {
    DomVec::Proxy _p(AzDomVec_withCapacity(cap));
    return _p;
}

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) {
    DomVec::Proxy _p(AzDomVec_fromItem(item.release()));
    return _p;
}

inline DomVec DomVec::copy_from_ptr(const Dom& ptr, size_t len) {
    DomVec::Proxy _p(AzDomVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    DomVec::Proxy _p(AzDomVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDomVec_toDbgString(&inner_));
    return _p;
}

inline IdOrClassVec IdOrClassVec::create() {
    IdOrClassVec::Proxy _p(AzIdOrClassVec_create());
    return _p;
}

inline IdOrClassVec IdOrClassVec::with_capacity(size_t cap) {
    IdOrClassVec::Proxy _p(AzIdOrClassVec_withCapacity(cap));
    return _p;
}

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) {
    IdOrClassVec::Proxy _p(AzIdOrClassVec_fromItem(item));
    return _p;
}

inline IdOrClassVec IdOrClassVec::copy_from_ptr(const AzIdOrClass* ptr, size_t len) {
    IdOrClassVec::Proxy _p(AzIdOrClassVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    IdOrClassVec::Proxy _p(AzIdOrClassVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzIdOrClassVec_toDbgString(&inner_));
    return _p;
}

inline DynamicSelectorVec DynamicSelectorVec::create() {
    DynamicSelectorVec::Proxy _p(AzDynamicSelectorVec_create());
    return _p;
}

inline DynamicSelectorVec DynamicSelectorVec::with_capacity(size_t cap) {
    DynamicSelectorVec::Proxy _p(AzDynamicSelectorVec_withCapacity(cap));
    return _p;
}

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) {
    DynamicSelectorVec::Proxy _p(AzDynamicSelectorVec_fromItem(item));
    return _p;
}

inline DynamicSelectorVec DynamicSelectorVec::copy_from_ptr(const AzDynamicSelector* ptr, size_t len) {
    DynamicSelectorVec::Proxy _p(AzDynamicSelectorVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    DynamicSelectorVec::Proxy _p(AzDynamicSelectorVec_clone(&inner_));
    return _p;
}

inline bool DynamicSelectorVec::partialEq(const DynamicSelectorVec& b) const {
    return AzDynamicSelectorVec_partialEq(&inner_, b.ptr());
}

inline String DynamicSelectorVec::toDbgString() const {
    String::Proxy _p(AzDynamicSelectorVec_toDbgString(&inner_));
    return _p;
}

inline CssPropertyWithConditionsVec CssPropertyWithConditionsVec::create() {
    CssPropertyWithConditionsVec::Proxy _p(AzCssPropertyWithConditionsVec_create());
    return _p;
}

inline CssPropertyWithConditionsVec CssPropertyWithConditionsVec::with_capacity(size_t cap) {
    CssPropertyWithConditionsVec::Proxy _p(AzCssPropertyWithConditionsVec_withCapacity(cap));
    return _p;
}

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) {
    CssPropertyWithConditionsVec::Proxy _p(AzCssPropertyWithConditionsVec_fromItem(item.release()));
    return _p;
}

inline CssPropertyWithConditionsVec CssPropertyWithConditionsVec::copy_from_ptr(const CssPropertyWithConditions& ptr, size_t len) {
    CssPropertyWithConditionsVec::Proxy _p(AzCssPropertyWithConditionsVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    CssPropertyWithConditionsVec::Proxy _p(AzCssPropertyWithConditionsVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCssPropertyWithConditionsVec_toDbgString(&inner_));
    return _p;
}

inline StyleBackgroundContentVec StyleBackgroundContentVec::create() {
    StyleBackgroundContentVec::Proxy _p(AzStyleBackgroundContentVec_create());
    return _p;
}

inline StyleBackgroundContentVec StyleBackgroundContentVec::with_capacity(size_t cap) {
    StyleBackgroundContentVec::Proxy _p(AzStyleBackgroundContentVec_withCapacity(cap));
    return _p;
}

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) {
    StyleBackgroundContentVec::Proxy _p(AzStyleBackgroundContentVec_fromItem(item));
    return _p;
}

inline StyleBackgroundContentVec StyleBackgroundContentVec::copy_from_ptr(const AzStyleBackgroundContent* ptr, size_t len) {
    StyleBackgroundContentVec::Proxy _p(AzStyleBackgroundContentVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    StyleBackgroundContentVec::Proxy _p(AzStyleBackgroundContentVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleBackgroundContentVec_toDbgString(&inner_));
    return _p;
}

inline StyleBackgroundPositionVec StyleBackgroundPositionVec::create() {
    StyleBackgroundPositionVec::Proxy _p(AzStyleBackgroundPositionVec_create());
    return _p;
}

inline StyleBackgroundPositionVec StyleBackgroundPositionVec::with_capacity(size_t cap) {
    StyleBackgroundPositionVec::Proxy _p(AzStyleBackgroundPositionVec_withCapacity(cap));
    return _p;
}

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) {
    StyleBackgroundPositionVec::Proxy _p(AzStyleBackgroundPositionVec_fromItem(item.release()));
    return _p;
}

inline StyleBackgroundPositionVec StyleBackgroundPositionVec::copy_from_ptr(const StyleBackgroundPosition& ptr, size_t len) {
    StyleBackgroundPositionVec::Proxy _p(AzStyleBackgroundPositionVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    StyleBackgroundPositionVec::Proxy _p(AzStyleBackgroundPositionVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleBackgroundPositionVec_toDbgString(&inner_));
    return _p;
}

inline StyleBackgroundRepeatVec StyleBackgroundRepeatVec::create() {
    StyleBackgroundRepeatVec::Proxy _p(AzStyleBackgroundRepeatVec_create());
    return _p;
}

inline StyleBackgroundRepeatVec StyleBackgroundRepeatVec::with_capacity(size_t cap) {
    StyleBackgroundRepeatVec::Proxy _p(AzStyleBackgroundRepeatVec_withCapacity(cap));
    return _p;
}

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) {
    StyleBackgroundRepeatVec::Proxy _p(AzStyleBackgroundRepeatVec_fromItem(item));
    return _p;
}

inline StyleBackgroundRepeatVec StyleBackgroundRepeatVec::copy_from_ptr(const AzStyleBackgroundRepeat* ptr, size_t len) {
    StyleBackgroundRepeatVec::Proxy _p(AzStyleBackgroundRepeatVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    StyleBackgroundRepeatVec::Proxy _p(AzStyleBackgroundRepeatVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleBackgroundRepeatVec_toDbgString(&inner_));
    return _p;
}

inline StyleBackgroundSizeVec StyleBackgroundSizeVec::create() {
    StyleBackgroundSizeVec::Proxy _p(AzStyleBackgroundSizeVec_create());
    return _p;
}

inline StyleBackgroundSizeVec StyleBackgroundSizeVec::with_capacity(size_t cap) {
    StyleBackgroundSizeVec::Proxy _p(AzStyleBackgroundSizeVec_withCapacity(cap));
    return _p;
}

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) {
    StyleBackgroundSizeVec::Proxy _p(AzStyleBackgroundSizeVec_fromItem(item));
    return _p;
}

inline StyleBackgroundSizeVec StyleBackgroundSizeVec::copy_from_ptr(const AzStyleBackgroundSize* ptr, size_t len) {
    StyleBackgroundSizeVec::Proxy _p(AzStyleBackgroundSizeVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    StyleBackgroundSizeVec::Proxy _p(AzStyleBackgroundSizeVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleBackgroundSizeVec_toDbgString(&inner_));
    return _p;
}

inline StyleTransformVec StyleTransformVec::create() {
    StyleTransformVec::Proxy _p(AzStyleTransformVec_create());
    return _p;
}

inline StyleTransformVec StyleTransformVec::with_capacity(size_t cap) {
    StyleTransformVec::Proxy _p(AzStyleTransformVec_withCapacity(cap));
    return _p;
}

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) {
    StyleTransformVec::Proxy _p(AzStyleTransformVec_fromItem(item));
    return _p;
}

inline StyleTransformVec StyleTransformVec::copy_from_ptr(const AzStyleTransform* ptr, size_t len) {
    StyleTransformVec::Proxy _p(AzStyleTransformVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    StyleTransformVec::Proxy _p(AzStyleTransformVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleTransformVec_toDbgString(&inner_));
    return _p;
}

inline SvgVertexVec SvgVertexVec::create() {
    SvgVertexVec::Proxy _p(AzSvgVertexVec_create());
    return _p;
}

inline SvgVertexVec SvgVertexVec::with_capacity(size_t cap) {
    SvgVertexVec::Proxy _p(AzSvgVertexVec_withCapacity(cap));
    return _p;
}

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) {
    SvgVertexVec::Proxy _p(AzSvgVertexVec_fromItem(item.release()));
    return _p;
}

inline SvgVertexVec SvgVertexVec::copy_from_ptr(const SvgVertex& ptr, size_t len) {
    SvgVertexVec::Proxy _p(AzSvgVertexVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    SvgVertexVec::Proxy _p(AzSvgVertexVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgVertexVec_toDbgString(&inner_));
    return _p;
}

inline U32Vec U32Vec::create() {
    U32Vec::Proxy _p(AzU32Vec_create());
    return _p;
}

inline U32Vec U32Vec::with_capacity(size_t cap) {
    U32Vec::Proxy _p(AzU32Vec_withCapacity(cap));
    return _p;
}

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) {
    U32Vec::Proxy _p(AzU32Vec_fromItem(item));
    return _p;
}

inline U32Vec U32Vec::copy_from_ptr(const uint32_t* ptr, size_t len) {
    U32Vec::Proxy _p(AzU32Vec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    U32Vec::Proxy _p(AzU32Vec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzU32Vec_toDbgString(&inner_));
    return _p;
}

inline VirtualKeyCodeVec VirtualKeyCodeVec::create() {
    VirtualKeyCodeVec::Proxy _p(AzVirtualKeyCodeVec_create());
    return _p;
}

inline VirtualKeyCodeVec VirtualKeyCodeVec::with_capacity(size_t cap) {
    VirtualKeyCodeVec::Proxy _p(AzVirtualKeyCodeVec_withCapacity(cap));
    return _p;
}

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) {
    VirtualKeyCodeVec::Proxy _p(AzVirtualKeyCodeVec_fromItem(item));
    return _p;
}

inline VirtualKeyCodeVec VirtualKeyCodeVec::copy_from_ptr(const AzVirtualKeyCode* ptr, size_t len) {
    VirtualKeyCodeVec::Proxy _p(AzVirtualKeyCodeVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    VirtualKeyCodeVec::Proxy _p(AzVirtualKeyCodeVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzVirtualKeyCodeVec_toDbgString(&inner_));
    return _p;
}

inline CascadeInfoVec CascadeInfoVec::create() {
    CascadeInfoVec::Proxy _p(AzCascadeInfoVec_create());
    return _p;
}

inline CascadeInfoVec CascadeInfoVec::with_capacity(size_t cap) {
    CascadeInfoVec::Proxy _p(AzCascadeInfoVec_withCapacity(cap));
    return _p;
}

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) {
    CascadeInfoVec::Proxy _p(AzCascadeInfoVec_fromItem(item.release()));
    return _p;
}

inline CascadeInfoVec CascadeInfoVec::copy_from_ptr(const CascadeInfo& ptr, size_t len) {
    CascadeInfoVec::Proxy _p(AzCascadeInfoVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    CascadeInfoVec::Proxy _p(AzCascadeInfoVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCascadeInfoVec_toDbgString(&inner_));
    return _p;
}

inline CssDeclarationVec CssDeclarationVec::create() {
    CssDeclarationVec::Proxy _p(AzCssDeclarationVec_create());
    return _p;
}

inline CssDeclarationVec CssDeclarationVec::with_capacity(size_t cap) {
    CssDeclarationVec::Proxy _p(AzCssDeclarationVec_withCapacity(cap));
    return _p;
}

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) {
    CssDeclarationVec::Proxy _p(AzCssDeclarationVec_fromItem(item));
    return _p;
}

inline CssDeclarationVec CssDeclarationVec::copy_from_ptr(const AzCssDeclaration* ptr, size_t len) {
    CssDeclarationVec::Proxy _p(AzCssDeclarationVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    CssDeclarationVec::Proxy _p(AzCssDeclarationVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCssDeclarationVec_toDbgString(&inner_));
    return _p;
}

inline CssPathSelectorVec CssPathSelectorVec::create() {
    CssPathSelectorVec::Proxy _p(AzCssPathSelectorVec_create());
    return _p;
}

inline CssPathSelectorVec CssPathSelectorVec::with_capacity(size_t cap) {
    CssPathSelectorVec::Proxy _p(AzCssPathSelectorVec_withCapacity(cap));
    return _p;
}

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) {
    CssPathSelectorVec::Proxy _p(AzCssPathSelectorVec_fromItem(item));
    return _p;
}

inline CssPathSelectorVec CssPathSelectorVec::copy_from_ptr(const AzCssPathSelector* ptr, size_t len) {
    CssPathSelectorVec::Proxy _p(AzCssPathSelectorVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    CssPathSelectorVec::Proxy _p(AzCssPathSelectorVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCssPathSelectorVec_toDbgString(&inner_));
    return _p;
}

inline CssVec CssVec::create() {
    CssVec::Proxy _p(AzCssVec_create());
    return _p;
}

inline CssVec CssVec::with_capacity(size_t cap) {
    CssVec::Proxy _p(AzCssVec_withCapacity(cap));
    return _p;
}

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) {
    CssVec::Proxy _p(AzCssVec_fromItem(item.release()));
    return _p;
}

inline CssVec CssVec::copy_from_ptr(const Css& ptr, size_t len) {
    CssVec::Proxy _p(AzCssVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    CssVec::Proxy _p(AzCssVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCssVec_toDbgString(&inner_));
    return _p;
}

inline CssRuleBlockVec CssRuleBlockVec::create() {
    CssRuleBlockVec::Proxy _p(AzCssRuleBlockVec_create());
    return _p;
}

inline CssRuleBlockVec CssRuleBlockVec::with_capacity(size_t cap) {
    CssRuleBlockVec::Proxy _p(AzCssRuleBlockVec_withCapacity(cap));
    return _p;
}

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) {
    CssRuleBlockVec::Proxy _p(AzCssRuleBlockVec_fromItem(item.release()));
    return _p;
}

inline CssRuleBlockVec CssRuleBlockVec::copy_from_ptr(const CssRuleBlock& ptr, size_t len) {
    CssRuleBlockVec::Proxy _p(AzCssRuleBlockVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    CssRuleBlockVec::Proxy _p(AzCssRuleBlockVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCssRuleBlockVec_toDbgString(&inner_));
    return _p;
}

inline U16Vec U16Vec::create() {
    U16Vec::Proxy _p(AzU16Vec_create());
    return _p;
}

inline U16Vec U16Vec::with_capacity(size_t cap) {
    U16Vec::Proxy _p(AzU16Vec_withCapacity(cap));
    return _p;
}

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) {
    U16Vec::Proxy _p(AzU16Vec_fromItem(item));
    return _p;
}

inline U16Vec U16Vec::copy_from_ptr(const uint16_t* ptr, size_t len) {
    U16Vec::Proxy _p(AzU16Vec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    U16Vec::Proxy _p(AzU16Vec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzU16Vec_toDbgString(&inner_));
    return _p;
}

inline F32Vec F32Vec::create() {
    F32Vec::Proxy _p(AzF32Vec_create());
    return _p;
}

inline F32Vec F32Vec::with_capacity(size_t cap) {
    F32Vec::Proxy _p(AzF32Vec_withCapacity(cap));
    return _p;
}

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) {
    F32Vec::Proxy _p(AzF32Vec_fromItem(item));
    return _p;
}

inline F32Vec F32Vec::copy_from_ptr(const float* ptr, size_t len) {
    F32Vec::Proxy _p(AzF32Vec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    F32Vec::Proxy _p(AzF32Vec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzF32Vec_toDbgString(&inner_));
    return _p;
}

inline U8Vec U8Vec::copy_from_bytes(const uint8_t* ptr, size_t start, size_t len) {
    U8Vec::Proxy _p(AzU8Vec_copyFromBytes(ptr, start, len));
    return _p;
}

inline U8VecRef U8Vec::as_ref_vec() const {
    U8VecRef::Proxy _p(AzU8Vec_asRefVec(&inner_));
    return _p;
}

inline U8Vec U8Vec::create() {
    U8Vec::Proxy _p(AzU8Vec_create());
    return _p;
}

inline U8Vec U8Vec::with_capacity(size_t cap) {
    U8Vec::Proxy _p(AzU8Vec_withCapacity(cap));
    return _p;
}

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) {
    U8Vec::Proxy _p(AzU8Vec_fromItem(item));
    return _p;
}

inline U8Vec U8Vec::copy_from_ptr(const uint8_t* ptr, size_t len) {
    U8Vec::Proxy _p(AzU8Vec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    U8Vec::Proxy _p(AzU8Vec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzU8Vec_toDbgString(&inner_));
    return _p;
}

inline GLuintVec GLuintVec::create() {
    GLuintVec::Proxy _p(AzGLuintVec_create());
    return _p;
}

inline GLuintVec GLuintVec::with_capacity(size_t cap) {
    GLuintVec::Proxy _p(AzGLuintVec_withCapacity(cap));
    return _p;
}

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) {
    GLuintVec::Proxy _p(AzGLuintVec_fromItem(item));
    return _p;
}

inline GLuintVec GLuintVec::copy_from_ptr(const AzGLuint* ptr, size_t len) {
    GLuintVec::Proxy _p(AzGLuintVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    GLuintVec::Proxy _p(AzGLuintVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGLuintVec_toDbgString(&inner_));
    return _p;
}

inline GLintVec GLintVec::create() {
    GLintVec::Proxy _p(AzGLintVec_create());
    return _p;
}

inline GLintVec GLintVec::with_capacity(size_t cap) {
    GLintVec::Proxy _p(AzGLintVec_withCapacity(cap));
    return _p;
}

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) {
    GLintVec::Proxy _p(AzGLintVec_fromItem(item));
    return _p;
}

inline GLintVec GLintVec::copy_from_ptr(const AzGLint* ptr, size_t len) {
    GLintVec::Proxy _p(AzGLintVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    GLintVec::Proxy _p(AzGLintVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGLintVec_toDbgString(&inner_));
    return _p;
}

inline StringVec StringVec::create() {
    StringVec::Proxy _p(AzStringVec_create());
    return _p;
}

inline StringVec StringVec::with_capacity(size_t cap) {
    StringVec::Proxy _p(AzStringVec_withCapacity(cap));
    return _p;
}

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) {
    StringVec::Proxy _p(AzStringVec_fromItem(item.release()));
    return _p;
}

inline StringVec StringVec::copy_from_ptr(const String& ptr, size_t len) {
    StringVec::Proxy _p(AzStringVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    StringVec::Proxy _p(AzStringVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStringVec_toDbgString(&inner_));
    return _p;
}

inline MimeTypeDataVec MimeTypeDataVec::create() {
    MimeTypeDataVec::Proxy _p(AzMimeTypeDataVec_create());
    return _p;
}

inline MimeTypeDataVec MimeTypeDataVec::with_capacity(size_t cap) {
    MimeTypeDataVec::Proxy _p(AzMimeTypeDataVec_withCapacity(cap));
    return _p;
}

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) {
    MimeTypeDataVec::Proxy _p(AzMimeTypeDataVec_fromItem(item.release()));
    return _p;
}

inline MimeTypeDataVec MimeTypeDataVec::copy_from_ptr(const MimeTypeData& ptr, size_t len) {
    MimeTypeDataVec::Proxy _p(AzMimeTypeDataVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    MimeTypeDataVec::Proxy _p(AzMimeTypeDataVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMimeTypeDataVec_toDbgString(&inner_));
    return _p;
}

inline StringPairVec StringPairVec::create() {
    StringPairVec::Proxy _p(AzStringPairVec_create());
    return _p;
}

inline StringPairVec StringPairVec::with_capacity(size_t cap) {
    StringPairVec::Proxy _p(AzStringPairVec_withCapacity(cap));
    return _p;
}

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) {
    StringPairVec::Proxy _p(AzStringPairVec_fromItem(item.release()));
    return _p;
}

inline StringPairVec StringPairVec::copy_from_ptr(const StringPair& ptr, size_t len) {
    StringPairVec::Proxy _p(AzStringPairVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    StringPairVec::Proxy _p(AzStringPairVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStringPairVec_toDbgString(&inner_));
    return _p;
}

inline NormalizedLinearColorStopVec NormalizedLinearColorStopVec::create() {
    NormalizedLinearColorStopVec::Proxy _p(AzNormalizedLinearColorStopVec_create());
    return _p;
}

inline NormalizedLinearColorStopVec NormalizedLinearColorStopVec::with_capacity(size_t cap) {
    NormalizedLinearColorStopVec::Proxy _p(AzNormalizedLinearColorStopVec_withCapacity(cap));
    return _p;
}

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) {
    NormalizedLinearColorStopVec::Proxy _p(AzNormalizedLinearColorStopVec_fromItem(item.release()));
    return _p;
}

inline NormalizedLinearColorStopVec NormalizedLinearColorStopVec::copy_from_ptr(const NormalizedLinearColorStop& ptr, size_t len) {
    NormalizedLinearColorStopVec::Proxy _p(AzNormalizedLinearColorStopVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    NormalizedLinearColorStopVec::Proxy _p(AzNormalizedLinearColorStopVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNormalizedLinearColorStopVec_toDbgString(&inner_));
    return _p;
}

inline NormalizedRadialColorStopVec NormalizedRadialColorStopVec::create() {
    NormalizedRadialColorStopVec::Proxy _p(AzNormalizedRadialColorStopVec_create());
    return _p;
}

inline NormalizedRadialColorStopVec NormalizedRadialColorStopVec::with_capacity(size_t cap) {
    NormalizedRadialColorStopVec::Proxy _p(AzNormalizedRadialColorStopVec_withCapacity(cap));
    return _p;
}

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) {
    NormalizedRadialColorStopVec::Proxy _p(AzNormalizedRadialColorStopVec_fromItem(item.release()));
    return _p;
}

inline NormalizedRadialColorStopVec NormalizedRadialColorStopVec::copy_from_ptr(const NormalizedRadialColorStop& ptr, size_t len) {
    NormalizedRadialColorStopVec::Proxy _p(AzNormalizedRadialColorStopVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    NormalizedRadialColorStopVec::Proxy _p(AzNormalizedRadialColorStopVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNormalizedRadialColorStopVec_toDbgString(&inner_));
    return _p;
}

inline NodeHierarchyItemVec NodeHierarchyItemVec::create() {
    NodeHierarchyItemVec::Proxy _p(AzNodeHierarchyItemVec_create());
    return _p;
}

inline NodeHierarchyItemVec NodeHierarchyItemVec::with_capacity(size_t cap) {
    NodeHierarchyItemVec::Proxy _p(AzNodeHierarchyItemVec_withCapacity(cap));
    return _p;
}

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) {
    NodeHierarchyItemVec::Proxy _p(AzNodeHierarchyItemVec_fromItem(item.release()));
    return _p;
}

inline NodeHierarchyItemVec NodeHierarchyItemVec::copy_from_ptr(const NodeHierarchyItem& ptr, size_t len) {
    NodeHierarchyItemVec::Proxy _p(AzNodeHierarchyItemVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    NodeHierarchyItemVec::Proxy _p(AzNodeHierarchyItemVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNodeHierarchyItemVec_toDbgString(&inner_));
    return _p;
}

inline TagIdToNodeIdMappingVec TagIdToNodeIdMappingVec::create() {
    TagIdToNodeIdMappingVec::Proxy _p(AzTagIdToNodeIdMappingVec_create());
    return _p;
}

inline TagIdToNodeIdMappingVec TagIdToNodeIdMappingVec::with_capacity(size_t cap) {
    TagIdToNodeIdMappingVec::Proxy _p(AzTagIdToNodeIdMappingVec_withCapacity(cap));
    return _p;
}

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) {
    TagIdToNodeIdMappingVec::Proxy _p(AzTagIdToNodeIdMappingVec_fromItem(item.release()));
    return _p;
}

inline TagIdToNodeIdMappingVec TagIdToNodeIdMappingVec::copy_from_ptr(const TagIdToNodeIdMapping& ptr, size_t len) {
    TagIdToNodeIdMappingVec::Proxy _p(AzTagIdToNodeIdMappingVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    TagIdToNodeIdMappingVec::Proxy _p(AzTagIdToNodeIdMappingVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTagIdToNodeIdMappingVec_toDbgString(&inner_));
    return _p;
}

inline ParentWithNodeDepthVec ParentWithNodeDepthVec::create() {
    ParentWithNodeDepthVec::Proxy _p(AzParentWithNodeDepthVec_create());
    return _p;
}

inline ParentWithNodeDepthVec ParentWithNodeDepthVec::with_capacity(size_t cap) {
    ParentWithNodeDepthVec::Proxy _p(AzParentWithNodeDepthVec_withCapacity(cap));
    return _p;
}

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) {
    ParentWithNodeDepthVec::Proxy _p(AzParentWithNodeDepthVec_fromItem(item.release()));
    return _p;
}

inline ParentWithNodeDepthVec ParentWithNodeDepthVec::copy_from_ptr(const ParentWithNodeDepth& ptr, size_t len) {
    ParentWithNodeDepthVec::Proxy _p(AzParentWithNodeDepthVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ParentWithNodeDepthVec::Proxy _p(AzParentWithNodeDepthVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzParentWithNodeDepthVec_toDbgString(&inner_));
    return _p;
}

inline NodeDataVec NodeDataVec::create() {
    NodeDataVec::Proxy _p(AzNodeDataVec_create());
    return _p;
}

inline NodeDataVec NodeDataVec::with_capacity(size_t cap) {
    NodeDataVec::Proxy _p(AzNodeDataVec_withCapacity(cap));
    return _p;
}

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) {
    NodeDataVec::Proxy _p(AzNodeDataVec_fromItem(item.release()));
    return _p;
}

inline NodeDataVec NodeDataVec::copy_from_ptr(const NodeData& ptr, size_t len) {
    NodeDataVec::Proxy _p(AzNodeDataVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    NodeDataVec::Proxy _p(AzNodeDataVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNodeDataVec_toDbgString(&inner_));
    return _p;
}

inline AttributeTypeVec AttributeTypeVec::create() {
    AttributeTypeVec::Proxy _p(AzAttributeTypeVec_create());
    return _p;
}

inline AttributeTypeVec AttributeTypeVec::with_capacity(size_t cap) {
    AttributeTypeVec::Proxy _p(AzAttributeTypeVec_withCapacity(cap));
    return _p;
}

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) {
    AttributeTypeVec::Proxy _p(AzAttributeTypeVec_fromItem(item));
    return _p;
}

inline AttributeTypeVec AttributeTypeVec::copy_from_ptr(const AzAttributeType* ptr, size_t len) {
    AttributeTypeVec::Proxy _p(AzAttributeTypeVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    AttributeTypeVec::Proxy _p(AzAttributeTypeVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzAttributeTypeVec_toDbgString(&inner_));
    return _p;
}

inline CoreCallbackDataVec CoreCallbackDataVec::create() {
    CoreCallbackDataVec::Proxy _p(AzCoreCallbackDataVec_create());
    return _p;
}

inline CoreCallbackDataVec CoreCallbackDataVec::with_capacity(size_t cap) {
    CoreCallbackDataVec::Proxy _p(AzCoreCallbackDataVec_withCapacity(cap));
    return _p;
}

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) {
    CoreCallbackDataVec::Proxy _p(AzCoreCallbackDataVec_fromItem(item.release()));
    return _p;
}

inline CoreCallbackDataVec CoreCallbackDataVec::copy_from_ptr(const CoreCallbackData& ptr, size_t len) {
    CoreCallbackDataVec::Proxy _p(AzCoreCallbackDataVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    CoreCallbackDataVec::Proxy _p(AzCoreCallbackDataVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCoreCallbackDataVec_toDbgString(&inner_));
    return _p;
}

inline AccessibilityActionVec AccessibilityActionVec::create() {
    AccessibilityActionVec::Proxy _p(AzAccessibilityActionVec_create());
    return _p;
}

inline AccessibilityActionVec AccessibilityActionVec::with_capacity(size_t cap) {
    AccessibilityActionVec::Proxy _p(AzAccessibilityActionVec_withCapacity(cap));
    return _p;
}

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) {
    AccessibilityActionVec::Proxy _p(AzAccessibilityActionVec_fromItem(item));
    return _p;
}

inline AccessibilityActionVec AccessibilityActionVec::copy_from_ptr(const AzAccessibilityAction* ptr, size_t len) {
    AccessibilityActionVec::Proxy _p(AzAccessibilityActionVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    AccessibilityActionVec::Proxy _p(AzAccessibilityActionVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzAccessibilityActionVec_toDbgString(&inner_));
    return _p;
}

inline GridTrackSizingVec GridTrackSizingVec::create() {
    GridTrackSizingVec::Proxy _p(AzGridTrackSizingVec_create());
    return _p;
}

inline GridTrackSizingVec GridTrackSizingVec::with_capacity(size_t cap) {
    GridTrackSizingVec::Proxy _p(AzGridTrackSizingVec_withCapacity(cap));
    return _p;
}

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) {
    GridTrackSizingVec::Proxy _p(AzGridTrackSizingVec_fromItem(item));
    return _p;
}

inline GridTrackSizingVec GridTrackSizingVec::copy_from_ptr(const AzGridTrackSizing* ptr, size_t len) {
    GridTrackSizingVec::Proxy _p(AzGridTrackSizingVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    GridTrackSizingVec::Proxy _p(AzGridTrackSizingVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGridTrackSizingVec_toDbgString(&inner_));
    return _p;
}

inline VertexAttributeVec VertexAttributeVec::create() {
    VertexAttributeVec::Proxy _p(AzVertexAttributeVec_create());
    return _p;
}

inline VertexAttributeVec VertexAttributeVec::with_capacity(size_t cap) {
    VertexAttributeVec::Proxy _p(AzVertexAttributeVec_withCapacity(cap));
    return _p;
}

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) {
    VertexAttributeVec::Proxy _p(AzVertexAttributeVec_fromItem(item.release()));
    return _p;
}

inline VertexAttributeVec VertexAttributeVec::copy_from_ptr(const VertexAttribute& ptr, size_t len) {
    VertexAttributeVec::Proxy _p(AzVertexAttributeVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    VertexAttributeVec::Proxy _p(AzVertexAttributeVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzVertexAttributeVec_toDbgString(&inner_));
    return _p;
}

inline DebugMessageVec DebugMessageVec::create() {
    DebugMessageVec::Proxy _p(AzDebugMessageVec_create());
    return _p;
}

inline DebugMessageVec DebugMessageVec::with_capacity(size_t cap) {
    DebugMessageVec::Proxy _p(AzDebugMessageVec_withCapacity(cap));
    return _p;
}

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) {
    DebugMessageVec::Proxy _p(AzDebugMessageVec_fromItem(item.release()));
    return _p;
}

inline DebugMessageVec DebugMessageVec::copy_from_ptr(const DebugMessage& ptr, size_t len) {
    DebugMessageVec::Proxy _p(AzDebugMessageVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    DebugMessageVec::Proxy _p(AzDebugMessageVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDebugMessageVec_toDbgString(&inner_));
    return _p;
}

inline ShapePointVec ShapePointVec::create() {
    ShapePointVec::Proxy _p(AzShapePointVec_create());
    return _p;
}

inline ShapePointVec ShapePointVec::with_capacity(size_t cap) {
    ShapePointVec::Proxy _p(AzShapePointVec_withCapacity(cap));
    return _p;
}

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) {
    ShapePointVec::Proxy _p(AzShapePointVec_fromItem(item.release()));
    return _p;
}

inline ShapePointVec ShapePointVec::copy_from_ptr(const ShapePoint& ptr, size_t len) {
    ShapePointVec::Proxy _p(AzShapePointVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ShapePointVec::Proxy _p(AzShapePointVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzShapePointVec_toDbgString(&inner_));
    return _p;
}

inline MonitorVec MonitorVec::create() {
    MonitorVec::Proxy _p(AzMonitorVec_create());
    return _p;
}

inline MonitorVec MonitorVec::with_capacity(size_t cap) {
    MonitorVec::Proxy _p(AzMonitorVec_withCapacity(cap));
    return _p;
}

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) {
    MonitorVec::Proxy _p(AzMonitorVec_fromItem(item.release()));
    return _p;
}

inline MonitorVec MonitorVec::copy_from_ptr(const Monitor& ptr, size_t len) {
    MonitorVec::Proxy _p(AzMonitorVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    MonitorVec::Proxy _p(AzMonitorVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMonitorVec_toDbgString(&inner_));
    return _p;
}

inline VideoModeVec VideoModeVec::create() {
    VideoModeVec::Proxy _p(AzVideoModeVec_create());
    return _p;
}

inline VideoModeVec VideoModeVec::with_capacity(size_t cap) {
    VideoModeVec::Proxy _p(AzVideoModeVec_withCapacity(cap));
    return _p;
}

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) {
    VideoModeVec::Proxy _p(AzVideoModeVec_fromItem(item.release()));
    return _p;
}

inline VideoModeVec VideoModeVec::copy_from_ptr(const VideoMode& ptr, size_t len) {
    VideoModeVec::Proxy _p(AzVideoModeVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    VideoModeVec::Proxy _p(AzVideoModeVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzVideoModeVec_toDbgString(&inner_));
    return _p;
}

inline XWindowTypeVec XWindowTypeVec::create() {
    XWindowTypeVec::Proxy _p(AzXWindowTypeVec_create());
    return _p;
}

inline XWindowTypeVec XWindowTypeVec::with_capacity(size_t cap) {
    XWindowTypeVec::Proxy _p(AzXWindowTypeVec_withCapacity(cap));
    return _p;
}

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) {
    XWindowTypeVec::Proxy _p(AzXWindowTypeVec_fromItem(item));
    return _p;
}

inline XWindowTypeVec XWindowTypeVec::copy_from_ptr(const AzXWindowType* ptr, size_t len) {
    XWindowTypeVec::Proxy _p(AzXWindowTypeVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    XWindowTypeVec::Proxy _p(AzXWindowTypeVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzXWindowTypeVec_toDbgString(&inner_));
    return _p;
}

inline ScanCodeVec ScanCodeVec::create() {
    ScanCodeVec::Proxy _p(AzScanCodeVec_create());
    return _p;
}

inline ScanCodeVec ScanCodeVec::with_capacity(size_t cap) {
    ScanCodeVec::Proxy _p(AzScanCodeVec_withCapacity(cap));
    return _p;
}

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) {
    ScanCodeVec::Proxy _p(AzScanCodeVec_fromItem(item));
    return _p;
}

inline ScanCodeVec ScanCodeVec::copy_from_ptr(const AzScanCode* ptr, size_t len) {
    ScanCodeVec::Proxy _p(AzScanCodeVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    ScanCodeVec::Proxy _p(AzScanCodeVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzScanCodeVec_toDbgString(&inner_));
    return _p;
}

inline ContentGroupVec ContentGroupVec::create() {
    ContentGroupVec::Proxy _p(AzContentGroupVec_create());
    return _p;
}

inline ContentGroupVec ContentGroupVec::with_capacity(size_t cap) {
    ContentGroupVec::Proxy _p(AzContentGroupVec_withCapacity(cap));
    return _p;
}

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) {
    ContentGroupVec::Proxy _p(AzContentGroupVec_fromItem(item.release()));
    return _p;
}

inline ContentGroupVec ContentGroupVec::copy_from_ptr(const ContentGroup& ptr, size_t len) {
    ContentGroupVec::Proxy _p(AzContentGroupVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ContentGroupVec::Proxy _p(AzContentGroupVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzContentGroupVec_toDbgString(&inner_));
    return _p;
}

inline StyledNodeVec StyledNodeVec::create() {
    StyledNodeVec::Proxy _p(AzStyledNodeVec_create());
    return _p;
}

inline StyledNodeVec StyledNodeVec::with_capacity(size_t cap) {
    StyledNodeVec::Proxy _p(AzStyledNodeVec_withCapacity(cap));
    return _p;
}

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) {
    StyledNodeVec::Proxy _p(AzStyledNodeVec_fromItem(item.release()));
    return _p;
}

inline StyledNodeVec StyledNodeVec::copy_from_ptr(const StyledNode& ptr, size_t len) {
    StyledNodeVec::Proxy _p(AzStyledNodeVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    StyledNodeVec::Proxy _p(AzStyledNodeVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyledNodeVec_toDbgString(&inner_));
    return _p;
}

inline DomIdVec DomIdVec::create() {
    DomIdVec::Proxy _p(AzDomIdVec_create());
    return _p;
}

inline DomIdVec DomIdVec::with_capacity(size_t cap) {
    DomIdVec::Proxy _p(AzDomIdVec_withCapacity(cap));
    return _p;
}

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) {
    DomIdVec::Proxy _p(AzDomIdVec_fromItem(item.release()));
    return _p;
}

inline DomIdVec DomIdVec::copy_from_ptr(const DomId& ptr, size_t len) {
    DomIdVec::Proxy _p(AzDomIdVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    DomIdVec::Proxy _p(AzDomIdVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDomIdVec_toDbgString(&inner_));
    return _p;
}

inline TimerIdVec TimerIdVec::create() {
    TimerIdVec::Proxy _p(AzTimerIdVec_create());
    return _p;
}

inline TimerIdVec TimerIdVec::with_capacity(size_t cap) {
    TimerIdVec::Proxy _p(AzTimerIdVec_withCapacity(cap));
    return _p;
}

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) {
    TimerIdVec::Proxy _p(AzTimerIdVec_fromItem(item.release()));
    return _p;
}

inline TimerIdVec TimerIdVec::copy_from_ptr(const TimerId& ptr, size_t len) {
    TimerIdVec::Proxy _p(AzTimerIdVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    TimerIdVec::Proxy _p(AzTimerIdVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTimerIdVec_toDbgString(&inner_));
    return _p;
}

inline SelectionRangeVec SelectionRangeVec::create() {
    SelectionRangeVec::Proxy _p(AzSelectionRangeVec_create());
    return _p;
}

inline SelectionRangeVec SelectionRangeVec::with_capacity(size_t cap) {
    SelectionRangeVec::Proxy _p(AzSelectionRangeVec_withCapacity(cap));
    return _p;
}

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) {
    SelectionRangeVec::Proxy _p(AzSelectionRangeVec_fromItem(item.release()));
    return _p;
}

inline SelectionRangeVec SelectionRangeVec::copy_from_ptr(const SelectionRange& ptr, size_t len) {
    SelectionRangeVec::Proxy _p(AzSelectionRangeVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    SelectionRangeVec::Proxy _p(AzSelectionRangeVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSelectionRangeVec_toDbgString(&inner_));
    return _p;
}

inline ThreadIdVec ThreadIdVec::create() {
    ThreadIdVec::Proxy _p(AzThreadIdVec_create());
    return _p;
}

inline ThreadIdVec ThreadIdVec::with_capacity(size_t cap) {
    ThreadIdVec::Proxy _p(AzThreadIdVec_withCapacity(cap));
    return _p;
}

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) {
    ThreadIdVec::Proxy _p(AzThreadIdVec_fromItem(item.release()));
    return _p;
}

inline ThreadIdVec ThreadIdVec::copy_from_ptr(const ThreadId& ptr, size_t len) {
    ThreadIdVec::Proxy _p(AzThreadIdVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ThreadIdVec::Proxy _p(AzThreadIdVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzThreadIdVec_toDbgString(&inner_));
    return _p;
}

inline StyledTextRunVec StyledTextRunVec::create() {
    StyledTextRunVec::Proxy _p(AzStyledTextRunVec_create());
    return _p;
}

inline StyledTextRunVec StyledTextRunVec::with_capacity(size_t cap) {
    StyledTextRunVec::Proxy _p(AzStyledTextRunVec_withCapacity(cap));
    return _p;
}

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) {
    StyledTextRunVec::Proxy _p(AzStyledTextRunVec_fromItem(item.release()));
    return _p;
}

inline StyledTextRunVec StyledTextRunVec::copy_from_ptr(const StyledTextRun& ptr, size_t len) {
    StyledTextRunVec::Proxy _p(AzStyledTextRunVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    StyledTextRunVec::Proxy _p(AzStyledTextRunVec_clone(&inner_));
    return _p;
}

inline bool StyledTextRunVec::partialEq(const StyledTextRunVec& b) const {
    return AzStyledTextRunVec_partialEq(&inner_, b.ptr());
}

inline String StyledTextRunVec::toDbgString() const {
    String::Proxy _p(AzStyledTextRunVec_toDbgString(&inner_));
    return _p;
}

inline SelectionVec SelectionVec::create() {
    SelectionVec::Proxy _p(AzSelectionVec_create());
    return _p;
}

inline SelectionVec SelectionVec::with_capacity(size_t cap) {
    SelectionVec::Proxy _p(AzSelectionVec_withCapacity(cap));
    return _p;
}

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) {
    SelectionVec::Proxy _p(AzSelectionVec_fromItem(item));
    return _p;
}

inline SelectionVec SelectionVec::copy_from_ptr(const AzSelection* ptr, size_t len) {
    SelectionVec::Proxy _p(AzSelectionVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    SelectionVec::Proxy _p(AzSelectionVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSelectionVec_toDbgString(&inner_));
    return _p;
}

inline HttpHeaderVec HttpHeaderVec::create() {
    HttpHeaderVec::Proxy _p(AzHttpHeaderVec_create());
    return _p;
}

inline HttpHeaderVec HttpHeaderVec::with_capacity(size_t cap) {
    HttpHeaderVec::Proxy _p(AzHttpHeaderVec_withCapacity(cap));
    return _p;
}

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) {
    HttpHeaderVec::Proxy _p(AzHttpHeaderVec_fromItem(item.release()));
    return _p;
}

inline HttpHeaderVec HttpHeaderVec::copy_from_ptr(const HttpHeader& ptr, size_t len) {
    HttpHeaderVec::Proxy _p(AzHttpHeaderVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    HttpHeaderVec::Proxy _p(AzHttpHeaderVec_clone(&inner_));
    return _p;
}

inline bool HttpHeaderVec::partialEq(const HttpHeaderVec& b) const {
    return AzHttpHeaderVec_partialEq(&inner_, b.ptr());
}

inline String HttpHeaderVec::toDbgString() const {
    String::Proxy _p(AzHttpHeaderVec_toDbgString(&inner_));
    return _p;
}

inline FmtArgVec FmtArgVec::create() {
    FmtArgVec::Proxy _p(AzFmtArgVec_create());
    return _p;
}

inline FmtArgVec FmtArgVec::with_capacity(size_t cap) {
    FmtArgVec::Proxy _p(AzFmtArgVec_withCapacity(cap));
    return _p;
}

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) {
    FmtArgVec::Proxy _p(AzFmtArgVec_fromItem(item.release()));
    return _p;
}

inline FmtArgVec FmtArgVec::copy_from_ptr(const FmtArg& ptr, size_t len) {
    FmtArgVec::Proxy _p(AzFmtArgVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    FmtArgVec::Proxy _p(AzFmtArgVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzFmtArgVec_toDbgString(&inner_));
    return _p;
}

inline JsonVec JsonVec::copy_from_array(const Json& ptr, size_t len) {
    JsonVec::Proxy _p(AzJsonVec_copyFromArray(ptr.ptr(), len));
    return _p;
}

inline JsonVec JsonVec::create() {
    JsonVec::Proxy _p(AzJsonVec_create());
    return _p;
}

inline JsonVec JsonVec::with_capacity(size_t cap) {
    JsonVec::Proxy _p(AzJsonVec_withCapacity(cap));
    return _p;
}

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) {
    JsonVec::Proxy _p(AzJsonVec_fromItem(item.release()));
    return _p;
}

inline JsonVec JsonVec::copy_from_ptr(const Json& ptr, size_t len) {
    JsonVec::Proxy _p(AzJsonVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    JsonVec::Proxy _p(AzJsonVec_clone(&inner_));
    return _p;
}

inline bool JsonVec::partialEq(const JsonVec& b) const {
    return AzJsonVec_partialEq(&inner_, b.ptr());
}

inline String JsonVec::toDbgString() const {
    String::Proxy _p(AzJsonVec_toDbgString(&inner_));
    return _p;
}

inline DirEntryVec DirEntryVec::create() {
    DirEntryVec::Proxy _p(AzDirEntryVec_create());
    return _p;
}

inline DirEntryVec DirEntryVec::with_capacity(size_t cap) {
    DirEntryVec::Proxy _p(AzDirEntryVec_withCapacity(cap));
    return _p;
}

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) {
    DirEntryVec::Proxy _p(AzDirEntryVec_fromItem(item.release()));
    return _p;
}

inline DirEntryVec DirEntryVec::copy_from_ptr(const DirEntry& ptr, size_t len) {
    DirEntryVec::Proxy _p(AzDirEntryVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    DirEntryVec::Proxy _p(AzDirEntryVec_clone(&inner_));
    return _p;
}

inline String DirEntryVec::toDbgString() const {
    String::Proxy _p(AzDirEntryVec_toDbgString(&inner_));
    return _p;
}

inline JsonKeyValueVec JsonKeyValueVec::copy_from_array(const JsonKeyValue& ptr, size_t len) {
    JsonKeyValueVec::Proxy _p(AzJsonKeyValueVec_copyFromArray(ptr.ptr(), len));
    return _p;
}

inline JsonKeyValueVec JsonKeyValueVec::create() {
    JsonKeyValueVec::Proxy _p(AzJsonKeyValueVec_create());
    return _p;
}

inline JsonKeyValueVec JsonKeyValueVec::with_capacity(size_t cap) {
    JsonKeyValueVec::Proxy _p(AzJsonKeyValueVec_withCapacity(cap));
    return _p;
}

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) {
    JsonKeyValueVec::Proxy _p(AzJsonKeyValueVec_fromItem(item.release()));
    return _p;
}

inline JsonKeyValueVec JsonKeyValueVec::copy_from_ptr(const JsonKeyValue& ptr, size_t len) {
    JsonKeyValueVec::Proxy _p(AzJsonKeyValueVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    JsonKeyValueVec::Proxy _p(AzJsonKeyValueVec_clone(&inner_));
    return _p;
}

inline String JsonKeyValueVec::toDbgString() const {
    String::Proxy _p(AzJsonKeyValueVec_toDbgString(&inner_));
    return _p;
}

inline NamedFontVec NamedFontVec::create() {
    NamedFontVec::Proxy _p(AzNamedFontVec_create());
    return _p;
}

inline NamedFontVec NamedFontVec::with_capacity(size_t cap) {
    NamedFontVec::Proxy _p(AzNamedFontVec_withCapacity(cap));
    return _p;
}

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) {
    NamedFontVec::Proxy _p(AzNamedFontVec_fromItem(item.release()));
    return _p;
}

inline NamedFontVec NamedFontVec::copy_from_ptr(const NamedFont& ptr, size_t len) {
    NamedFontVec::Proxy _p(AzNamedFontVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    NamedFontVec::Proxy _p(AzNamedFontVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNamedFontVec_toDbgString(&inner_));
    return _p;
}

inline ExternalResourceVec ExternalResourceVec::create() {
    ExternalResourceVec::Proxy _p(AzExternalResourceVec_create());
    return _p;
}

inline ExternalResourceVec ExternalResourceVec::with_capacity(size_t cap) {
    ExternalResourceVec::Proxy _p(AzExternalResourceVec_withCapacity(cap));
    return _p;
}

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) {
    ExternalResourceVec::Proxy _p(AzExternalResourceVec_fromItem(item.release()));
    return _p;
}

inline ExternalResourceVec ExternalResourceVec::copy_from_ptr(const ExternalResource& ptr, size_t len) {
    ExternalResourceVec::Proxy _p(AzExternalResourceVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ExternalResourceVec::Proxy _p(AzExternalResourceVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzExternalResourceVec_toDbgString(&inner_));
    return _p;
}

inline NodeHierarchyItemIdVec NodeHierarchyItemIdVec::create() {
    NodeHierarchyItemIdVec::Proxy _p(AzNodeHierarchyItemIdVec_create());
    return _p;
}

inline NodeHierarchyItemIdVec NodeHierarchyItemIdVec::with_capacity(size_t cap) {
    NodeHierarchyItemIdVec::Proxy _p(AzNodeHierarchyItemIdVec_withCapacity(cap));
    return _p;
}

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) {
    NodeHierarchyItemIdVec::Proxy _p(AzNodeHierarchyItemIdVec_fromItem(item.release()));
    return _p;
}

inline NodeHierarchyItemIdVec NodeHierarchyItemIdVec::copy_from_ptr(const NodeHierarchyItemId& ptr, size_t len) {
    NodeHierarchyItemIdVec::Proxy _p(AzNodeHierarchyItemIdVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    NodeHierarchyItemIdVec::Proxy _p(AzNodeHierarchyItemIdVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNodeHierarchyItemIdVec_toDbgString(&inner_));
    return _p;
}

inline CalcAstItemVec CalcAstItemVec::create() {
    CalcAstItemVec::Proxy _p(AzCalcAstItemVec_create());
    return _p;
}

inline CalcAstItemVec CalcAstItemVec::with_capacity(size_t cap) {
    CalcAstItemVec::Proxy _p(AzCalcAstItemVec_withCapacity(cap));
    return _p;
}

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) {
    CalcAstItemVec::Proxy _p(AzCalcAstItemVec_fromItem(item));
    return _p;
}

inline CalcAstItemVec CalcAstItemVec::copy_from_ptr(const AzCalcAstItem* ptr, size_t len) {
    CalcAstItemVec::Proxy _p(AzCalcAstItemVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    CalcAstItemVec::Proxy _p(AzCalcAstItemVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCalcAstItemVec_toDbgString(&inner_));
    return _p;
}

inline GridAreaDefinitionVec GridAreaDefinitionVec::create() {
    GridAreaDefinitionVec::Proxy _p(AzGridAreaDefinitionVec_create());
    return _p;
}

inline GridAreaDefinitionVec GridAreaDefinitionVec::with_capacity(size_t cap) {
    GridAreaDefinitionVec::Proxy _p(AzGridAreaDefinitionVec_withCapacity(cap));
    return _p;
}

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) {
    GridAreaDefinitionVec::Proxy _p(AzGridAreaDefinitionVec_fromItem(item.release()));
    return _p;
}

inline GridAreaDefinitionVec GridAreaDefinitionVec::copy_from_ptr(const GridAreaDefinition& ptr, size_t len) {
    GridAreaDefinitionVec::Proxy _p(AzGridAreaDefinitionVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    GridAreaDefinitionVec::Proxy _p(AzGridAreaDefinitionVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGridAreaDefinitionVec_toDbgString(&inner_));
    return _p;
}

inline ComponentDataFieldVec ComponentDataFieldVec::create() {
    ComponentDataFieldVec::Proxy _p(AzComponentDataFieldVec_create());
    return _p;
}

inline ComponentDataFieldVec ComponentDataFieldVec::with_capacity(size_t cap) {
    ComponentDataFieldVec::Proxy _p(AzComponentDataFieldVec_withCapacity(cap));
    return _p;
}

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) {
    ComponentDataFieldVec::Proxy _p(AzComponentDataFieldVec_fromItem(item.release()));
    return _p;
}

inline ComponentDataFieldVec ComponentDataFieldVec::copy_from_ptr(const ComponentDataField& ptr, size_t len) {
    ComponentDataFieldVec::Proxy _p(AzComponentDataFieldVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ComponentDataFieldVec::Proxy _p(AzComponentDataFieldVec_clone(&inner_));
    return _p;
}

inline bool ComponentDataFieldVec::partialEq(const ComponentDataFieldVec& b) const {
    return AzComponentDataFieldVec_partialEq(&inner_, b.ptr());
}

inline String ComponentDataFieldVec::toDbgString() const {
    String::Proxy _p(AzComponentDataFieldVec_toDbgString(&inner_));
    return _p;
}

inline ComponentDefVec ComponentDefVec::create() {
    ComponentDefVec::Proxy _p(AzComponentDefVec_create());
    return _p;
}

inline ComponentDefVec ComponentDefVec::with_capacity(size_t cap) {
    ComponentDefVec::Proxy _p(AzComponentDefVec_withCapacity(cap));
    return _p;
}

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) {
    ComponentDefVec::Proxy _p(AzComponentDefVec_fromItem(item.release()));
    return _p;
}

inline ComponentDefVec ComponentDefVec::copy_from_ptr(const ComponentDef& ptr, size_t len) {
    ComponentDefVec::Proxy _p(AzComponentDefVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ComponentDefVec::Proxy _p(AzComponentDefVec_clone(&inner_));
    return _p;
}

inline String ComponentDefVec::toDbgString() const {
    String::Proxy _p(AzComponentDefVec_toDbgString(&inner_));
    return _p;
}

inline ComponentLibraryVec ComponentLibraryVec::create() {
    ComponentLibraryVec::Proxy _p(AzComponentLibraryVec_create());
    return _p;
}

inline ComponentLibraryVec ComponentLibraryVec::with_capacity(size_t cap) {
    ComponentLibraryVec::Proxy _p(AzComponentLibraryVec_withCapacity(cap));
    return _p;
}

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) {
    ComponentLibraryVec::Proxy _p(AzComponentLibraryVec_fromItem(item.release()));
    return _p;
}

inline ComponentLibraryVec ComponentLibraryVec::copy_from_ptr(const ComponentLibrary& ptr, size_t len) {
    ComponentLibraryVec::Proxy _p(AzComponentLibraryVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ComponentLibraryVec::Proxy _p(AzComponentLibraryVec_clone(&inner_));
    return _p;
}

inline String ComponentLibraryVec::toDbgString() const {
    String::Proxy _p(AzComponentLibraryVec_toDbgString(&inner_));
    return _p;
}

inline ComponentDataModelVec ComponentDataModelVec::create() {
    ComponentDataModelVec::Proxy _p(AzComponentDataModelVec_create());
    return _p;
}

inline ComponentDataModelVec ComponentDataModelVec::with_capacity(size_t cap) {
    ComponentDataModelVec::Proxy _p(AzComponentDataModelVec_withCapacity(cap));
    return _p;
}

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) {
    ComponentDataModelVec::Proxy _p(AzComponentDataModelVec_fromItem(item.release()));
    return _p;
}

inline ComponentDataModelVec ComponentDataModelVec::copy_from_ptr(const ComponentDataModel& ptr, size_t len) {
    ComponentDataModelVec::Proxy _p(AzComponentDataModelVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ComponentDataModelVec::Proxy _p(AzComponentDataModelVec_clone(&inner_));
    return _p;
}

inline String ComponentDataModelVec::toDbgString() const {
    String::Proxy _p(AzComponentDataModelVec_toDbgString(&inner_));
    return _p;
}

inline ComponentEnumModelVec ComponentEnumModelVec::create() {
    ComponentEnumModelVec::Proxy _p(AzComponentEnumModelVec_create());
    return _p;
}

inline ComponentEnumModelVec ComponentEnumModelVec::with_capacity(size_t cap) {
    ComponentEnumModelVec::Proxy _p(AzComponentEnumModelVec_withCapacity(cap));
    return _p;
}

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) {
    ComponentEnumModelVec::Proxy _p(AzComponentEnumModelVec_fromItem(item.release()));
    return _p;
}

inline ComponentEnumModelVec ComponentEnumModelVec::copy_from_ptr(const ComponentEnumModel& ptr, size_t len) {
    ComponentEnumModelVec::Proxy _p(AzComponentEnumModelVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ComponentEnumModelVec::Proxy _p(AzComponentEnumModelVec_clone(&inner_));
    return _p;
}

inline bool ComponentEnumModelVec::partialEq(const ComponentEnumModelVec& b) const {
    return AzComponentEnumModelVec_partialEq(&inner_, b.ptr());
}

inline String ComponentEnumModelVec::toDbgString() const {
    String::Proxy _p(AzComponentEnumModelVec_toDbgString(&inner_));
    return _p;
}

inline ComponentEnumVariantVec ComponentEnumVariantVec::create() {
    ComponentEnumVariantVec::Proxy _p(AzComponentEnumVariantVec_create());
    return _p;
}

inline ComponentEnumVariantVec ComponentEnumVariantVec::with_capacity(size_t cap) {
    ComponentEnumVariantVec::Proxy _p(AzComponentEnumVariantVec_withCapacity(cap));
    return _p;
}

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) {
    ComponentEnumVariantVec::Proxy _p(AzComponentEnumVariantVec_fromItem(item.release()));
    return _p;
}

inline ComponentEnumVariantVec ComponentEnumVariantVec::copy_from_ptr(const ComponentEnumVariant& ptr, size_t len) {
    ComponentEnumVariantVec::Proxy _p(AzComponentEnumVariantVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ComponentEnumVariantVec::Proxy _p(AzComponentEnumVariantVec_clone(&inner_));
    return _p;
}

inline bool ComponentEnumVariantVec::partialEq(const ComponentEnumVariantVec& b) const {
    return AzComponentEnumVariantVec_partialEq(&inner_, b.ptr());
}

inline String ComponentEnumVariantVec::toDbgString() const {
    String::Proxy _p(AzComponentEnumVariantVec_toDbgString(&inner_));
    return _p;
}

inline ComponentCallbackArgVec ComponentCallbackArgVec::create() {
    ComponentCallbackArgVec::Proxy _p(AzComponentCallbackArgVec_create());
    return _p;
}

inline ComponentCallbackArgVec ComponentCallbackArgVec::with_capacity(size_t cap) {
    ComponentCallbackArgVec::Proxy _p(AzComponentCallbackArgVec_withCapacity(cap));
    return _p;
}

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) {
    ComponentCallbackArgVec::Proxy _p(AzComponentCallbackArgVec_fromItem(item.release()));
    return _p;
}

inline ComponentCallbackArgVec ComponentCallbackArgVec::copy_from_ptr(const ComponentCallbackArg& ptr, size_t len) {
    ComponentCallbackArgVec::Proxy _p(AzComponentCallbackArgVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ComponentCallbackArgVec::Proxy _p(AzComponentCallbackArgVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzComponentCallbackArgVec_toDbgString(&inner_));
    return _p;
}

inline ComponentFieldOverrideVec ComponentFieldOverrideVec::create() {
    ComponentFieldOverrideVec::Proxy _p(AzComponentFieldOverrideVec_create());
    return _p;
}

inline ComponentFieldOverrideVec ComponentFieldOverrideVec::with_capacity(size_t cap) {
    ComponentFieldOverrideVec::Proxy _p(AzComponentFieldOverrideVec_withCapacity(cap));
    return _p;
}

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) {
    ComponentFieldOverrideVec::Proxy _p(AzComponentFieldOverrideVec_fromItem(item.release()));
    return _p;
}

inline ComponentFieldOverrideVec ComponentFieldOverrideVec::copy_from_ptr(const ComponentFieldOverride& ptr, size_t len) {
    ComponentFieldOverrideVec::Proxy _p(AzComponentFieldOverrideVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    ComponentFieldOverrideVec::Proxy _p(AzComponentFieldOverrideVec_clone(&inner_));
    return _p;
}

inline bool ComponentFieldOverrideVec::partialEq(const ComponentFieldOverrideVec& b) const {
    return AzComponentFieldOverrideVec_partialEq(&inner_, b.ptr());
}

inline String ComponentFieldOverrideVec::toDbgString() const {
    String::Proxy _p(AzComponentFieldOverrideVec_toDbgString(&inner_));
    return _p;
}

inline SvgPathElementVec SvgPathElementVec::create() {
    SvgPathElementVec::Proxy _p(AzSvgPathElementVec_create());
    return _p;
}

inline SvgPathElementVec SvgPathElementVec::with_capacity(size_t cap) {
    SvgPathElementVec::Proxy _p(AzSvgPathElementVec_withCapacity(cap));
    return _p;
}

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) {
    SvgPathElementVec::Proxy _p(AzSvgPathElementVec_fromItem(item));
    return _p;
}

inline SvgPathElementVec SvgPathElementVec::copy_from_ptr(const AzSvgPathElement* ptr, size_t len) {
    SvgPathElementVec::Proxy _p(AzSvgPathElementVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    SvgPathElementVec::Proxy _p(AzSvgPathElementVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgPathElementVec_toDbgString(&inner_));
    return _p;
}

inline SvgPathVec SvgPathVec::create() {
    SvgPathVec::Proxy _p(AzSvgPathVec_create());
    return _p;
}

inline SvgPathVec SvgPathVec::with_capacity(size_t cap) {
    SvgPathVec::Proxy _p(AzSvgPathVec_withCapacity(cap));
    return _p;
}

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) {
    SvgPathVec::Proxy _p(AzSvgPathVec_fromItem(item.release()));
    return _p;
}

inline SvgPathVec SvgPathVec::copy_from_ptr(const SvgPath& ptr, size_t len) {
    SvgPathVec::Proxy _p(AzSvgPathVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    SvgPathVec::Proxy _p(AzSvgPathVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgPathVec_toDbgString(&inner_));
    return _p;
}

inline RibbonSectionVec RibbonSectionVec::create() {
    RibbonSectionVec::Proxy _p(AzRibbonSectionVec_create());
    return _p;
}

inline RibbonSectionVec RibbonSectionVec::with_capacity(size_t cap) {
    RibbonSectionVec::Proxy _p(AzRibbonSectionVec_withCapacity(cap));
    return _p;
}

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) {
    RibbonSectionVec::Proxy _p(AzRibbonSectionVec_fromItem(item.release()));
    return _p;
}

inline RibbonSectionVec RibbonSectionVec::copy_from_ptr(const RibbonSection& ptr, size_t len) {
    RibbonSectionVec::Proxy _p(AzRibbonSectionVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    RibbonSectionVec::Proxy _p(AzRibbonSectionVec_clone(&inner_));
    return _p;
}

inline String RibbonSectionVec::toDbgString() const {
    String::Proxy _p(AzRibbonSectionVec_toDbgString(&inner_));
    return _p;
}

inline RibbonTabVec RibbonTabVec::create() {
    RibbonTabVec::Proxy _p(AzRibbonTabVec_create());
    return _p;
}

inline RibbonTabVec RibbonTabVec::with_capacity(size_t cap) {
    RibbonTabVec::Proxy _p(AzRibbonTabVec_withCapacity(cap));
    return _p;
}

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) {
    RibbonTabVec::Proxy _p(AzRibbonTabVec_fromItem(item.release()));
    return _p;
}

inline RibbonTabVec RibbonTabVec::copy_from_ptr(const RibbonTab& ptr, size_t len) {
    RibbonTabVec::Proxy _p(AzRibbonTabVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    RibbonTabVec::Proxy _p(AzRibbonTabVec_clone(&inner_));
    return _p;
}

inline String RibbonTabVec::toDbgString() const {
    String::Proxy _p(AzRibbonTabVec_toDbgString(&inner_));
    return _p;
}

inline TreeViewNodeVec TreeViewNodeVec::create() {
    TreeViewNodeVec::Proxy _p(AzTreeViewNodeVec_create());
    return _p;
}

inline TreeViewNodeVec TreeViewNodeVec::with_capacity(size_t cap) {
    TreeViewNodeVec::Proxy _p(AzTreeViewNodeVec_withCapacity(cap));
    return _p;
}

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) {
    TreeViewNodeVec::Proxy _p(AzTreeViewNodeVec_fromItem(item.release()));
    return _p;
}

inline TreeViewNodeVec TreeViewNodeVec::copy_from_ptr(const TreeViewNode& ptr, size_t len) {
    TreeViewNodeVec::Proxy _p(AzTreeViewNodeVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    TreeViewNodeVec::Proxy _p(AzTreeViewNodeVec_clone(&inner_));
    return _p;
}

inline bool TreeViewNodeVec::partialEq(const TreeViewNodeVec& b) const {
    return AzTreeViewNodeVec_partialEq(&inner_, b.ptr());
}

inline String TreeViewNodeVec::toDbgString() const {
    String::Proxy _p(AzTreeViewNodeVec_toDbgString(&inner_));
    return _p;
}

inline RouteVec RouteVec::create() {
    RouteVec::Proxy _p(AzRouteVec_create());
    return _p;
}

inline RouteVec RouteVec::with_capacity(size_t cap) {
    RouteVec::Proxy _p(AzRouteVec_withCapacity(cap));
    return _p;
}

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) {
    RouteVec::Proxy _p(AzRouteVec_fromItem(item.release()));
    return _p;
}

inline RouteVec RouteVec::copy_from_ptr(const Route& ptr, size_t len) {
    RouteVec::Proxy _p(AzRouteVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    RouteVec::Proxy _p(AzRouteVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzRouteVec_toDbgString(&inner_));
    return _p;
}

inline TouchPointVec TouchPointVec::create() {
    TouchPointVec::Proxy _p(AzTouchPointVec_create());
    return _p;
}

inline TouchPointVec TouchPointVec::with_capacity(size_t cap) {
    TouchPointVec::Proxy _p(AzTouchPointVec_withCapacity(cap));
    return _p;
}

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) {
    TouchPointVec::Proxy _p(AzTouchPointVec_fromItem(item.release()));
    return _p;
}

inline TouchPointVec TouchPointVec::copy_from_ptr(const TouchPoint& ptr, size_t len) {
    TouchPointVec::Proxy _p(AzTouchPointVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    TouchPointVec::Proxy _p(AzTouchPointVec_clone(&inner_));
    return _p;
}

inline bool TouchPointVec::partialEq(const TouchPointVec& b) const {
    return AzTouchPointVec_partialEq(&inner_, b.ptr());
}

inline String TouchPointVec::toDbgString() const {
    String::Proxy _p(AzTouchPointVec_toDbgString(&inner_));
    return _p;
}

inline LayoutRectVec LayoutRectVec::create() {
    LayoutRectVec::Proxy _p(AzLayoutRectVec_create());
    return _p;
}

inline LayoutRectVec LayoutRectVec::with_capacity(size_t cap) {
    LayoutRectVec::Proxy _p(AzLayoutRectVec_withCapacity(cap));
    return _p;
}

inline LayoutRectVec LayoutRectVec::from_item(LayoutRect item) {
    LayoutRectVec::Proxy _p(AzLayoutRectVec_fromItem(item.release()));
    return _p;
}

inline LayoutRectVec LayoutRectVec::copy_from_ptr(const LayoutRect& ptr, size_t len) {
    LayoutRectVec::Proxy _p(AzLayoutRectVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    LayoutRectVec::Proxy _p(AzLayoutRectVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutRectVec_toDbgString(&inner_));
    return _p;
}

inline DbValueVec DbValueVec::create() {
    DbValueVec::Proxy _p(AzDbValueVec_create());
    return _p;
}

inline DbValueVec DbValueVec::with_capacity(size_t cap) {
    DbValueVec::Proxy _p(AzDbValueVec_withCapacity(cap));
    return _p;
}

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) {
    DbValueVec::Proxy _p(AzDbValueVec_fromItem(item));
    return _p;
}

inline DbValueVec DbValueVec::copy_from_ptr(const AzDbValue* ptr, size_t len) {
    DbValueVec::Proxy _p(AzDbValueVec_copyFromPtr(ptr, len));
    return _p;
}

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 {
    DbValueVec::Proxy _p(AzDbValueVec_clone(&inner_));
    return _p;
}

inline bool DbValueVec::partialEq(const DbValueVec& b) const {
    return AzDbValueVec_partialEq(&inner_, b.ptr());
}

inline String DbValueVec::toDbgString() const {
    String::Proxy _p(AzDbValueVec_toDbgString(&inner_));
    return _p;
}

inline LoadedFontVec LoadedFontVec::create() {
    LoadedFontVec::Proxy _p(AzLoadedFontVec_create());
    return _p;
}

inline LoadedFontVec LoadedFontVec::with_capacity(size_t cap) {
    LoadedFontVec::Proxy _p(AzLoadedFontVec_withCapacity(cap));
    return _p;
}

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) {
    LoadedFontVec::Proxy _p(AzLoadedFontVec_fromItem(item.release()));
    return _p;
}

inline LoadedFontVec LoadedFontVec::copy_from_ptr(const LoadedFont& ptr, size_t len) {
    LoadedFontVec::Proxy _p(AzLoadedFontVec_copyFromPtr(ptr.ptr(), len));
    return _p;
}

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 {
    LoadedFontVec::Proxy _p(AzLoadedFontVec_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLoadedFontVec_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgRenderOptions_toDbgString(&inner_));
    return _p;
}

inline IconStyleOptions IconStyleOptions::default_() {
    IconStyleOptions::Proxy _p(AzIconStyleOptions_default());
    return _p;
}

inline void IconStyleOptions::delete_() {
    AzIconStyleOptions_delete(&inner_);
}

inline IconStyleOptions IconStyleOptions::clone() const {
    IconStyleOptions::Proxy _p(AzIconStyleOptions_clone(&inner_));
    return _p;
}

inline bool IconStyleOptions::partialEq(const IconStyleOptions& b) const {
    return AzIconStyleOptions_partialEq(&inner_, b.ptr());
}

inline String IconStyleOptions::toDbgString() const {
    String::Proxy _p(AzIconStyleOptions_toDbgString(&inner_));
    return _p;
}

inline void TaskBarIcon::delete_() {
    AzTaskBarIcon_delete(&inner_);
}

inline TaskBarIcon TaskBarIcon::clone() const {
    TaskBarIcon::Proxy _p(AzTaskBarIcon_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTaskBarIcon_toDbgString(&inner_));
    return _p;
}

inline void SmallWindowIconBytes::delete_() {
    AzSmallWindowIconBytes_delete(&inner_);
}

inline SmallWindowIconBytes SmallWindowIconBytes::clone() const {
    SmallWindowIconBytes::Proxy _p(AzSmallWindowIconBytes_clone(&inner_));
    return _p;
}

inline String SmallWindowIconBytes::toDbgString() const {
    String::Proxy _p(AzSmallWindowIconBytes_toDbgString(&inner_));
    return _p;
}

inline void LargeWindowIconBytes::delete_() {
    AzLargeWindowIconBytes_delete(&inner_);
}

inline LargeWindowIconBytes LargeWindowIconBytes::clone() const {
    LargeWindowIconBytes::Proxy _p(AzLargeWindowIconBytes_clone(&inner_));
    return _p;
}

inline String LargeWindowIconBytes::toDbgString() const {
    String::Proxy _p(AzLargeWindowIconBytes_toDbgString(&inner_));
    return _p;
}

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 {
    VirtualViewCallbackInfo::Proxy _p(AzVirtualViewCallbackInfo_clone(&inner_));
    return _p;
}

inline String VirtualViewCallbackInfo::toDbgString() const {
    String::Proxy _p(AzVirtualViewCallbackInfo_toDbgString(&inner_));
    return _p;
}

inline LayoutCallback LayoutCallback::create(AzLayoutCallbackType cb) {
    LayoutCallback::Proxy _p(AzLayoutCallback_create(cb));
    return _p;
}

inline LayoutCallback LayoutCallback::default_() {
    LayoutCallback::Proxy _p(AzLayoutCallback_default());
    return _p;
}

inline void LayoutCallback::delete_() {
    AzLayoutCallback_delete(&inner_);
}

inline LayoutCallback LayoutCallback::clone() const {
    LayoutCallback::Proxy _p(AzLayoutCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLayoutCallback_toDbgString(&inner_));
    return _p;
}

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 {
    LayoutCallbackInfo::Proxy _p(AzLayoutCallbackInfo_clone(&inner_));
    return _p;
}

inline String LayoutCallbackInfo::toDbgString() const {
    String::Proxy _p(AzLayoutCallbackInfo_toDbgString(&inner_));
    return _p;
}

inline void TimerCallback::delete_() {
    AzTimerCallback_delete(&inner_);
}

inline TimerCallback TimerCallback::clone() const {
    TimerCallback::Proxy _p(AzTimerCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTimerCallback_toDbgString(&inner_));
    return _p;
}

inline void WriteBackCallback::delete_() {
    AzWriteBackCallback_delete(&inner_);
}

inline WriteBackCallback WriteBackCallback::clone() const {
    WriteBackCallback::Proxy _p(AzWriteBackCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzWriteBackCallback_toDbgString(&inner_));
    return _p;
}

inline void ThreadCallback::delete_() {
    AzThreadCallback_delete(&inner_);
}

inline ThreadCallback ThreadCallback::clone() const {
    ThreadCallback::Proxy _p(AzThreadCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzThreadCallback_toDbgString(&inner_));
    return _p;
}

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 {
    RenderImageCallbackInfo::Proxy _p(AzRenderImageCallbackInfo_clone(&inner_));
    return _p;
}

inline String RenderImageCallbackInfo::toDbgString() const {
    String::Proxy _p(AzRenderImageCallbackInfo_toDbgString(&inner_));
    return _p;
}

inline void ListViewOnColumnClickCallback::delete_() {
    AzListViewOnColumnClickCallback_delete(&inner_);
}

inline ListViewOnColumnClickCallback ListViewOnColumnClickCallback::clone() const {
    ListViewOnColumnClickCallback::Proxy _p(AzListViewOnColumnClickCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzListViewOnColumnClickCallback_toDbgString(&inner_));
    return _p;
}

inline void CoreCallback::delete_() {
    AzCoreCallback_delete(&inner_);
}

inline CoreCallback CoreCallback::clone() const {
    CoreCallback::Proxy _p(AzCoreCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCoreCallback_toDbgString(&inner_));
    return _p;
}

inline void ListViewOnRowClickCallback::delete_() {
    AzListViewOnRowClickCallback_delete(&inner_);
}

inline ListViewOnRowClickCallback ListViewOnRowClickCallback::clone() const {
    ListViewOnRowClickCallback::Proxy _p(AzListViewOnRowClickCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzListViewOnRowClickCallback_toDbgString(&inner_));
    return _p;
}

inline void CheckBoxOnToggleCallback::delete_() {
    AzCheckBoxOnToggleCallback_delete(&inner_);
}

inline CheckBoxOnToggleCallback CheckBoxOnToggleCallback::clone() const {
    CheckBoxOnToggleCallback::Proxy _p(AzCheckBoxOnToggleCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCheckBoxOnToggleCallback_toDbgString(&inner_));
    return _p;
}

inline void DropDownOnChoiceChangeCallback::delete_() {
    AzDropDownOnChoiceChangeCallback_delete(&inner_);
}

inline DropDownOnChoiceChangeCallback DropDownOnChoiceChangeCallback::clone() const {
    DropDownOnChoiceChangeCallback::Proxy _p(AzDropDownOnChoiceChangeCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDropDownOnChoiceChangeCallback_toDbgString(&inner_));
    return _p;
}

inline void TabOnClickCallback::delete_() {
    AzTabOnClickCallback_delete(&inner_);
}

inline TabOnClickCallback TabOnClickCallback::clone() const {
    TabOnClickCallback::Proxy _p(AzTabOnClickCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTabOnClickCallback_toDbgString(&inner_));
    return _p;
}

inline void ListViewOnLazyLoadScrollCallback::delete_() {
    AzListViewOnLazyLoadScrollCallback_delete(&inner_);
}

inline ListViewOnLazyLoadScrollCallback ListViewOnLazyLoadScrollCallback::clone() const {
    ListViewOnLazyLoadScrollCallback::Proxy _p(AzListViewOnLazyLoadScrollCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzListViewOnLazyLoadScrollCallback_toDbgString(&inner_));
    return _p;
}

inline void ButtonOnClickCallback::delete_() {
    AzButtonOnClickCallback_delete(&inner_);
}

inline ButtonOnClickCallback ButtonOnClickCallback::clone() const {
    ButtonOnClickCallback::Proxy _p(AzButtonOnClickCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzButtonOnClickCallback_toDbgString(&inner_));
    return _p;
}

inline XmlAttributeMap XmlAttributeMap::default_() {
    XmlAttributeMap::Proxy _p(AzXmlAttributeMap_default());
    return _p;
}

inline void XmlAttributeMap::delete_() {
    AzXmlAttributeMap_delete(&inner_);
}

inline XmlAttributeMap XmlAttributeMap::clone() const {
    XmlAttributeMap::Proxy _p(AzXmlAttributeMap_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzXmlAttributeMap_toDbgString(&inner_));
    return _p;
}

inline Callback Callback::create(AzCallbackType cb) {
    Callback::Proxy _p(AzCallback_create(cb));
    return _p;
}

inline CoreCallback Callback::to_core() const {
    CoreCallback::Proxy _p(AzCallback_toCore(inner_));
    return _p;
}

inline void Callback::delete_() {
    AzCallback_delete(&inner_);
}

inline Callback Callback::clone() const {
    Callback::Proxy _p(AzCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCallback_toDbgString(&inner_));
    return _p;
}

inline KeyboardState KeyboardState::default_() {
    KeyboardState::Proxy _p(AzKeyboardState_default());
    return _p;
}

inline void KeyboardState::delete_() {
    AzKeyboardState_delete(&inner_);
}

inline KeyboardState KeyboardState::clone() const {
    KeyboardState::Proxy _p(AzKeyboardState_clone(&inner_));
    return _p;
}

inline bool KeyboardState::partialEq(const KeyboardState& b) const {
    return AzKeyboardState_partialEq(&inner_, b.ptr());
}

inline String KeyboardState::toDbgString() const {
    String::Proxy _p(AzKeyboardState_toDbgString(&inner_));
    return _p;
}

inline TouchState TouchState::default_() {
    TouchState::Proxy _p(AzTouchState_default());
    return _p;
}

inline void TouchState::delete_() {
    AzTouchState_delete(&inner_);
}

inline TouchState TouchState::clone() const {
    TouchState::Proxy _p(AzTouchState_clone(&inner_));
    return _p;
}

inline bool TouchState::partialEq(const TouchState& b) const {
    return AzTouchState_partialEq(&inner_, b.ptr());
}

inline String TouchState::toDbgString() const {
    String::Proxy _p(AzTouchState_toDbgString(&inner_));
    return _p;
}

inline void CoreRenderImageCallback::delete_() {
    AzCoreRenderImageCallback_delete(&inner_);
}

inline CoreRenderImageCallback CoreRenderImageCallback::clone() const {
    CoreRenderImageCallback::Proxy _p(AzCoreRenderImageCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCoreRenderImageCallback_toDbgString(&inner_));
    return _p;
}

inline void VirtualKeyCodeCombo::delete_() {
    AzVirtualKeyCodeCombo_delete(&inner_);
}

inline VirtualKeyCodeCombo VirtualKeyCodeCombo::clone() const {
    VirtualKeyCodeCombo::Proxy _p(AzVirtualKeyCodeCombo_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzVirtualKeyCodeCombo_toDbgString(&inner_));
    return _p;
}

inline void TextInputOnVirtualKeyDownCallback::delete_() {
    AzTextInputOnVirtualKeyDownCallback_delete(&inner_);
}

inline TextInputOnVirtualKeyDownCallback TextInputOnVirtualKeyDownCallback::clone() const {
    TextInputOnVirtualKeyDownCallback::Proxy _p(AzTextInputOnVirtualKeyDownCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTextInputOnVirtualKeyDownCallback_toDbgString(&inner_));
    return _p;
}

inline void SelectionState::delete_() {
    AzSelectionState_delete(&inner_);
}

inline SelectionState SelectionState::clone() const {
    SelectionState::Proxy _p(AzSelectionState_clone(&inner_));
    return _p;
}

inline bool SelectionState::partialEq(const SelectionState& b) const {
    return AzSelectionState_partialEq(&inner_, b.ptr());
}

inline String SelectionState::toDbgString() const {
    String::Proxy _p(AzSelectionState_toDbgString(&inner_));
    return _p;
}

inline void TextOpExtendSelection::delete_() {
    AzTextOpExtendSelection_delete(&inner_);
}

inline TextOpExtendSelection TextOpExtendSelection::clone() const {
    TextOpExtendSelection::Proxy _p(AzTextOpExtendSelection_clone(&inner_));
    return _p;
}

inline String TextOpExtendSelection::toDbgString() const {
    String::Proxy _p(AzTextOpExtendSelection_toDbgString(&inner_));
    return _p;
}

inline RenderImageCallback RenderImageCallback::create(AzRenderImageCallbackType cb) {
    RenderImageCallback::Proxy _p(AzRenderImageCallback_create(cb));
    return _p;
}

inline CoreRenderImageCallback RenderImageCallback::to_core() const {
    CoreRenderImageCallback::Proxy _p(AzRenderImageCallback_toCore(inner_));
    return _p;
}

inline void RenderImageCallback::delete_() {
    AzRenderImageCallback_delete(&inner_);
}

inline RenderImageCallback RenderImageCallback::clone() const {
    RenderImageCallback::Proxy _p(AzRenderImageCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzRenderImageCallback_toDbgString(&inner_));
    return _p;
}

inline void TextOpClearSelection::delete_() {
    AzTextOpClearSelection_delete(&inner_);
}

inline TextOpClearSelection TextOpClearSelection::clone() const {
    TextOpClearSelection::Proxy _p(AzTextOpClearSelection_clone(&inner_));
    return _p;
}

inline String TextOpClearSelection::toDbgString() const {
    String::Proxy _p(AzTextOpClearSelection_toDbgString(&inner_));
    return _p;
}

inline DatasetMergeCallback DatasetMergeCallback::from(AzDatasetMergeCallbackType cb) {
    DatasetMergeCallback::Proxy _p(AzDatasetMergeCallback_from(cb));
    return _p;
}

inline void DatasetMergeCallback::delete_() {
    AzDatasetMergeCallback_delete(&inner_);
}

inline DatasetMergeCallback DatasetMergeCallback::clone() const {
    DatasetMergeCallback::Proxy _p(AzDatasetMergeCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDatasetMergeCallback_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzFocusVisuals_toDbgString(&inner_));
    return _p;
}

inline DragData DragData::new_() {
    DragData::Proxy _p(AzDragData_new());
    return _p;
}

inline DragData DragData::default_() {
    DragData::Proxy _p(AzDragData_default());
    return _p;
}

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 {
    DragData::Proxy _p(AzDragData_clone(&inner_));
    return _p;
}

inline bool DragData::partialEq(const DragData& b) const {
    return AzDragData_partialEq(&inner_, b.ptr());
}

inline String DragData::toDbgString() const {
    String::Proxy _p(AzDragData_toDbgString(&inner_));
    return _p;
}

inline void VirtualViewCallback::delete_() {
    AzVirtualViewCallback_delete(&inner_);
}

inline VirtualViewCallback VirtualViewCallback::clone() const {
    VirtualViewCallback::Proxy _p(AzVirtualViewCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzVirtualViewCallback_toDbgString(&inner_));
    return _p;
}

inline void RibbonOnTabClickCallback::delete_() {
    AzRibbonOnTabClickCallback_delete(&inner_);
}

inline RibbonOnTabClickCallback RibbonOnTabClickCallback::clone() const {
    RibbonOnTabClickCallback::Proxy _p(AzRibbonOnTabClickCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzRibbonOnTabClickCallback_toDbgString(&inner_));
    return _p;
}

inline void TreeViewOnNodeClickCallback::delete_() {
    AzTreeViewOnNodeClickCallback_delete(&inner_);
}

inline TreeViewOnNodeClickCallback TreeViewOnNodeClickCallback::clone() const {
    TreeViewOnNodeClickCallback::Proxy _p(AzTreeViewOnNodeClickCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTreeViewOnNodeClickCallback_toDbgString(&inner_));
    return _p;
}

inline void OnVideoFrameCallback::delete_() {
    AzOnVideoFrameCallback_delete(&inner_);
}

inline OnVideoFrameCallback OnVideoFrameCallback::clone() const {
    OnVideoFrameCallback::Proxy _p(AzOnVideoFrameCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOnVideoFrameCallback_toDbgString(&inner_));
    return _p;
}

inline void MapPinTapCallback::delete_() {
    AzMapPinTapCallback_delete(&inner_);
}

inline MapPinTapCallback MapPinTapCallback::clone() const {
    MapPinTapCallback::Proxy _p(AzMapPinTapCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMapPinTapCallback_toDbgString(&inner_));
    return _p;
}

inline void OnAudioFrameCallback::delete_() {
    AzOnAudioFrameCallback_delete(&inner_);
}

inline OnAudioFrameCallback OnAudioFrameCallback::clone() const {
    OnAudioFrameCallback::Proxy _p(AzOnAudioFrameCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOnAudioFrameCallback_toDbgString(&inner_));
    return _p;
}

inline Menu Menu::create(MenuItemVec items) {
    Menu::Proxy _p(AzMenu_create(items.release()));
    return _p;
}

inline Menu Menu::default_() {
    Menu::Proxy _p(AzMenu_default());
    return _p;
}

inline void Menu::set_popup_position(AzMenuPopupPosition position) {
    AzMenu_setPopupPosition(&inner_, position);
}

inline Menu Menu::with_popup_position(AzMenuPopupPosition position) const {
    Menu::Proxy _p(AzMenu_withPopupPosition(inner_, position));
    return _p;
}

inline void Menu::delete_() {
    AzMenu_delete(&inner_);
}

inline Menu Menu::clone() const {
    Menu::Proxy _p(AzMenu_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMenu_toDbgString(&inner_));
    return _p;
}

inline Css Css::empty() {
    Css::Proxy _p(AzCss_empty());
    return _p;
}

inline Css Css::from_string(String s) {
    Css::Proxy _p(AzCss_fromString(s.release()));
    return _p;
}

inline Css Css::default_() {
    Css::Proxy _p(AzCss_default());
    return _p;
}

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 {
    Css::Proxy _p(AzCss_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCss_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleBoxShadow_toDbgString(&inner_));
    return _p;
}

inline LinearGradient LinearGradient::default_() {
    LinearGradient::Proxy _p(AzLinearGradient_default());
    return _p;
}

inline void LinearGradient::delete_() {
    AzLinearGradient_delete(&inner_);
}

inline LinearGradient LinearGradient::clone() const {
    LinearGradient::Proxy _p(AzLinearGradient_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLinearGradient_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleBackgroundPosition_toDbgString(&inner_));
    return _p;
}

inline GridTemplate GridTemplate::default_() {
    GridTemplate::Proxy _p(AzGridTemplate_default());
    return _p;
}

inline void GridTemplate::delete_() {
    AzGridTemplate_delete(&inner_);
}

inline GridTemplate GridTemplate::clone() const {
    GridTemplate::Proxy _p(AzGridTemplate_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGridTemplate_toDbgString(&inner_));
    return _p;
}

inline GridAutoTracks GridAutoTracks::default_() {
    GridAutoTracks::Proxy _p(AzGridAutoTracks_default());
    return _p;
}

inline void GridAutoTracks::delete_() {
    AzGridAutoTracks_delete(&inner_);
}

inline GridAutoTracks GridAutoTracks::clone() const {
    GridAutoTracks::Proxy _p(AzGridAutoTracks_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGridAutoTracks_toDbgString(&inner_));
    return _p;
}

inline StyledDom StyledDom::default_() {
    StyledDom::Proxy _p(AzStyledDom_default());
    return _p;
}

inline void StyledDom::append_child(StyledDom other) {
    AzStyledDom_appendChild(&inner_, other.release());
}

inline StyledDom StyledDom::with_child(StyledDom other) const {
    StyledDom::Proxy _p(AzStyledDom_withChild(inner_, other.release()));
    return _p;
}

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 {
    StyledDom::Proxy _p(AzStyledDom_withMenuBar(inner_, menu_bar.release()));
    return _p;
}

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 {
    StyledDom::Proxy _p(AzStyledDom_withContextMenu(inner_, context_menu.release()));
    return _p;
}

inline ContentGroup StyledDom::get_rects_in_rendering_order() const {
    ContentGroup::Proxy _p(AzStyledDom_getRectsInRenderingOrder(&inner_));
    return _p;
}

inline StyledDom StyledDom::swap_with_default() {
    StyledDom::Proxy _p(AzStyledDom_swapWithDefault(&inner_));
    return _p;
}

inline void StyledDom::delete_() {
    AzStyledDom_delete(&inner_);
}

inline StyledDom StyledDom::clone() const {
    StyledDom::Proxy _p(AzStyledDom_clone(&inner_));
    return _p;
}

inline bool StyledDom::partialEq(const StyledDom& b) const {
    return AzStyledDom_partialEq(&inner_, b.ptr());
}

inline String StyledDom::toDbgString() const {
    String::Proxy _p(AzStyledDom_toDbgString(&inner_));
    return _p;
}

inline void VertexLayout::delete_() {
    AzVertexLayout_delete(&inner_);
}

inline VertexLayout VertexLayout::clone() const {
    VertexLayout::Proxy _p(AzVertexLayout_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzVertexLayout_toDbgString(&inner_));
    return _p;
}

inline void ContentGroup::delete_() {
    AzContentGroup_delete(&inner_);
}

inline ContentGroup ContentGroup::clone() const {
    ContentGroup::Proxy _p(AzContentGroup_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzContentGroup_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSafeAreaInsets_toDbgString(&inner_));
    return _p;
}

inline GridTemplateAreas GridTemplateAreas::default_() {
    GridTemplateAreas::Proxy _p(AzGridTemplateAreas_default());
    return _p;
}

inline void GridTemplateAreas::delete_() {
    AzGridTemplateAreas_delete(&inner_);
}

inline GridTemplateAreas GridTemplateAreas::clone() const {
    GridTemplateAreas::Proxy _p(AzGridTemplateAreas_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGridTemplateAreas_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleObjectPosition_toDbgString(&inner_));
    return _p;
}

inline void FileInputOnPathChangeCallback::delete_() {
    AzFileInputOnPathChangeCallback_delete(&inner_);
}

inline FileInputOnPathChangeCallback FileInputOnPathChangeCallback::clone() const {
    FileInputOnPathChangeCallback::Proxy _p(AzFileInputOnPathChangeCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzFileInputOnPathChangeCallback_toDbgString(&inner_));
    return _p;
}

inline void ColorInputOnValueChangeCallback::delete_() {
    AzColorInputOnValueChangeCallback_delete(&inner_);
}

inline ColorInputOnValueChangeCallback ColorInputOnValueChangeCallback::clone() const {
    ColorInputOnValueChangeCallback::Proxy _p(AzColorInputOnValueChangeCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzColorInputOnValueChangeCallback_toDbgString(&inner_));
    return _p;
}

inline void TextInputOnTextInputCallback::delete_() {
    AzTextInputOnTextInputCallback_delete(&inner_);
}

inline TextInputOnTextInputCallback TextInputOnTextInputCallback::clone() const {
    TextInputOnTextInputCallback::Proxy _p(AzTextInputOnTextInputCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTextInputOnTextInputCallback_toDbgString(&inner_));
    return _p;
}

inline void TextInputOnFocusLostCallback::delete_() {
    AzTextInputOnFocusLostCallback_delete(&inner_);
}

inline TextInputOnFocusLostCallback TextInputOnFocusLostCallback::clone() const {
    TextInputOnFocusLostCallback::Proxy _p(AzTextInputOnFocusLostCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTextInputOnFocusLostCallback_toDbgString(&inner_));
    return _p;
}

inline void NumberInputOnValueChangeCallback::delete_() {
    AzNumberInputOnValueChangeCallback_delete(&inner_);
}

inline NumberInputOnValueChangeCallback NumberInputOnValueChangeCallback::clone() const {
    NumberInputOnValueChangeCallback::Proxy _p(AzNumberInputOnValueChangeCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNumberInputOnValueChangeCallback_toDbgString(&inner_));
    return _p;
}

inline void NumberInputOnFocusLostCallback::delete_() {
    AzNumberInputOnFocusLostCallback_delete(&inner_);
}

inline NumberInputOnFocusLostCallback NumberInputOnFocusLostCallback::clone() const {
    NumberInputOnFocusLostCallback::Proxy _p(AzNumberInputOnFocusLostCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNumberInputOnFocusLostCallback_toDbgString(&inner_));
    return _p;
}

inline ProgressBar ProgressBar::create(float percent_done) {
    ProgressBar::Proxy _p(AzProgressBar_create(percent_done));
    return _p;
}

inline void ProgressBar::set_height(PixelValue height) {
    AzProgressBar_setHeight(&inner_, height.release());
}

inline ProgressBar ProgressBar::with_height(PixelValue height) const {
    ProgressBar::Proxy _p(AzProgressBar_withHeight(inner_, height.release()));
    return _p;
}

inline void ProgressBar::set_container_background(StyleBackgroundContentVec background) {
    AzProgressBar_setContainerBackground(&inner_, background.release());
}

inline ProgressBar ProgressBar::with_container_style(StyleBackgroundContentVec background) const {
    ProgressBar::Proxy _p(AzProgressBar_withContainerStyle(inner_, background.release()));
    return _p;
}

inline void ProgressBar::set_bar_background(StyleBackgroundContentVec background) {
    AzProgressBar_setBarBackground(&inner_, background.release());
}

inline ProgressBar ProgressBar::with_bar_background(StyleBackgroundContentVec background) const {
    ProgressBar::Proxy _p(AzProgressBar_withBarBackground(inner_, background.release()));
    return _p;
}

inline Dom ProgressBar::dom() const {
    Dom::Proxy _p(AzProgressBar_dom(inner_));
    return _p;
}

inline void ProgressBar::delete_() {
    AzProgressBar_delete(&inner_);
}

inline ProgressBar ProgressBar::clone() const {
    ProgressBar::Proxy _p(AzProgressBar_clone(&inner_));
    return _p;
}

inline String ProgressBar::toDbgString() const {
    String::Proxy _p(AzProgressBar_toDbgString(&inner_));
    return _p;
}

inline void ListViewState::delete_() {
    AzListViewState_delete(&inner_);
}

inline ListViewState ListViewState::clone() const {
    ListViewState::Proxy _p(AzListViewState_clone(&inner_));
    return _p;
}

inline String ListViewState::toDbgString() const {
    String::Proxy _p(AzListViewState_toDbgString(&inner_));
    return _p;
}

inline void VideoFrame::delete_() {
    AzVideoFrame_delete(&inner_);
}

inline VideoFrame VideoFrame::clone() const {
    VideoFrame::Proxy _p(AzVideoFrame_clone(&inner_));
    return _p;
}

inline bool VideoFrame::partialEq(const VideoFrame& b) const {
    return AzVideoFrame_partialEq(&inner_, b.ptr());
}

inline String VideoFrame::toDbgString() const {
    String::Proxy _p(AzVideoFrame_toDbgString(&inner_));
    return _p;
}

inline void MapViewportChangedCallback::delete_() {
    AzMapViewportChangedCallback_delete(&inner_);
}

inline MapViewportChangedCallback MapViewportChangedCallback::clone() const {
    MapViewportChangedCallback::Proxy _p(AzMapViewportChangedCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMapViewportChangedCallback_toDbgString(&inner_));
    return _p;
}

inline size_t AudioFrame::frame_count() const {
    return AzAudioFrame_frameCount(&inner_);
}

inline void AudioFrame::delete_() {
    AzAudioFrame_delete(&inner_);
}

inline AudioFrame AudioFrame::clone() const {
    AudioFrame::Proxy _p(AzAudioFrame_clone(&inner_));
    return _p;
}

inline bool AudioFrame::partialEq(const AudioFrame& b) const {
    return AzAudioFrame_partialEq(&inner_, b.ptr());
}

inline String AudioFrame::toDbgString() const {
    String::Proxy _p(AzAudioFrame_toDbgString(&inner_));
    return _p;
}

inline void GetProgramBinaryReturn::delete_() {
    AzGetProgramBinaryReturn_delete(&inner_);
}

inline GetProgramBinaryReturn GetProgramBinaryReturn::clone() const {
    GetProgramBinaryReturn::Proxy _p(AzGetProgramBinaryReturn_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGetProgramBinaryReturn_toDbgString(&inner_));
    return _p;
}

inline void LoadedFontSource::delete_() {
    AzLoadedFontSource_delete(&inner_);
}

inline LoadedFontSource LoadedFontSource::clone() const {
    LoadedFontSource::Proxy _p(AzLoadedFontSource_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLoadedFontSource_toDbgString(&inner_));
    return _p;
}

inline TessellatedSvgNode TessellatedSvgNode::empty() {
    TessellatedSvgNode::Proxy _p(AzTessellatedSvgNode_empty());
    return _p;
}

inline TessellatedSvgNode TessellatedSvgNode::from_nodes(TessellatedSvgNodeVecRef nodes) {
    TessellatedSvgNode::Proxy _p(AzTessellatedSvgNode_fromNodes(nodes.release()));
    return _p;
}

inline TessellatedSvgNode TessellatedSvgNode::default_() {
    TessellatedSvgNode::Proxy _p(AzTessellatedSvgNode_default());
    return _p;
}

inline void TessellatedSvgNode::delete_() {
    AzTessellatedSvgNode_delete(&inner_);
}

inline TessellatedSvgNode TessellatedSvgNode::clone() const {
    TessellatedSvgNode::Proxy _p(AzTessellatedSvgNode_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTessellatedSvgNode_toDbgString(&inner_));
    return _p;
}

inline CssPath CssPath::default_() {
    CssPath::Proxy _p(AzCssPath_default());
    return _p;
}

inline void CssPath::delete_() {
    AzCssPath_delete(&inner_);
}

inline CssPath CssPath::clone() const {
    CssPath::Proxy _p(AzCssPath_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCssPath_toDbgString(&inner_));
    return _p;
}

inline void ShapePolygon::delete_() {
    AzShapePolygon_delete(&inner_);
}

inline ShapePolygon ShapePolygon::clone() const {
    ShapePolygon::Proxy _p(AzShapePolygon_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzShapePolygon_toDbgString(&inner_));
    return _p;
}

inline SvgPath SvgPath::create(SvgPathElementVec items) {
    SvgPath::Proxy _p(AzSvgPath_create(items.release()));
    return _p;
}

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 {
    SvgPath::Proxy _p(AzSvgPath_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgPath_toDbgString(&inner_));
    return _p;
}

inline SvgMultiPolygon SvgMultiPolygon::create(SvgPathVec rings) {
    SvgMultiPolygon::Proxy _p(AzSvgMultiPolygon_create(rings.release()));
    return _p;
}

inline SvgRect SvgMultiPolygon::get_bounds() const {
    return SvgRect(AzSvgMultiPolygon_getBounds(&inner_));
}

inline TessellatedSvgNode SvgMultiPolygon::tessellate_fill(SvgFillStyle fill_style) const {
    TessellatedSvgNode::Proxy _p(AzSvgMultiPolygon_tessellateFill(&inner_, fill_style.release()));
    return _p;
}

inline TessellatedSvgNode SvgMultiPolygon::tessellate_stroke(SvgStrokeStyle stroke_style) const {
    TessellatedSvgNode::Proxy _p(AzSvgMultiPolygon_tessellateStroke(&inner_, stroke_style.release()));
    return _p;
}

inline void SvgMultiPolygon::delete_() {
    AzSvgMultiPolygon_delete(&inner_);
}

inline SvgMultiPolygon SvgMultiPolygon::clone() const {
    SvgMultiPolygon::Proxy _p(AzSvgMultiPolygon_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgMultiPolygon_toDbgString(&inner_));
    return _p;
}

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 {
    ParsedSvg::Proxy _p(AzParsedSvg_clone(&inner_));
    return _p;
}

inline String ParsedSvg::toDbgString() const {
    String::Proxy _p(AzParsedSvg_toDbgString(&inner_));
    return _p;
}

inline String String::copy_from_bytes(const uint8_t* ptr, size_t start, size_t len) {
    String::Proxy _p(AzString_copyFromBytes(ptr, start, len));
    return _p;
}

inline String String::from_c_str(const int8_t* ptr) {
    String::Proxy _p(AzString_fromCStr(ptr));
    return _p;
}

inline String String::default_() {
    String::Proxy _p(AzString_default());
    return _p;
}

inline U8Vec String::to_c_str() const {
    U8Vec::Proxy _p(AzString_toCStr(&inner_));
    return _p;
}

inline String String::from_utf16_le(const uint8_t* ptr, size_t len) {
    String::Proxy _p(AzString_fromUtf16Le(ptr, len));
    return _p;
}

inline String String::from_utf16_be(const uint8_t* ptr, size_t len) {
    String::Proxy _p(AzString_fromUtf16Be(ptr, len));
    return _p;
}

inline String String::from_utf8_lossy(const uint8_t* ptr, size_t len) {
    String::Proxy _p(AzString_fromUtf8Lossy(ptr, len));
    return _p;
}

inline String String::from_utf8(const uint8_t* ptr, size_t len) {
    String::Proxy _p(AzString_fromUtf8(ptr, len));
    return _p;
}

inline void String::delete_() {
    AzString_delete(&inner_);
}

inline String String::clone() const {
    String::Proxy _p(AzString_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzString_toDbgString(&inner_));
    return _p;
}

inline void InvalidCharMultipleError::delete_() {
    AzInvalidCharMultipleError_delete(&inner_);
}

inline InvalidCharMultipleError InvalidCharMultipleError::clone() const {
    InvalidCharMultipleError::Proxy _p(AzInvalidCharMultipleError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzInvalidCharMultipleError_toDbgString(&inner_));
    return _p;
}

inline void FluentZipLoadResult::delete_() {
    AzFluentZipLoadResult_delete(&inner_);
}

inline FluentZipLoadResult FluentZipLoadResult::clone() const {
    FluentZipLoadResult::Proxy _p(AzFluentZipLoadResult_clone(&inner_));
    return _p;
}

inline String FluentZipLoadResult::toDbgString() const {
    String::Proxy _p(AzFluentZipLoadResult_toDbgString(&inner_));
    return _p;
}

inline bool ThreadSender::send(AzThreadReceiveMsg msg) {
    return AzThreadSender_send(&inner_, msg);
}

inline void ThreadSender::delete_() {
    AzThreadSender_delete(&inner_);
}

inline ThreadSender ThreadSender::clone() const {
    ThreadSender::Proxy _p(AzThreadSender_clone(&inner_));
    return _p;
}

inline String ThreadSender::toDbgString() const {
    String::Proxy _p(AzThreadSender_toDbgString(&inner_));
    return _p;
}

inline OptionThreadSendMsg ThreadReceiver::recv() {
    return OptionThreadSendMsg(AzThreadReceiver_recv(&inner_));
}

inline void ThreadReceiver::delete_() {
    AzThreadReceiver_delete(&inner_);
}

inline ThreadReceiver ThreadReceiver::clone() const {
    ThreadReceiver::Proxy _p(AzThreadReceiver_clone(&inner_));
    return _p;
}

inline String ThreadReceiver::toDbgString() const {
    String::Proxy _p(AzThreadReceiver_toDbgString(&inner_));
    return _p;
}

inline void DbRows::delete_() {
    AzDbRows_delete(&inner_);
}

inline DbRows DbRows::clone() const {
    DbRows::Proxy _p(AzDbRows_clone(&inner_));
    return _p;
}

inline bool DbRows::partialEq(const DbRows& b) const {
    return AzDbRows_partialEq(&inner_, b.ptr());
}

inline String DbRows::toDbgString() const {
    String::Proxy _p(AzDbRows_toDbgString(&inner_));
    return _p;
}

inline ComponentMap ComponentMap::create() {
    ComponentMap::Proxy _p(AzComponentMap_create());
    return _p;
}

inline ComponentMap ComponentMap::default_() {
    ComponentMap::Proxy _p(AzComponentMap_default());
    return _p;
}

inline void ComponentMap::delete_() {
    AzComponentMap_delete(&inner_);
}

inline ComponentMap ComponentMap::clone() const {
    ComponentMap::Proxy _p(AzComponentMap_clone(&inner_));
    return _p;
}

inline String ComponentMap::toDbgString() const {
    String::Proxy _p(AzComponentMap_toDbgString(&inner_));
    return _p;
}

inline void WaylandTheme::delete_() {
    AzWaylandTheme_delete(&inner_);
}

inline WaylandTheme WaylandTheme::clone() const {
    WaylandTheme::Proxy _p(AzWaylandTheme_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzWaylandTheme_toDbgString(&inner_));
    return _p;
}

inline void MimeTypeHint::delete_() {
    AzMimeTypeHint_delete(&inner_);
}

inline MimeTypeHint MimeTypeHint::clone() const {
    MimeTypeHint::Proxy _p(AzMimeTypeHint_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMimeTypeHint_toDbgString(&inner_));
    return _p;
}

inline MimeTypeData MimeTypeData::default_() {
    MimeTypeData::Proxy _p(AzMimeTypeData_default());
    return _p;
}

inline void MimeTypeData::delete_() {
    AzMimeTypeData_delete(&inner_);
}

inline MimeTypeData MimeTypeData::clone() const {
    MimeTypeData::Proxy _p(AzMimeTypeData_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMimeTypeData_toDbgString(&inner_));
    return _p;
}

inline void HttpHeader::delete_() {
    AzHttpHeader_delete(&inner_);
}

inline HttpHeader HttpHeader::clone() const {
    HttpHeader::Proxy _p(AzHttpHeader_clone(&inner_));
    return _p;
}

inline bool HttpHeader::partialEq(const HttpHeader& b) const {
    return AzHttpHeader_partialEq(&inner_, b.ptr());
}

inline String HttpHeader::toDbgString() const {
    String::Proxy _p(AzHttpHeader_toDbgString(&inner_));
    return _p;
}

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 {
    HttpResponse::Proxy _p(AzHttpResponse_clone(&inner_));
    return _p;
}

inline bool HttpResponse::partialEq(const HttpResponse& b) const {
    return AzHttpResponse_partialEq(&inner_, b.ptr());
}

inline String HttpResponse::toDbgString() const {
    String::Proxy _p(AzHttpResponse_toDbgString(&inner_));
    return _p;
}

inline HttpRequestConfig HttpRequestConfig::create() {
    HttpRequestConfig::Proxy _p(AzHttpRequestConfig_create());
    return _p;
}

inline HttpRequestConfig HttpRequestConfig::default_() {
    HttpRequestConfig::Proxy _p(AzHttpRequestConfig_default());
    return _p;
}

inline HttpRequestConfig HttpRequestConfig::with_timeout(uint64_t secs) const {
    HttpRequestConfig::Proxy _p(AzHttpRequestConfig_withTimeout(inner_, secs));
    return _p;
}

inline HttpRequestConfig HttpRequestConfig::with_max_size(uint64_t max_bytes) const {
    HttpRequestConfig::Proxy _p(AzHttpRequestConfig_withMaxSize(inner_, max_bytes));
    return _p;
}

inline HttpRequestConfig HttpRequestConfig::with_user_agent(String ua) const {
    HttpRequestConfig::Proxy _p(AzHttpRequestConfig_withUserAgent(inner_, ua.release()));
    return _p;
}

inline HttpRequestConfig HttpRequestConfig::with_header(String name, String value) const {
    HttpRequestConfig::Proxy _p(AzHttpRequestConfig_withHeader(inner_, name.release(), value.release()));
    return _p;
}

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 {
    HttpRequestConfig::Proxy _p(AzHttpRequestConfig_clone(&inner_));
    return _p;
}

inline String HttpRequestConfig::toDbgString() const {
    String::Proxy _p(AzHttpRequestConfig_toDbgString(&inner_));
    return _p;
}

inline TimerCallbackInfo TimerCallbackInfo::create(CallbackInfo callback_info, OptionDomNodeId node_id, AzInstant frame_start, size_t call_count, bool is_about_to_finish) {
    TimerCallbackInfo::Proxy _p(AzTimerCallbackInfo_create(callback_info.release(), node_id.release(), frame_start, call_count, is_about_to_finish));
    return _p;
}

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 {
    TimerCallbackInfo::Proxy _p(AzTimerCallbackInfo_clone(&inner_));
    return _p;
}

inline void CoreCallbackData::delete_() {
    AzCoreCallbackData_delete(&inner_);
}

inline CoreCallbackData CoreCallbackData::clone() const {
    CoreCallbackData::Proxy _p(AzCoreCallbackData_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCoreCallbackData_toDbgString(&inner_));
    return _p;
}

inline void CoreMenuCallback::delete_() {
    AzCoreMenuCallback_delete(&inner_);
}

inline CoreMenuCallback CoreMenuCallback::clone() const {
    CoreMenuCallback::Proxy _p(AzCoreMenuCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCoreMenuCallback_toDbgString(&inner_));
    return _p;
}

inline void AttributeNameValue::delete_() {
    AzAttributeNameValue_delete(&inner_);
}

inline AttributeNameValue AttributeNameValue::clone() const {
    AttributeNameValue::Proxy _p(AzAttributeNameValue_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzAttributeNameValue_toDbgString(&inner_));
    return _p;
}

inline XmlTagName XmlTagName::default_() {
    XmlTagName::Proxy _p(AzXmlTagName_default());
    return _p;
}

inline void XmlTagName::delete_() {
    AzXmlTagName_delete(&inner_);
}

inline XmlTagName XmlTagName::clone() const {
    XmlTagName::Proxy _p(AzXmlTagName_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzXmlTagName_toDbgString(&inner_));
    return _p;
}

inline void VertexAttribute::delete_() {
    AzVertexAttribute_delete(&inner_);
}

inline VertexAttribute VertexAttribute::clone() const {
    VertexAttribute::Proxy _p(AzVertexAttribute_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzVertexAttribute_toDbgString(&inner_));
    return _p;
}

inline void CoreImageCallback::delete_() {
    AzCoreImageCallback_delete(&inner_);
}

inline CoreImageCallback CoreImageCallback::clone() const {
    CoreImageCallback::Proxy _p(AzCoreImageCallback_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCoreImageCallback_toDbgString(&inner_));
    return _p;
}

inline void ClipboardContent::delete_() {
    AzClipboardContent_delete(&inner_);
}

inline ClipboardContent ClipboardContent::clone() const {
    ClipboardContent::Proxy _p(AzClipboardContent_clone(&inner_));
    return _p;
}

inline bool ClipboardContent::partialEq(const ClipboardContent& b) const {
    return AzClipboardContent_partialEq(&inner_, b.ptr());
}

inline String ClipboardContent::toDbgString() const {
    String::Proxy _p(AzClipboardContent_toDbgString(&inner_));
    return _p;
}

inline void TextInputOnVirtualKeyDown::delete_() {
    AzTextInputOnVirtualKeyDown_delete(&inner_);
}

inline TextInputOnVirtualKeyDown TextInputOnVirtualKeyDown::clone() const {
    TextInputOnVirtualKeyDown::Proxy _p(AzTextInputOnVirtualKeyDown_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTextInputOnVirtualKeyDown_toDbgString(&inner_));
    return _p;
}

inline void TextOpSetSelection::delete_() {
    AzTextOpSetSelection_delete(&inner_);
}

inline TextOpSetSelection TextOpSetSelection::clone() const {
    TextOpSetSelection::Proxy _p(AzTextOpSetSelection_clone(&inner_));
    return _p;
}

inline String TextOpSetSelection::toDbgString() const {
    String::Proxy _p(AzTextOpSetSelection_toDbgString(&inner_));
    return _p;
}

inline void NodeStateSnapshot::delete_() {
    AzNodeStateSnapshot_delete(&inner_);
}

inline NodeStateSnapshot NodeStateSnapshot::clone() const {
    NodeStateSnapshot::Proxy _p(AzNodeStateSnapshot_clone(&inner_));
    return _p;
}

inline String NodeStateSnapshot::toDbgString() const {
    String::Proxy _p(AzNodeStateSnapshot_toDbgString(&inner_));
    return _p;
}

inline void ParseIntErrorWithInput::delete_() {
    AzParseIntErrorWithInput_delete(&inner_);
}

inline ParseIntErrorWithInput ParseIntErrorWithInput::clone() const {
    ParseIntErrorWithInput::Proxy _p(AzParseIntErrorWithInput_clone(&inner_));
    return _p;
}

inline bool ParseIntErrorWithInput::partialEq(const ParseIntErrorWithInput& b) const {
    return AzParseIntErrorWithInput_partialEq(&inner_, b.ptr());
}

inline String ParseIntErrorWithInput::toDbgString() const {
    String::Proxy _p(AzParseIntErrorWithInput_toDbgString(&inner_));
    return _p;
}

inline void ParseFloatErrorWithInput::delete_() {
    AzParseFloatErrorWithInput_delete(&inner_);
}

inline ParseFloatErrorWithInput ParseFloatErrorWithInput::clone() const {
    ParseFloatErrorWithInput::Proxy _p(AzParseFloatErrorWithInput_clone(&inner_));
    return _p;
}

inline bool ParseFloatErrorWithInput::partialEq(const ParseFloatErrorWithInput& b) const {
    return AzParseFloatErrorWithInput_partialEq(&inner_, b.ptr());
}

inline String ParseFloatErrorWithInput::toDbgString() const {
    String::Proxy _p(AzParseFloatErrorWithInput_toDbgString(&inner_));
    return _p;
}

inline CssRuleBlock CssRuleBlock::default_() {
    CssRuleBlock::Proxy _p(AzCssRuleBlock_default());
    return _p;
}

inline void CssRuleBlock::delete_() {
    AzCssRuleBlock_delete(&inner_);
}

inline CssRuleBlock CssRuleBlock::clone() const {
    CssRuleBlock::Proxy _p(AzCssRuleBlock_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCssRuleBlock_toDbgString(&inner_));
    return _p;
}

inline RadialGradient RadialGradient::default_() {
    RadialGradient::Proxy _p(AzRadialGradient_default());
    return _p;
}

inline void RadialGradient::delete_() {
    AzRadialGradient_delete(&inner_);
}

inline RadialGradient RadialGradient::clone() const {
    RadialGradient::Proxy _p(AzRadialGradient_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzRadialGradient_toDbgString(&inner_));
    return _p;
}

inline ConicGradient ConicGradient::default_() {
    ConicGradient::Proxy _p(AzConicGradient_default());
    return _p;
}

inline void ConicGradient::delete_() {
    AzConicGradient_delete(&inner_);
}

inline ConicGradient ConicGradient::clone() const {
    ConicGradient::Proxy _p(AzConicGradient_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzConicGradient_toDbgString(&inner_));
    return _p;
}

inline CounterReset CounterReset::default_() {
    CounterReset::Proxy _p(AzCounterReset_default());
    return _p;
}

inline void CounterReset::delete_() {
    AzCounterReset_delete(&inner_);
}

inline CounterReset CounterReset::clone() const {
    CounterReset::Proxy _p(AzCounterReset_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCounterReset_toDbgString(&inner_));
    return _p;
}

inline Content Content::default_() {
    Content::Proxy _p(AzContent_default());
    return _p;
}

inline void Content::delete_() {
    AzContent_delete(&inner_);
}

inline Content Content::clone() const {
    Content::Proxy _p(AzContent_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzContent_toDbgString(&inner_));
    return _p;
}

inline CounterIncrement CounterIncrement::default_() {
    CounterIncrement::Proxy _p(AzCounterIncrement_default());
    return _p;
}

inline void CounterIncrement::delete_() {
    AzCounterIncrement_delete(&inner_);
}

inline CounterIncrement CounterIncrement::clone() const {
    CounterIncrement::Proxy _p(AzCounterIncrement_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCounterIncrement_toDbgString(&inner_));
    return _p;
}

inline StyleHyphenationLanguage StyleHyphenationLanguage::default_() {
    StyleHyphenationLanguage::Proxy _p(AzStyleHyphenationLanguage_default());
    return _p;
}

inline void StyleHyphenationLanguage::delete_() {
    AzStyleHyphenationLanguage_delete(&inner_);
}

inline StyleHyphenationLanguage StyleHyphenationLanguage::clone() const {
    StyleHyphenationLanguage::Proxy _p(AzStyleHyphenationLanguage_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStyleHyphenationLanguage_toDbgString(&inner_));
    return _p;
}

inline NamedGridLine NamedGridLine::create(String name, OptionI32 span) {
    NamedGridLine::Proxy _p(AzNamedGridLine_create(name.release(), span.release()));
    return _p;
}

inline OptionI32 NamedGridLine::span() const {
    return OptionI32(AzNamedGridLine_span(&inner_));
}

inline void NamedGridLine::delete_() {
    AzNamedGridLine_delete(&inner_);
}

inline NamedGridLine NamedGridLine::clone() const {
    NamedGridLine::Proxy _p(AzNamedGridLine_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNamedGridLine_toDbgString(&inner_));
    return _p;
}

inline void ShapePath::delete_() {
    AzShapePath_delete(&inner_);
}

inline ShapePath ShapePath::clone() const {
    ShapePath::Proxy _p(AzShapePath_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzShapePath_toDbgString(&inner_));
    return _p;
}

inline void TextOpReplaceText::delete_() {
    AzTextOpReplaceText_delete(&inner_);
}

inline TextOpReplaceText TextOpReplaceText::clone() const {
    TextOpReplaceText::Proxy _p(AzTextOpReplaceText_clone(&inner_));
    return _p;
}

inline String TextOpReplaceText::toDbgString() const {
    String::Proxy _p(AzTextOpReplaceText_toDbgString(&inner_));
    return _p;
}

inline void TextOpDeleteText::delete_() {
    AzTextOpDeleteText_delete(&inner_);
}

inline TextOpDeleteText TextOpDeleteText::clone() const {
    TextOpDeleteText::Proxy _p(AzTextOpDeleteText_clone(&inner_));
    return _p;
}

inline String TextOpDeleteText::toDbgString() const {
    String::Proxy _p(AzTextOpDeleteText_toDbgString(&inner_));
    return _p;
}

inline void TextOpSelectAll::delete_() {
    AzTextOpSelectAll_delete(&inner_);
}

inline TextOpSelectAll TextOpSelectAll::clone() const {
    TextOpSelectAll::Proxy _p(AzTextOpSelectAll_clone(&inner_));
    return _p;
}

inline String TextOpSelectAll::toDbgString() const {
    String::Proxy _p(AzTextOpSelectAll_toDbgString(&inner_));
    return _p;
}

inline void TextOpInsertText::delete_() {
    AzTextOpInsertText_delete(&inner_);
}

inline TextOpInsertText TextOpInsertText::clone() const {
    TextOpInsertText::Proxy _p(AzTextOpInsertText_clone(&inner_));
    return _p;
}

inline String TextOpInsertText::toDbgString() const {
    String::Proxy _p(AzTextOpInsertText_toDbgString(&inner_));
    return _p;
}

inline void PendingTextEdit::delete_() {
    AzPendingTextEdit_delete(&inner_);
}

inline PendingTextEdit PendingTextEdit::clone() const {
    PendingTextEdit::Proxy _p(AzPendingTextEdit_clone(&inner_));
    return _p;
}

inline String PendingTextEdit::toDbgString() const {
    String::Proxy _p(AzPendingTextEdit_toDbgString(&inner_));
    return _p;
}

inline NamedFont NamedFont::create(String name, U8Vec bytes) {
    NamedFont::Proxy _p(AzNamedFont_create(name.release(), bytes.release()));
    return _p;
}

inline void NamedFont::delete_() {
    AzNamedFont_delete(&inner_);
}

inline NamedFont NamedFont::clone() const {
    NamedFont::Proxy _p(AzNamedFont_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNamedFont_toDbgString(&inner_));
    return _p;
}

inline void GridAreaDefinition::delete_() {
    AzGridAreaDefinition_delete(&inner_);
}

inline GridAreaDefinition GridAreaDefinition::clone() const {
    GridAreaDefinition::Proxy _p(AzGridAreaDefinition_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGridAreaDefinition_toDbgString(&inner_));
    return _p;
}

inline void InvalidValueErrOwned::delete_() {
    AzInvalidValueErrOwned_delete(&inner_);
}

inline InvalidValueErrOwned InvalidValueErrOwned::clone() const {
    InvalidValueErrOwned::Proxy _p(AzInvalidValueErrOwned_clone(&inner_));
    return _p;
}

inline bool InvalidValueErrOwned::partialEq(const InvalidValueErrOwned& b) const {
    return AzInvalidValueErrOwned_partialEq(&inner_, b.ptr());
}

inline String InvalidValueErrOwned::toDbgString() const {
    String::Proxy _p(AzInvalidValueErrOwned_toDbgString(&inner_));
    return _p;
}

inline void FileTypeList::delete_() {
    AzFileTypeList_delete(&inner_);
}

inline FileTypeList FileTypeList::clone() const {
    FileTypeList::Proxy _p(AzFileTypeList_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzFileTypeList_toDbgString(&inner_));
    return _p;
}

inline MapTileLayer MapTileLayer::default_() {
    MapTileLayer::Proxy _p(AzMapTileLayer_default());
    return _p;
}

inline void MapTileLayer::delete_() {
    AzMapTileLayer_delete(&inner_);
}

inline MapTileLayer MapTileLayer::clone() const {
    MapTileLayer::Proxy _p(AzMapTileLayer_clone(&inner_));
    return _p;
}

inline bool MapTileLayer::partialEq(const MapTileLayer& b) const {
    return AzMapTileLayer_partialEq(&inner_, b.ptr());
}

inline String MapTileLayer::toDbgString() const {
    String::Proxy _p(AzMapTileLayer_toDbgString(&inner_));
    return _p;
}

inline void ButtonOnClick::delete_() {
    AzButtonOnClick_delete(&inner_);
}

inline ButtonOnClick ButtonOnClick::clone() const {
    ButtonOnClick::Proxy _p(AzButtonOnClick_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzButtonOnClick_toDbgString(&inner_));
    return _p;
}

inline void FileInputOnPathChange::delete_() {
    AzFileInputOnPathChange_delete(&inner_);
}

inline FileInputOnPathChange FileInputOnPathChange::clone() const {
    FileInputOnPathChange::Proxy _p(AzFileInputOnPathChange_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzFileInputOnPathChange_toDbgString(&inner_));
    return _p;
}

inline void CheckBoxOnToggle::delete_() {
    AzCheckBoxOnToggle_delete(&inner_);
}

inline CheckBoxOnToggle CheckBoxOnToggle::clone() const {
    CheckBoxOnToggle::Proxy _p(AzCheckBoxOnToggle_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCheckBoxOnToggle_toDbgString(&inner_));
    return _p;
}

inline void DropDownOnChoiceChange::delete_() {
    AzDropDownOnChoiceChange_delete(&inner_);
}

inline DropDownOnChoiceChange DropDownOnChoiceChange::clone() const {
    DropDownOnChoiceChange::Proxy _p(AzDropDownOnChoiceChange_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDropDownOnChoiceChange_toDbgString(&inner_));
    return _p;
}

inline void ColorInputOnValueChange::delete_() {
    AzColorInputOnValueChange_delete(&inner_);
}

inline ColorInputOnValueChange ColorInputOnValueChange::clone() const {
    ColorInputOnValueChange::Proxy _p(AzColorInputOnValueChange_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzColorInputOnValueChange_toDbgString(&inner_));
    return _p;
}

inline void TextInputOnTextInput::delete_() {
    AzTextInputOnTextInput_delete(&inner_);
}

inline TextInputOnTextInput TextInputOnTextInput::clone() const {
    TextInputOnTextInput::Proxy _p(AzTextInputOnTextInput_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTextInputOnTextInput_toDbgString(&inner_));
    return _p;
}

inline void TextInputOnFocusLost::delete_() {
    AzTextInputOnFocusLost_delete(&inner_);
}

inline TextInputOnFocusLost TextInputOnFocusLost::clone() const {
    TextInputOnFocusLost::Proxy _p(AzTextInputOnFocusLost_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTextInputOnFocusLost_toDbgString(&inner_));
    return _p;
}

inline void NumberInputOnValueChange::delete_() {
    AzNumberInputOnValueChange_delete(&inner_);
}

inline NumberInputOnValueChange NumberInputOnValueChange::clone() const {
    NumberInputOnValueChange::Proxy _p(AzNumberInputOnValueChange_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNumberInputOnValueChange_toDbgString(&inner_));
    return _p;
}

inline void NumberInputOnFocusLost::delete_() {
    AzNumberInputOnFocusLost_delete(&inner_);
}

inline NumberInputOnFocusLost NumberInputOnFocusLost::clone() const {
    NumberInputOnFocusLost::Proxy _p(AzNumberInputOnFocusLost_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNumberInputOnFocusLost_toDbgString(&inner_));
    return _p;
}

inline void TabOnClick::delete_() {
    AzTabOnClick_delete(&inner_);
}

inline TabOnClick TabOnClick::clone() const {
    TabOnClick::Proxy _p(AzTabOnClick_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTabOnClick_toDbgString(&inner_));
    return _p;
}

inline void ListViewRow::delete_() {
    AzListViewRow_delete(&inner_);
}

inline ListViewRow ListViewRow::clone() const {
    ListViewRow::Proxy _p(AzListViewRow_clone(&inner_));
    return _p;
}

inline String ListViewRow::toDbgString() const {
    String::Proxy _p(AzListViewRow_toDbgString(&inner_));
    return _p;
}

inline void ListViewOnLazyLoadScroll::delete_() {
    AzListViewOnLazyLoadScroll_delete(&inner_);
}

inline ListViewOnLazyLoadScroll ListViewOnLazyLoadScroll::clone() const {
    ListViewOnLazyLoadScroll::Proxy _p(AzListViewOnLazyLoadScroll_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzListViewOnLazyLoadScroll_toDbgString(&inner_));
    return _p;
}

inline void ListViewOnColumnClick::delete_() {
    AzListViewOnColumnClick_delete(&inner_);
}

inline ListViewOnColumnClick ListViewOnColumnClick::clone() const {
    ListViewOnColumnClick::Proxy _p(AzListViewOnColumnClick_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzListViewOnColumnClick_toDbgString(&inner_));
    return _p;
}

inline void ListViewOnRowClick::delete_() {
    AzListViewOnRowClick_delete(&inner_);
}

inline ListViewOnRowClick ListViewOnRowClick::clone() const {
    ListViewOnRowClick::Proxy _p(AzListViewOnRowClick_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzListViewOnRowClick_toDbgString(&inner_));
    return _p;
}

inline RibbonTab RibbonTab::new_(String label) {
    RibbonTab::Proxy _p(AzRibbonTab_new(label.release()));
    return _p;
}

inline void RibbonTab::add_section(RibbonSection section) {
    AzRibbonTab_addSection(&inner_, section.release());
}

inline RibbonTab RibbonTab::with_section(RibbonSection section) const {
    RibbonTab::Proxy _p(AzRibbonTab_withSection(inner_, section.release()));
    return _p;
}

inline void RibbonTab::delete_() {
    AzRibbonTab_delete(&inner_);
}

inline RibbonTab RibbonTab::clone() const {
    RibbonTab::Proxy _p(AzRibbonTab_clone(&inner_));
    return _p;
}

inline String RibbonTab::toDbgString() const {
    String::Proxy _p(AzRibbonTab_toDbgString(&inner_));
    return _p;
}

inline void RibbonOnTabClick::delete_() {
    AzRibbonOnTabClick_delete(&inner_);
}

inline RibbonOnTabClick RibbonOnTabClick::clone() const {
    RibbonOnTabClick::Proxy _p(AzRibbonOnTabClick_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzRibbonOnTabClick_toDbgString(&inner_));
    return _p;
}

inline TreeViewNode TreeViewNode::new_(String label) {
    TreeViewNode::Proxy _p(AzTreeViewNode_new(label.release()));
    return _p;
}

inline void TreeViewNode::add_child(TreeViewNode child) {
    AzTreeViewNode_addChild(&inner_, child.release());
}

inline TreeViewNode TreeViewNode::with_child(TreeViewNode child) const {
    TreeViewNode::Proxy _p(AzTreeViewNode_withChild(inner_, child.release()));
    return _p;
}

inline TreeViewNode TreeViewNode::with_expanded(bool expanded) const {
    TreeViewNode::Proxy _p(AzTreeViewNode_withExpanded(inner_, expanded));
    return _p;
}

inline TreeViewNode TreeViewNode::with_selected(bool selected) const {
    TreeViewNode::Proxy _p(AzTreeViewNode_withSelected(inner_, selected));
    return _p;
}

inline void TreeViewNode::delete_() {
    AzTreeViewNode_delete(&inner_);
}

inline TreeViewNode TreeViewNode::clone() const {
    TreeViewNode::Proxy _p(AzTreeViewNode_clone(&inner_));
    return _p;
}

inline bool TreeViewNode::partialEq(const TreeViewNode& b) const {
    return AzTreeViewNode_partialEq(&inner_, b.ptr());
}

inline String TreeViewNode::toDbgString() const {
    String::Proxy _p(AzTreeViewNode_toDbgString(&inner_));
    return _p;
}

inline void TreeViewOnNodeClick::delete_() {
    AzTreeViewOnNodeClick_delete(&inner_);
}

inline TreeViewOnNodeClick TreeViewOnNodeClick::clone() const {
    TreeViewOnNodeClick::Proxy _p(AzTreeViewOnNodeClick_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTreeViewOnNodeClick_toDbgString(&inner_));
    return _p;
}

inline Titlebar Titlebar::new_(String title) {
    Titlebar::Proxy _p(AzTitlebar_new(title.release()));
    return _p;
}

inline Titlebar Titlebar::default_() {
    Titlebar::Proxy _p(AzTitlebar_default());
    return _p;
}

inline Dom Titlebar::dom() const {
    Dom::Proxy _p(AzTitlebar_dom(inner_));
    return _p;
}

inline Dom Titlebar::domWithButtons(TitlebarButtons buttons, AzTitlebarButtonSide button_side) const {
    Dom::Proxy _p(AzTitlebar_domWithButtons(inner_, buttons.release(), button_side));
    return _p;
}

inline void Titlebar::delete_() {
    AzTitlebar_delete(&inner_);
}

inline Titlebar Titlebar::clone() const {
    Titlebar::Proxy _p(AzTitlebar_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTitlebar_toDbgString(&inner_));
    return _p;
}

inline void OnVideoFrame::delete_() {
    AzOnVideoFrame_delete(&inner_);
}

inline OnVideoFrame OnVideoFrame::clone() const {
    OnVideoFrame::Proxy _p(AzOnVideoFrame_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOnVideoFrame_toDbgString(&inner_));
    return _p;
}

inline void MapViewportChanged::delete_() {
    AzMapViewportChanged_delete(&inner_);
}

inline MapViewportChanged MapViewportChanged::clone() const {
    MapViewportChanged::Proxy _p(AzMapViewportChanged_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMapViewportChanged_toDbgString(&inner_));
    return _p;
}

inline void OnAudioFrame::delete_() {
    AzOnAudioFrame_delete(&inner_);
}

inline OnAudioFrame OnAudioFrame::clone() const {
    OnAudioFrame::Proxy _p(AzOnAudioFrame_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOnAudioFrame_toDbgString(&inner_));
    return _p;
}

inline void GetActiveAttribReturn::delete_() {
    AzGetActiveAttribReturn_delete(&inner_);
}

inline GetActiveAttribReturn GetActiveAttribReturn::clone() const {
    GetActiveAttribReturn::Proxy _p(AzGetActiveAttribReturn_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGetActiveAttribReturn_toDbgString(&inner_));
    return _p;
}

inline void GetActiveUniformReturn::delete_() {
    AzGetActiveUniformReturn_delete(&inner_);
}

inline GetActiveUniformReturn GetActiveUniformReturn::clone() const {
    GetActiveUniformReturn::Proxy _p(AzGetActiveUniformReturn_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGetActiveUniformReturn_toDbgString(&inner_));
    return _p;
}

inline void VertexArrayObject::delete_() {
    AzVertexArrayObject_delete(&inner_);
}

inline VertexArrayObject VertexArrayObject::clone() const {
    VertexArrayObject::Proxy _p(AzVertexArrayObject_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzVertexArrayObject_toDbgString(&inner_));
    return _p;
}

inline void DebugMessage::delete_() {
    AzDebugMessage_delete(&inner_);
}

inline DebugMessage DebugMessage::clone() const {
    DebugMessage::Proxy _p(AzDebugMessage_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDebugMessage_toDbgString(&inner_));
    return _p;
}

inline RawImage RawImage::empty() {
    RawImage::Proxy _p(AzRawImage_empty());
    return _p;
}

inline RawImage RawImage::allocate_clip_mask(LayoutSize size) {
    RawImage::Proxy _p(AzRawImage_allocateClipMask(size.release()));
    return _p;
}

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 {
    RawImage::Proxy _p(AzRawImage_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzRawImage_toDbgString(&inner_));
    return _p;
}

inline void Route::delete_() {
    AzRoute_delete(&inner_);
}

inline Route Route::clone() const {
    Route::Proxy _p(AzRoute_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzRoute_toDbgString(&inner_));
    return _p;
}

inline void RouteMatch::delete_() {
    AzRouteMatch_delete(&inner_);
}

inline RouteMatch RouteMatch::clone() const {
    RouteMatch::Proxy _p(AzRouteMatch_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzRouteMatch_toDbgString(&inner_));
    return _p;
}

inline LoadedFont LoadedFont::new_(uint64_t font_hash, String family_name, uint32_t num_glyphs, bool has_bytes) {
    LoadedFont::Proxy _p(AzLoadedFont_new(font_hash, family_name.release(), num_glyphs, has_bytes));
    return _p;
}

inline void LoadedFont::delete_() {
    AzLoadedFont_delete(&inner_);
}

inline LoadedFont LoadedFont::clone() const {
    LoadedFont::Proxy _p(AzLoadedFont_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLoadedFont_toDbgString(&inner_));
    return _p;
}

inline FilePath FilePath::create(String path) {
    FilePath::Proxy _p(AzFilePath_create(path.release()));
    return _p;
}

inline FilePath FilePath::empty() {
    FilePath::Proxy _p(AzFilePath_empty());
    return _p;
}

inline FilePath FilePath::from_str(String s) {
    FilePath::Proxy _p(AzFilePath_fromStr(s.release()));
    return _p;
}

inline FilePath FilePath::get_temp_dir() {
    FilePath::Proxy _p(AzFilePath_getTempDir());
    return _p;
}

inline FilePath FilePath::from(String s) {
    FilePath::Proxy _p(AzFilePath_from(s.release()));
    return _p;
}

inline FilePath FilePath::default_() {
    FilePath::Proxy _p(AzFilePath_default());
    return _p;
}

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 {
    FilePath::Proxy _p(AzFilePath_join(&inner_, other.release()));
    return _p;
}

inline FilePath FilePath::join_str(String component) const {
    FilePath::Proxy _p(AzFilePath_joinStr(&inner_, component.release()));
    return _p;
}

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 {
    String::Proxy _p(AzFilePath_asString(&inner_));
    return _p;
}

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 {
    FilePath::Proxy _p(AzFilePath_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzFilePath_toDbgString(&inner_));
    return _p;
}

inline StringPair StringPair::default_() {
    StringPair::Proxy _p(AzStringPair_default());
    return _p;
}

inline void StringPair::delete_() {
    AzStringPair_delete(&inner_);
}

inline StringPair StringPair::clone() const {
    StringPair::Proxy _p(AzStringPair_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStringPair_toDbgString(&inner_));
    return _p;
}

inline StringSet StringSet::default_() {
    StringSet::Proxy _p(AzStringSet_default());
    return _p;
}

inline void StringSet::delete_() {
    AzStringSet_delete(&inner_);
}

inline StringSet StringSet::clone() const {
    StringSet::Proxy _p(AzStringSet_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStringSet_toDbgString(&inner_));
    return _p;
}

inline void DuplicatedNamespaceError::delete_() {
    AzDuplicatedNamespaceError_delete(&inner_);
}

inline DuplicatedNamespaceError DuplicatedNamespaceError::clone() const {
    DuplicatedNamespaceError::Proxy _p(AzDuplicatedNamespaceError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDuplicatedNamespaceError_toDbgString(&inner_));
    return _p;
}

inline void UnknownNamespaceError::delete_() {
    AzUnknownNamespaceError_delete(&inner_);
}

inline UnknownNamespaceError UnknownNamespaceError::clone() const {
    UnknownNamespaceError::Proxy _p(AzUnknownNamespaceError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzUnknownNamespaceError_toDbgString(&inner_));
    return _p;
}

inline void UnexpectedCloseTagError::delete_() {
    AzUnexpectedCloseTagError_delete(&inner_);
}

inline UnexpectedCloseTagError UnexpectedCloseTagError::clone() const {
    UnexpectedCloseTagError::Proxy _p(AzUnexpectedCloseTagError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzUnexpectedCloseTagError_toDbgString(&inner_));
    return _p;
}

inline void UnknownEntityReferenceError::delete_() {
    AzUnknownEntityReferenceError_delete(&inner_);
}

inline UnknownEntityReferenceError UnknownEntityReferenceError::clone() const {
    UnknownEntityReferenceError::Proxy _p(AzUnknownEntityReferenceError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzUnknownEntityReferenceError_toDbgString(&inner_));
    return _p;
}

inline void DuplicatedAttributeError::delete_() {
    AzDuplicatedAttributeError_delete(&inner_);
}

inline DuplicatedAttributeError DuplicatedAttributeError::clone() const {
    DuplicatedAttributeError::Proxy _p(AzDuplicatedAttributeError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDuplicatedAttributeError_toDbgString(&inner_));
    return _p;
}

inline void InvalidStringError::delete_() {
    AzInvalidStringError_delete(&inner_);
}

inline InvalidStringError InvalidStringError::clone() const {
    InvalidStringError::Proxy _p(AzInvalidStringError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzInvalidStringError_toDbgString(&inner_));
    return _p;
}

inline void MalformedHierarchyError::delete_() {
    AzMalformedHierarchyError_delete(&inner_);
}

inline MalformedHierarchyError MalformedHierarchyError::clone() const {
    MalformedHierarchyError::Proxy _p(AzMalformedHierarchyError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMalformedHierarchyError_toDbgString(&inner_));
    return _p;
}

inline void SelectAllResult::delete_() {
    AzSelectAllResult_delete(&inner_);
}

inline SelectAllResult SelectAllResult::clone() const {
    SelectAllResult::Proxy _p(AzSelectAllResult_clone(&inner_));
    return _p;
}

inline bool SelectAllResult::partialEq(const SelectAllResult& b) const {
    return AzSelectAllResult_partialEq(&inner_, b.ptr());
}

inline String SelectAllResult::toDbgString() const {
    String::Proxy _p(AzSelectAllResult_toDbgString(&inner_));
    return _p;
}

inline void DeleteResult::delete_() {
    AzDeleteResult_delete(&inner_);
}

inline DeleteResult DeleteResult::clone() const {
    DeleteResult::Proxy _p(AzDeleteResult_clone(&inner_));
    return _p;
}

inline bool DeleteResult::partialEq(const DeleteResult& b) const {
    return AzDeleteResult_partialEq(&inner_, b.ptr());
}

inline String DeleteResult::toDbgString() const {
    String::Proxy _p(AzDeleteResult_toDbgString(&inner_));
    return _p;
}

inline void IcuError::delete_() {
    AzIcuError_delete(&inner_);
}

inline IcuError IcuError::clone() const {
    IcuError::Proxy _p(AzIcuError_clone(&inner_));
    return _p;
}

inline bool IcuError::partialEq(const IcuError& b) const {
    return AzIcuError_partialEq(&inner_, b.ptr());
}

inline String IcuError::toDbgString() const {
    String::Proxy _p(AzIcuError_toDbgString(&inner_));
    return _p;
}

inline void HttpStatusError::delete_() {
    AzHttpStatusError_delete(&inner_);
}

inline HttpStatusError HttpStatusError::clone() const {
    HttpStatusError::Proxy _p(AzHttpStatusError_clone(&inner_));
    return _p;
}

inline bool HttpStatusError::partialEq(const HttpStatusError& b) const {
    return AzHttpStatusError_partialEq(&inner_, b.ptr());
}

inline String HttpStatusError::toDbgString() const {
    String::Proxy _p(AzHttpStatusError_toDbgString(&inner_));
    return _p;
}

inline void FileError::delete_() {
    AzFileError_delete(&inner_);
}

inline FileError FileError::clone() const {
    FileError::Proxy _p(AzFileError_clone(&inner_));
    return _p;
}

inline bool FileError::partialEq(const FileError& b) const {
    return AzFileError_partialEq(&inner_, b.ptr());
}

inline String FileError::toDbgString() const {
    String::Proxy _p(AzFileError_toDbgString(&inner_));
    return _p;
}

inline void JsonParseError::delete_() {
    AzJsonParseError_delete(&inner_);
}

inline JsonParseError JsonParseError::clone() const {
    JsonParseError::Proxy _p(AzJsonParseError_clone(&inner_));
    return _p;
}

inline bool JsonParseError::partialEq(const JsonParseError& b) const {
    return AzJsonParseError_partialEq(&inner_, b.ptr());
}

inline String JsonParseError::toDbgString() const {
    String::Proxy _p(AzJsonParseError_toDbgString(&inner_));
    return _p;
}

inline void UrlParseError::delete_() {
    AzUrlParseError_delete(&inner_);
}

inline UrlParseError UrlParseError::clone() const {
    UrlParseError::Proxy _p(AzUrlParseError_clone(&inner_));
    return _p;
}

inline bool UrlParseError::partialEq(const UrlParseError& b) const {
    return AzUrlParseError_partialEq(&inner_, b.ptr());
}

inline String UrlParseError::toDbgString() const {
    String::Proxy _p(AzUrlParseError_toDbgString(&inner_));
    return _p;
}

inline void PixelNoValueGivenError::delete_() {
    AzPixelNoValueGivenError_delete(&inner_);
}

inline PixelNoValueGivenError PixelNoValueGivenError::clone() const {
    PixelNoValueGivenError::Proxy _p(AzPixelNoValueGivenError_clone(&inner_));
    return _p;
}

inline bool PixelNoValueGivenError::partialEq(const PixelNoValueGivenError& b) const {
    return AzPixelNoValueGivenError_partialEq(&inner_, b.ptr());
}

inline String PixelNoValueGivenError::toDbgString() const {
    String::Proxy _p(AzPixelNoValueGivenError_toDbgString(&inner_));
    return _p;
}

inline void VarOnShorthandPropertyError::delete_() {
    AzVarOnShorthandPropertyError_delete(&inner_);
}

inline VarOnShorthandPropertyError VarOnShorthandPropertyError::clone() const {
    VarOnShorthandPropertyError::Proxy _p(AzVarOnShorthandPropertyError_clone(&inner_));
    return _p;
}

inline bool VarOnShorthandPropertyError::partialEq(const VarOnShorthandPropertyError& b) const {
    return AzVarOnShorthandPropertyError_partialEq(&inner_, b.ptr());
}

inline String VarOnShorthandPropertyError::toDbgString() const {
    String::Proxy _p(AzVarOnShorthandPropertyError_toDbgString(&inner_));
    return _p;
}

inline void WrongComponentCountError::delete_() {
    AzWrongComponentCountError_delete(&inner_);
}

inline WrongComponentCountError WrongComponentCountError::clone() const {
    WrongComponentCountError::Proxy _p(AzWrongComponentCountError_clone(&inner_));
    return _p;
}

inline bool WrongComponentCountError::partialEq(const WrongComponentCountError& b) const {
    return AzWrongComponentCountError_partialEq(&inner_, b.ptr());
}

inline String WrongComponentCountError::toDbgString() const {
    String::Proxy _p(AzWrongComponentCountError_toDbgString(&inner_));
    return _p;
}

inline void AngleNoValueGivenError::delete_() {
    AzAngleNoValueGivenError_delete(&inner_);
}

inline AngleNoValueGivenError AngleNoValueGivenError::clone() const {
    AngleNoValueGivenError::Proxy _p(AzAngleNoValueGivenError_clone(&inner_));
    return _p;
}

inline bool AngleNoValueGivenError::partialEq(const AngleNoValueGivenError& b) const {
    return AzAngleNoValueGivenError_partialEq(&inner_, b.ptr());
}

inline String AngleNoValueGivenError::toDbgString() const {
    String::Proxy _p(AzAngleNoValueGivenError_toDbgString(&inner_));
    return _p;
}

inline void WhiteSpaceInComponentNameError::delete_() {
    AzWhiteSpaceInComponentNameError_delete(&inner_);
}

inline WhiteSpaceInComponentNameError WhiteSpaceInComponentNameError::clone() const {
    WhiteSpaceInComponentNameError::Proxy _p(AzWhiteSpaceInComponentNameError_clone(&inner_));
    return _p;
}

inline bool WhiteSpaceInComponentNameError::partialEq(const WhiteSpaceInComponentNameError& b) const {
    return AzWhiteSpaceInComponentNameError_partialEq(&inner_, b.ptr());
}

inline String WhiteSpaceInComponentNameError::toDbgString() const {
    String::Proxy _p(AzWhiteSpaceInComponentNameError_toDbgString(&inner_));
    return _p;
}

inline void WhiteSpaceInComponentTypeError::delete_() {
    AzWhiteSpaceInComponentTypeError_delete(&inner_);
}

inline WhiteSpaceInComponentTypeError WhiteSpaceInComponentTypeError::clone() const {
    WhiteSpaceInComponentTypeError::Proxy _p(AzWhiteSpaceInComponentTypeError_clone(&inner_));
    return _p;
}

inline bool WhiteSpaceInComponentTypeError::partialEq(const WhiteSpaceInComponentTypeError& b) const {
    return AzWhiteSpaceInComponentTypeError_partialEq(&inner_, b.ptr());
}

inline String WhiteSpaceInComponentTypeError::toDbgString() const {
    String::Proxy _p(AzWhiteSpaceInComponentTypeError_toDbgString(&inner_));
    return _p;
}

inline void UnknownPropertyKeyError::delete_() {
    AzUnknownPropertyKeyError_delete(&inner_);
}

inline UnknownPropertyKeyError UnknownPropertyKeyError::clone() const {
    UnknownPropertyKeyError::Proxy _p(AzUnknownPropertyKeyError_clone(&inner_));
    return _p;
}

inline bool UnknownPropertyKeyError::partialEq(const UnknownPropertyKeyError& b) const {
    return AzUnknownPropertyKeyError_partialEq(&inner_, b.ptr());
}

inline String UnknownPropertyKeyError::toDbgString() const {
    String::Proxy _p(AzUnknownPropertyKeyError_toDbgString(&inner_));
    return _p;
}

inline void UselessFunctionArgumentError::delete_() {
    AzUselessFunctionArgumentError_delete(&inner_);
}

inline UselessFunctionArgumentError UselessFunctionArgumentError::clone() const {
    UselessFunctionArgumentError::Proxy _p(AzUselessFunctionArgumentError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzUselessFunctionArgumentError_toDbgString(&inner_));
    return _p;
}

inline void MissingTypeError::delete_() {
    AzMissingTypeError_delete(&inner_);
}

inline MissingTypeError MissingTypeError::clone() const {
    MissingTypeError::Proxy _p(AzMissingTypeError_clone(&inner_));
    return _p;
}

inline bool MissingTypeError::partialEq(const MissingTypeError& b) const {
    return AzMissingTypeError_partialEq(&inner_, b.ptr());
}

inline String MissingTypeError::toDbgString() const {
    String::Proxy _p(AzMissingTypeError_toDbgString(&inner_));
    return _p;
}

inline void MapPinTap::delete_() {
    AzMapPinTap_delete(&inner_);
}

inline MapPinTap MapPinTap::clone() const {
    MapPinTap::Proxy _p(AzMapPinTap_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMapPinTap_toDbgString(&inner_));
    return _p;
}

inline ThreadWriteBackMsg ThreadWriteBackMsg::create(AzWriteBackCallbackType callback, RefAny data) {
    ThreadWriteBackMsg::Proxy _p(AzThreadWriteBackMsg_create(az_detail_wrap_cb<AzWriteBackCallback>(callback), data.release()));
    return _p;
}

inline void ThreadWriteBackMsg::delete_() {
    AzThreadWriteBackMsg_delete(&inner_);
}

inline ThreadWriteBackMsg ThreadWriteBackMsg::clone() const {
    ThreadWriteBackMsg::Proxy _p(AzThreadWriteBackMsg_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzThreadWriteBackMsg_toDbgString(&inner_));
    return _p;
}

inline Url Url::from_parts(String scheme, String host, uint16_t port, String path) {
    Url::Proxy _p(AzUrl_fromParts(scheme.release(), host.release(), port, path.release()));
    return _p;
}

inline ResultUrlUrlParseError Url::parse(String s) {
    return ResultUrlUrlParseError(AzUrl_parse(s.release()));
}

inline String Url::to_string() const {
    String::Proxy _p(AzUrl_toString(&inner_));
    return _p;
}

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 {
    Url::Proxy _p(AzUrl_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzUrl_toDbgString(&inner_));
    return _p;
}

inline JsonInternal JsonInternal::default_() {
    JsonInternal::Proxy _p(AzJsonInternal_default());
    return _p;
}

inline void JsonInternal::delete_() {
    AzJsonInternal_delete(&inner_);
}

inline JsonInternal JsonInternal::clone() const {
    JsonInternal::Proxy _p(AzJsonInternal_clone(&inner_));
    return _p;
}

inline bool JsonInternal::partialEq(const JsonInternal& b) const {
    return AzJsonInternal_partialEq(&inner_, b.ptr());
}

inline String JsonInternal::toDbgString() const {
    String::Proxy _p(AzJsonInternal_toDbgString(&inner_));
    return _p;
}

inline void DirEntry::delete_() {
    AzDirEntry_delete(&inner_);
}

inline DirEntry DirEntry::clone() const {
    DirEntry::Proxy _p(AzDirEntry_clone(&inner_));
    return _p;
}

inline String DirEntry::toDbgString() const {
    String::Proxy _p(AzDirEntry_toDbgString(&inner_));
    return _p;
}

inline BiometricPrompt BiometricPrompt::default_() {
    BiometricPrompt::Proxy _p(AzBiometricPrompt_default());
    return _p;
}

inline void BiometricPrompt::delete_() {
    AzBiometricPrompt_delete(&inner_);
}

inline BiometricPrompt BiometricPrompt::clone() const {
    BiometricPrompt::Proxy _p(AzBiometricPrompt_clone(&inner_));
    return _p;
}

inline bool BiometricPrompt::partialEq(const BiometricPrompt& b) const {
    return AzBiometricPrompt_partialEq(&inner_, b.ptr());
}

inline String BiometricPrompt::toDbgString() const {
    String::Proxy _p(AzBiometricPrompt_toDbgString(&inner_));
    return _p;
}

inline VideoConfig VideoConfig::default_() {
    VideoConfig::Proxy _p(AzVideoConfig_default());
    return _p;
}

inline void VideoConfig::delete_() {
    AzVideoConfig_delete(&inner_);
}

inline VideoConfig VideoConfig::clone() const {
    VideoConfig::Proxy _p(AzVideoConfig_clone(&inner_));
    return _p;
}

inline bool VideoConfig::partialEq(const VideoConfig& b) const {
    return AzVideoConfig_partialEq(&inner_, b.ptr());
}

inline String VideoConfig::toDbgString() const {
    String::Proxy _p(AzVideoConfig_toDbgString(&inner_));
    return _p;
}

inline ComponentId ComponentId::builtin(String name) {
    ComponentId::Proxy _p(AzComponentId_builtin(name.release()));
    return _p;
}

inline ComponentId ComponentId::new_(String collection, String name) {
    ComponentId::Proxy _p(AzComponentId_new(collection.release(), name.release()));
    return _p;
}

inline String ComponentId::qualified_name() const {
    String::Proxy _p(AzComponentId_qualifiedName(&inner_));
    return _p;
}

inline void ComponentId::delete_() {
    AzComponentId_delete(&inner_);
}

inline ComponentId ComponentId::clone() const {
    ComponentId::Proxy _p(AzComponentId_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzComponentId_toDbgString(&inner_));
    return _p;
}

inline void ComponentLibrary::delete_() {
    AzComponentLibrary_delete(&inner_);
}

inline ComponentLibrary ComponentLibrary::clone() const {
    ComponentLibrary::Proxy _p(AzComponentLibrary_clone(&inner_));
    return _p;
}

inline String ComponentLibrary::toDbgString() const {
    String::Proxy _p(AzComponentLibrary_toDbgString(&inner_));
    return _p;
}

inline void ComponentDataModel::delete_() {
    AzComponentDataModel_delete(&inner_);
}

inline ComponentDataModel ComponentDataModel::clone() const {
    ComponentDataModel::Proxy _p(AzComponentDataModel_clone(&inner_));
    return _p;
}

inline String ComponentDataModel::toDbgString() const {
    String::Proxy _p(AzComponentDataModel_toDbgString(&inner_));
    return _p;
}

inline void ComponentEnumVariant::delete_() {
    AzComponentEnumVariant_delete(&inner_);
}

inline ComponentEnumVariant ComponentEnumVariant::clone() const {
    ComponentEnumVariant::Proxy _p(AzComponentEnumVariant_clone(&inner_));
    return _p;
}

inline bool ComponentEnumVariant::partialEq(const ComponentEnumVariant& b) const {
    return AzComponentEnumVariant_partialEq(&inner_, b.ptr());
}

inline String ComponentEnumVariant::toDbgString() const {
    String::Proxy _p(AzComponentEnumVariant_toDbgString(&inner_));
    return _p;
}

inline void ComponentEnumModel::delete_() {
    AzComponentEnumModel_delete(&inner_);
}

inline ComponentEnumModel ComponentEnumModel::clone() const {
    ComponentEnumModel::Proxy _p(AzComponentEnumModel_clone(&inner_));
    return _p;
}

inline bool ComponentEnumModel::partialEq(const ComponentEnumModel& b) const {
    return AzComponentEnumModel_partialEq(&inner_, b.ptr());
}

inline String ComponentEnumModel::toDbgString() const {
    String::Proxy _p(AzComponentEnumModel_toDbgString(&inner_));
    return _p;
}

inline void ComponentInstanceDefault::delete_() {
    AzComponentInstanceDefault_delete(&inner_);
}

inline ComponentInstanceDefault ComponentInstanceDefault::clone() const {
    ComponentInstanceDefault::Proxy _p(AzComponentInstanceDefault_clone(&inner_));
    return _p;
}

inline bool ComponentInstanceDefault::partialEq(const ComponentInstanceDefault& b) const {
    return AzComponentInstanceDefault_partialEq(&inner_, b.ptr());
}

inline String ComponentInstanceDefault::toDbgString() const {
    String::Proxy _p(AzComponentInstanceDefault_toDbgString(&inner_));
    return _p;
}

inline void ComponentCallbackSignature::delete_() {
    AzComponentCallbackSignature_delete(&inner_);
}

inline ComponentCallbackSignature ComponentCallbackSignature::clone() const {
    ComponentCallbackSignature::Proxy _p(AzComponentCallbackSignature_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzComponentCallbackSignature_toDbgString(&inner_));
    return _p;
}

inline Monitor Monitor::default_() {
    Monitor::Proxy _p(AzMonitor_default());
    return _p;
}

inline void Monitor::delete_() {
    AzMonitor_delete(&inner_);
}

inline Monitor Monitor::clone() const {
    Monitor::Proxy _p(AzMonitor_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzMonitor_toDbgString(&inner_));
    return _p;
}

inline DialogAriaInfo DialogAriaInfo::create(String label) {
    DialogAriaInfo::Proxy _p(AzDialogAriaInfo_create(label.release()));
    return _p;
}

inline DialogAriaInfo DialogAriaInfo::with_modal(bool modal) const {
    DialogAriaInfo::Proxy _p(AzDialogAriaInfo_withModal(inner_, modal));
    return _p;
}

inline DialogAriaInfo DialogAriaInfo::with_described_by(String described_by) const {
    DialogAriaInfo::Proxy _p(AzDialogAriaInfo_withDescribedBy(inner_, described_by.release()));
    return _p;
}

inline DialogAriaInfo DialogAriaInfo::with_role(AzAccessibilityRole role) const {
    DialogAriaInfo::Proxy _p(AzDialogAriaInfo_withRole(inner_, role));
    return _p;
}

inline DialogAriaInfo DialogAriaInfo::with_description(String desc) const {
    DialogAriaInfo::Proxy _p(AzDialogAriaInfo_withDescription(inner_, desc.release()));
    return _p;
}

inline void DialogAriaInfo::delete_() {
    AzDialogAriaInfo_delete(&inner_);
}

inline DialogAriaInfo DialogAriaInfo::clone() const {
    DialogAriaInfo::Proxy _p(AzDialogAriaInfo_clone(&inner_));
    return _p;
}

inline bool DialogAriaInfo::partialEq(const DialogAriaInfo& b) const {
    return AzDialogAriaInfo_partialEq(&inner_, b.ptr());
}

inline String DialogAriaInfo::toDbgString() const {
    String::Proxy _p(AzDialogAriaInfo_toDbgString(&inner_));
    return _p;
}

inline void AccessibilityInfo::delete_() {
    AzAccessibilityInfo_delete(&inner_);
}

inline AccessibilityInfo AccessibilityInfo::clone() const {
    AccessibilityInfo::Proxy _p(AzAccessibilityInfo_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzAccessibilityInfo_toDbgString(&inner_));
    return _p;
}

inline void DragState::delete_() {
    AzDragState_delete(&inner_);
}

inline DragState DragState::clone() const {
    DragState::Proxy _p(AzDragState_clone(&inner_));
    return _p;
}

inline bool DragState::partialEq(const DragState& b) const {
    return AzDragState_partialEq(&inner_, b.ptr());
}

inline String DragState::toDbgString() const {
    String::Proxy _p(AzDragState_toDbgString(&inner_));
    return _p;
}

inline SmallAriaInfo SmallAriaInfo::label(String text) {
    SmallAriaInfo::Proxy _p(AzSmallAriaInfo_label(text.release()));
    return _p;
}

inline SmallAriaInfo SmallAriaInfo::with_role(AzAccessibilityRole role) const {
    SmallAriaInfo::Proxy _p(AzSmallAriaInfo_withRole(inner_, role));
    return _p;
}

inline SmallAriaInfo SmallAriaInfo::with_description(String desc) const {
    SmallAriaInfo::Proxy _p(AzSmallAriaInfo_withDescription(inner_, desc.release()));
    return _p;
}

inline void SmallAriaInfo::delete_() {
    AzSmallAriaInfo_delete(&inner_);
}

inline SmallAriaInfo SmallAriaInfo::clone() const {
    SmallAriaInfo::Proxy _p(AzSmallAriaInfo_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSmallAriaInfo_toDbgString(&inner_));
    return _p;
}

inline ProgressAriaInfo ProgressAriaInfo::create(String label) {
    ProgressAriaInfo::Proxy _p(AzProgressAriaInfo_create(label.release()));
    return _p;
}

inline ProgressAriaInfo ProgressAriaInfo::with_current_value(float value) const {
    ProgressAriaInfo::Proxy _p(AzProgressAriaInfo_withCurrentValue(inner_, value));
    return _p;
}

inline ProgressAriaInfo ProgressAriaInfo::with_max(float max) const {
    ProgressAriaInfo::Proxy _p(AzProgressAriaInfo_withMax(inner_, max));
    return _p;
}

inline ProgressAriaInfo ProgressAriaInfo::with_indeterminate(bool indeterminate) const {
    ProgressAriaInfo::Proxy _p(AzProgressAriaInfo_withIndeterminate(inner_, indeterminate));
    return _p;
}

inline ProgressAriaInfo ProgressAriaInfo::with_description(String desc) const {
    ProgressAriaInfo::Proxy _p(AzProgressAriaInfo_withDescription(inner_, desc.release()));
    return _p;
}

inline void ProgressAriaInfo::delete_() {
    AzProgressAriaInfo_delete(&inner_);
}

inline ProgressAriaInfo ProgressAriaInfo::clone() const {
    ProgressAriaInfo::Proxy _p(AzProgressAriaInfo_clone(&inner_));
    return _p;
}

inline bool ProgressAriaInfo::partialEq(const ProgressAriaInfo& b) const {
    return AzProgressAriaInfo_partialEq(&inner_, b.ptr());
}

inline String ProgressAriaInfo::toDbgString() const {
    String::Proxy _p(AzProgressAriaInfo_toDbgString(&inner_));
    return _p;
}

inline MeterAriaInfo MeterAriaInfo::create(String label, float current_value, float min, float max) {
    MeterAriaInfo::Proxy _p(AzMeterAriaInfo_create(label.release(), current_value, min, max));
    return _p;
}

inline MeterAriaInfo MeterAriaInfo::with_low(float low) const {
    MeterAriaInfo::Proxy _p(AzMeterAriaInfo_withLow(inner_, low));
    return _p;
}

inline MeterAriaInfo MeterAriaInfo::with_high(float high) const {
    MeterAriaInfo::Proxy _p(AzMeterAriaInfo_withHigh(inner_, high));
    return _p;
}

inline MeterAriaInfo MeterAriaInfo::with_optimum(float optimum) const {
    MeterAriaInfo::Proxy _p(AzMeterAriaInfo_withOptimum(inner_, optimum));
    return _p;
}

inline MeterAriaInfo MeterAriaInfo::with_description(String desc) const {
    MeterAriaInfo::Proxy _p(AzMeterAriaInfo_withDescription(inner_, desc.release()));
    return _p;
}

inline void MeterAriaInfo::delete_() {
    AzMeterAriaInfo_delete(&inner_);
}

inline MeterAriaInfo MeterAriaInfo::clone() const {
    MeterAriaInfo::Proxy _p(AzMeterAriaInfo_clone(&inner_));
    return _p;
}

inline bool MeterAriaInfo::partialEq(const MeterAriaInfo& b) const {
    return AzMeterAriaInfo_partialEq(&inner_, b.ptr());
}

inline String MeterAriaInfo::toDbgString() const {
    String::Proxy _p(AzMeterAriaInfo_toDbgString(&inner_));
    return _p;
}

inline CssAttributeSelector CssAttributeSelector::default_() {
    CssAttributeSelector::Proxy _p(AzCssAttributeSelector_default());
    return _p;
}

inline void CssAttributeSelector::delete_() {
    AzCssAttributeSelector_delete(&inner_);
}

inline CssAttributeSelector CssAttributeSelector::clone() const {
    CssAttributeSelector::Proxy _p(AzCssAttributeSelector_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCssAttributeSelector_toDbgString(&inner_));
    return _p;
}

inline void StyledTextRun::delete_() {
    AzStyledTextRun_delete(&inner_);
}

inline StyledTextRun StyledTextRun::clone() const {
    StyledTextRun::Proxy _p(AzStyledTextRun_clone(&inner_));
    return _p;
}

inline bool StyledTextRun::partialEq(const StyledTextRun& b) const {
    return AzStyledTextRun_partialEq(&inner_, b.ptr());
}

inline String StyledTextRun::toDbgString() const {
    String::Proxy _p(AzStyledTextRun_toDbgString(&inner_));
    return _p;
}

inline void TextOpCopy::delete_() {
    AzTextOpCopy_delete(&inner_);
}

inline TextOpCopy TextOpCopy::clone() const {
    TextOpCopy::Proxy _p(AzTextOpCopy_clone(&inner_));
    return _p;
}

inline String TextOpCopy::toDbgString() const {
    String::Proxy _p(AzTextOpCopy_toDbgString(&inner_));
    return _p;
}

inline void TextOpPaste::delete_() {
    AzTextOpPaste_delete(&inner_);
}

inline TextOpPaste TextOpPaste::clone() const {
    TextOpPaste::Proxy _p(AzTextOpPaste_clone(&inner_));
    return _p;
}

inline String TextOpPaste::toDbgString() const {
    String::Proxy _p(AzTextOpPaste_toDbgString(&inner_));
    return _p;
}

inline void TextOpCut::delete_() {
    AzTextOpCut_delete(&inner_);
}

inline TextOpCut TextOpCut::clone() const {
    TextOpCut::Proxy _p(AzTextOpCut_clone(&inner_));
    return _p;
}

inline String TextOpCut::toDbgString() const {
    String::Proxy _p(AzTextOpCut_toDbgString(&inner_));
    return _p;
}

inline SystemFonts SystemFonts::default_() {
    SystemFonts::Proxy _p(AzSystemFonts_default());
    return _p;
}

inline void SystemFonts::delete_() {
    AzSystemFonts_delete(&inner_);
}

inline SystemFonts SystemFonts::clone() const {
    SystemFonts::Proxy _p(AzSystemFonts_clone(&inner_));
    return _p;
}

inline bool SystemFonts::partialEq(const SystemFonts& b) const {
    return AzSystemFonts_partialEq(&inner_, b.ptr());
}

inline String SystemFonts::toDbgString() const {
    String::Proxy _p(AzSystemFonts_toDbgString(&inner_));
    return _p;
}

inline void PercentageParseErrorWithInput::delete_() {
    AzPercentageParseErrorWithInput_delete(&inner_);
}

inline PercentageParseErrorWithInput PercentageParseErrorWithInput::clone() const {
    PercentageParseErrorWithInput::Proxy _p(AzPercentageParseErrorWithInput_clone(&inner_));
    return _p;
}

inline bool PercentageParseErrorWithInput::partialEq(const PercentageParseErrorWithInput& b) const {
    return AzPercentageParseErrorWithInput_partialEq(&inner_, b.ptr());
}

inline String PercentageParseErrorWithInput::toDbgString() const {
    String::Proxy _p(AzPercentageParseErrorWithInput_toDbgString(&inner_));
    return _p;
}

inline TitlebarMetrics TitlebarMetrics::windows() {
    TitlebarMetrics::Proxy _p(AzTitlebarMetrics_windows());
    return _p;
}

inline TitlebarMetrics TitlebarMetrics::macos() {
    TitlebarMetrics::Proxy _p(AzTitlebarMetrics_macos());
    return _p;
}

inline TitlebarMetrics TitlebarMetrics::linux_gnome() {
    TitlebarMetrics::Proxy _p(AzTitlebarMetrics_linuxGnome());
    return _p;
}

inline TitlebarMetrics TitlebarMetrics::ios() {
    TitlebarMetrics::Proxy _p(AzTitlebarMetrics_ios());
    return _p;
}

inline TitlebarMetrics TitlebarMetrics::android() {
    TitlebarMetrics::Proxy _p(AzTitlebarMetrics_android());
    return _p;
}

inline TitlebarMetrics TitlebarMetrics::default_() {
    TitlebarMetrics::Proxy _p(AzTitlebarMetrics_default());
    return _p;
}

inline void TitlebarMetrics::delete_() {
    AzTitlebarMetrics_delete(&inner_);
}

inline TitlebarMetrics TitlebarMetrics::clone() const {
    TitlebarMetrics::Proxy _p(AzTitlebarMetrics_clone(&inner_));
    return _p;
}

inline bool TitlebarMetrics::partialEq(const TitlebarMetrics& b) const {
    return AzTitlebarMetrics_partialEq(&inner_, b.ptr());
}

inline String TitlebarMetrics::toDbgString() const {
    String::Proxy _p(AzTitlebarMetrics_toDbgString(&inner_));
    return _p;
}

inline LinuxCustomization LinuxCustomization::default_() {
    LinuxCustomization::Proxy _p(AzLinuxCustomization_default());
    return _p;
}

inline void LinuxCustomization::delete_() {
    AzLinuxCustomization_delete(&inner_);
}

inline LinuxCustomization LinuxCustomization::clone() const {
    LinuxCustomization::Proxy _p(AzLinuxCustomization_clone(&inner_));
    return _p;
}

inline bool LinuxCustomization::partialEq(const LinuxCustomization& b) const {
    return AzLinuxCustomization_partialEq(&inner_, b.ptr());
}

inline String LinuxCustomization::toDbgString() const {
    String::Proxy _p(AzLinuxCustomization_toDbgString(&inner_));
    return _p;
}

inline FileInputState FileInputState::default_() {
    FileInputState::Proxy _p(AzFileInputState_default());
    return _p;
}

inline void FileInputState::delete_() {
    AzFileInputState_delete(&inner_);
}

inline FileInputState FileInputState::clone() const {
    FileInputState::Proxy _p(AzFileInputState_clone(&inner_));
    return _p;
}

inline bool FileInputState::partialEq(const FileInputState& b) const {
    return AzFileInputState_partialEq(&inner_, b.ptr());
}

inline String FileInputState::toDbgString() const {
    String::Proxy _p(AzFileInputState_toDbgString(&inner_));
    return _p;
}

inline TextInputState TextInputState::default_() {
    TextInputState::Proxy _p(AzTextInputState_default());
    return _p;
}

inline String TextInputState::get_text() const {
    String::Proxy _p(AzTextInputState_getText(&inner_));
    return _p;
}

inline void TextInputState::delete_() {
    AzTextInputState_delete(&inner_);
}

inline TextInputState TextInputState::clone() const {
    TextInputState::Proxy _p(AzTextInputState_clone(&inner_));
    return _p;
}

inline bool TextInputState::partialEq(const TextInputState& b) const {
    return AzTextInputState_partialEq(&inner_, b.ptr());
}

inline String TextInputState::toDbgString() const {
    String::Proxy _p(AzTextInputState_toDbgString(&inner_));
    return _p;
}

inline void VertexBuffer::delete_() {
    AzVertexBuffer_delete(&inner_);
}

inline VertexBuffer VertexBuffer::clone() const {
    VertexBuffer::Proxy _p(AzVertexBuffer_clone(&inner_));
    return _p;
}

inline SvgParseOptions SvgParseOptions::default_() {
    SvgParseOptions::Proxy _p(AzSvgParseOptions_default());
    return _p;
}

inline void SvgParseOptions::delete_() {
    AzSvgParseOptions_delete(&inner_);
}

inline SvgParseOptions SvgParseOptions::clone() const {
    SvgParseOptions::Proxy _p(AzSvgParseOptions_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzSvgParseOptions_toDbgString(&inner_));
    return _p;
}

inline void UnknownSelectorError::delete_() {
    AzUnknownSelectorError_delete(&inner_);
}

inline UnknownSelectorError UnknownSelectorError::clone() const {
    UnknownSelectorError::Proxy _p(AzUnknownSelectorError_clone(&inner_));
    return _p;
}

inline bool UnknownSelectorError::partialEq(const UnknownSelectorError& b) const {
    return AzUnknownSelectorError_partialEq(&inner_, b.ptr());
}

inline String UnknownSelectorError::toDbgString() const {
    String::Proxy _p(AzUnknownSelectorError_toDbgString(&inner_));
    return _p;
}

inline Timer Timer::create(RefAny refany, AzTimerCallbackType callback, GetSystemTimeCallback get_system_time_fn) {
    Timer::Proxy _p(AzTimer_create(refany.release(), az_detail_wrap_cb<AzTimerCallback>(callback), get_system_time_fn.release()));
    return _p;
}

inline Timer Timer::default_() {
    Timer::Proxy _p(AzTimer_default());
    return _p;
}

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 {
    Timer::Proxy _p(AzTimer_withDelay(inner_, delay));
    return _p;
}

inline Timer Timer::with_interval(AzDuration interval) const {
    Timer::Proxy _p(AzTimer_withInterval(inner_, interval));
    return _p;
}

inline Timer Timer::with_timeout(AzDuration timeout) const {
    Timer::Proxy _p(AzTimer_withTimeout(inner_, timeout));
    return _p;
}

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 {
    Timer::Proxy _p(AzTimer_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTimer_toDbgString(&inner_));
    return _p;
}

inline void FmtArg::delete_() {
    AzFmtArg_delete(&inner_);
}

inline FmtArg FmtArg::clone() const {
    FmtArg::Proxy _p(AzFmtArg_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzFmtArg_toDbgString(&inner_));
    return _p;
}

inline Json Json::null() {
    Json::Proxy _p(AzJson_null());
    return _p;
}

inline Json Json::bool_(bool value) {
    Json::Proxy _p(AzJson_bool(value));
    return _p;
}

inline Json Json::float_(double value) {
    Json::Proxy _p(AzJson_float(value));
    return _p;
}

inline Json Json::int_(int64_t value) {
    Json::Proxy _p(AzJson_int(value));
    return _p;
}

inline Json Json::string(String value) {
    Json::Proxy _p(AzJson_string(value.release()));
    return _p;
}

inline Json Json::array(JsonVec values) {
    Json::Proxy _p(AzJson_array(values.release()));
    return _p;
}

inline Json Json::object(JsonKeyValueVec entries) {
    Json::Proxy _p(AzJson_object(entries.release()));
    return _p;
}

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 {
    StringVec::Proxy _p(AzJson_keys(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzJson_toString(&inner_));
    return _p;
}

inline String Json::to_string_pretty() const {
    String::Proxy _p(AzJson_toStringPretty(&inner_));
    return _p;
}

inline Json Json::jq(String path) const {
    Json::Proxy _p(AzJson_jq(&inner_, path.release()));
    return _p;
}

inline JsonVec Json::jq_all(String path) const {
    JsonVec::Proxy _p(AzJson_jqAll(&inner_, path.release()));
    return _p;
}

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 {
    Json::Proxy _p(AzJson_clone(&inner_));
    return _p;
}

inline bool Json::partialEq(const Json& b) const {
    return AzJson_partialEq(&inner_, b.ptr());
}

inline String Json::toDbgString() const {
    String::Proxy _p(AzJson_toDbgString(&inner_));
    return _p;
}

inline void ComponentDef::delete_() {
    AzComponentDef_delete(&inner_);
}

inline ComponentDef ComponentDef::clone() const {
    ComponentDef::Proxy _p(AzComponentDef_clone(&inner_));
    return _p;
}

inline String ComponentDef::toDbgString() const {
    String::Proxy _p(AzComponentDef_toDbgString(&inner_));
    return _p;
}

inline void ComponentFieldOverride::delete_() {
    AzComponentFieldOverride_delete(&inner_);
}

inline ComponentFieldOverride ComponentFieldOverride::clone() const {
    ComponentFieldOverride::Proxy _p(AzComponentFieldOverride_clone(&inner_));
    return _p;
}

inline bool ComponentFieldOverride::partialEq(const ComponentFieldOverride& b) const {
    return AzComponentFieldOverride_partialEq(&inner_, b.ptr());
}

inline String ComponentFieldOverride::toDbgString() const {
    String::Proxy _p(AzComponentFieldOverride_toDbgString(&inner_));
    return _p;
}

inline LinuxWindowOptions LinuxWindowOptions::default_() {
    LinuxWindowOptions::Proxy _p(AzLinuxWindowOptions_default());
    return _p;
}

inline void LinuxWindowOptions::delete_() {
    AzLinuxWindowOptions_delete(&inner_);
}

inline LinuxWindowOptions LinuxWindowOptions::clone() const {
    LinuxWindowOptions::Proxy _p(AzLinuxWindowOptions_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzLinuxWindowOptions_toDbgString(&inner_));
    return _p;
}

inline WindowsWindowOptions WindowsWindowOptions::default_() {
    WindowsWindowOptions::Proxy _p(AzWindowsWindowOptions_default());
    return _p;
}

inline void WindowsWindowOptions::delete_() {
    AzWindowsWindowOptions_delete(&inner_);
}

inline WindowsWindowOptions WindowsWindowOptions::clone() const {
    WindowsWindowOptions::Proxy _p(AzWindowsWindowOptions_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzWindowsWindowOptions_toDbgString(&inner_));
    return _p;
}

inline NodeData NodeData::create(AzNodeType node_type) {
    NodeData::Proxy _p(AzNodeData_create(node_type));
    return _p;
}

inline NodeData NodeData::create_body() {
    NodeData::Proxy _p(AzNodeData_createBody());
    return _p;
}

inline NodeData NodeData::create_div() {
    NodeData::Proxy _p(AzNodeData_createDiv());
    return _p;
}

inline NodeData NodeData::create_br() {
    NodeData::Proxy _p(AzNodeData_createBr());
    return _p;
}

inline NodeData NodeData::create_text(String value) {
    NodeData::Proxy _p(AzNodeData_createText(value.release()));
    return _p;
}

inline NodeData NodeData::create_image(ImageRef image) {
    NodeData::Proxy _p(AzNodeData_createImage(image.release()));
    return _p;
}

inline NodeData NodeData::create_virtual_view(RefAny data, AzVirtualViewCallbackType callback) {
    NodeData::Proxy _p(AzNodeData_createVirtualView(data.release(), callback));
    return _p;
}

inline NodeData NodeData::create_node(AzNodeType node_type) {
    NodeData::Proxy _p(AzNodeData_createNode(node_type));
    return _p;
}

inline NodeData NodeData::create_button(SmallAriaInfo aria) {
    NodeData::Proxy _p(AzNodeData_createButton(aria.release()));
    return _p;
}

inline NodeData NodeData::create_button_no_a11y() {
    NodeData::Proxy _p(AzNodeData_createButtonNoA11y());
    return _p;
}

inline NodeData NodeData::create_a(String href, SmallAriaInfo aria) {
    NodeData::Proxy _p(AzNodeData_createA(href.release(), aria.release()));
    return _p;
}

inline NodeData NodeData::create_a_no_a11y(String href) {
    NodeData::Proxy _p(AzNodeData_createANoA11y(href.release()));
    return _p;
}

inline NodeData NodeData::create_input(String input_type, String name, String label, SmallAriaInfo aria) {
    NodeData::Proxy _p(AzNodeData_createInput(input_type.release(), name.release(), label.release(), aria.release()));
    return _p;
}

inline NodeData NodeData::create_input_no_a11y(String input_type, String name, String label) {
    NodeData::Proxy _p(AzNodeData_createInputNoA11y(input_type.release(), name.release(), label.release()));
    return _p;
}

inline NodeData NodeData::create_textarea(String name, String label, SmallAriaInfo aria) {
    NodeData::Proxy _p(AzNodeData_createTextarea(name.release(), label.release(), aria.release()));
    return _p;
}

inline NodeData NodeData::create_textarea_no_a11y(String name, String label) {
    NodeData::Proxy _p(AzNodeData_createTextareaNoA11y(name.release(), label.release()));
    return _p;
}

inline NodeData NodeData::create_select(String name, String label, SmallAriaInfo aria) {
    NodeData::Proxy _p(AzNodeData_createSelect(name.release(), label.release(), aria.release()));
    return _p;
}

inline NodeData NodeData::create_select_no_a11y(String name, String label) {
    NodeData::Proxy _p(AzNodeData_createSelectNoA11y(name.release(), label.release()));
    return _p;
}

inline NodeData NodeData::create_table(SmallAriaInfo aria) {
    NodeData::Proxy _p(AzNodeData_createTable(aria.release()));
    return _p;
}

inline NodeData NodeData::create_table_no_a11y() {
    NodeData::Proxy _p(AzNodeData_createTableNoA11y());
    return _p;
}

inline NodeData NodeData::create_label(String for_id, SmallAriaInfo aria) {
    NodeData::Proxy _p(AzNodeData_createLabel(for_id.release(), aria.release()));
    return _p;
}

inline NodeData NodeData::create_label_no_a11y(String for_id) {
    NodeData::Proxy _p(AzNodeData_createLabelNoA11y(for_id.release()));
    return _p;
}

inline NodeData NodeData::default_() {
    NodeData::Proxy _p(AzNodeData_default());
    return _p;
}

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 {
    NodeData::Proxy _p(AzNodeData_withContenteditable(inner_, contenteditable));
    return _p;
}

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 {
    String::Proxy _p(AzNodeData_debugPrintEnd(&inner_));
    return _p;
}

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 {
    NodeData::Proxy _p(AzNodeData_withMergeCallback(inner_, az_detail_wrap_cb<AzDatasetMergeCallback>(callback)));
    return _p;
}

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 {
    IdOrClassVec::Proxy _p(AzNodeData_getIdsAndClasses(&inner_));
    return _p;
}

inline void NodeData::delete_() {
    AzNodeData_delete(&inner_);
}

inline NodeData NodeData::clone() const {
    NodeData::Proxy _p(AzNodeData_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzNodeData_toDbgString(&inner_));
    return _p;
}

inline StringMenuItem StringMenuItem::create(String label) {
    StringMenuItem::Proxy _p(AzStringMenuItem_create(label.release()));
    return _p;
}

inline void StringMenuItem::delete_() {
    AzStringMenuItem_delete(&inner_);
}

inline StringMenuItem StringMenuItem::clone() const {
    StringMenuItem::Proxy _p(AzStringMenuItem_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzStringMenuItem_toDbgString(&inner_));
    return _p;
}

inline GridPlacement GridPlacement::default_() {
    GridPlacement::Proxy _p(AzGridPlacement_default());
    return _p;
}

inline void GridPlacement::delete_() {
    AzGridPlacement_delete(&inner_);
}

inline GridPlacement GridPlacement::clone() const {
    GridPlacement::Proxy _p(AzGridPlacement_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzGridPlacement_toDbgString(&inner_));
    return _p;
}

inline CssMockEnvironment CssMockEnvironment::default_() {
    CssMockEnvironment::Proxy _p(AzCssMockEnvironment_default());
    return _p;
}

inline void CssMockEnvironment::delete_() {
    AzCssMockEnvironment_delete(&inner_);
}

inline CssMockEnvironment CssMockEnvironment::clone() const {
    CssMockEnvironment::Proxy _p(AzCssMockEnvironment_clone(&inner_));
    return _p;
}

inline String CssMockEnvironment::toDbgString() const {
    String::Proxy _p(AzCssMockEnvironment_toDbgString(&inner_));
    return _p;
}

inline SystemMetrics SystemMetrics::default_() {
    SystemMetrics::Proxy _p(AzSystemMetrics_default());
    return _p;
}

inline void SystemMetrics::delete_() {
    AzSystemMetrics_delete(&inner_);
}

inline SystemMetrics SystemMetrics::clone() const {
    SystemMetrics::Proxy _p(AzSystemMetrics_clone(&inner_));
    return _p;
}

inline bool SystemMetrics::partialEq(const SystemMetrics& b) const {
    return AzSystemMetrics_partialEq(&inner_, b.ptr());
}

inline String SystemMetrics::toDbgString() const {
    String::Proxy _p(AzSystemMetrics_toDbgString(&inner_));
    return _p;
}

inline Button Button::create(String label) {
    Button::Proxy _p(AzButton_create(label.release()));
    return _p;
}

inline Button Button::with_type(String label, AzButtonType button_type) {
    Button::Proxy _p(AzButton_withType(label.release(), button_type));
    return _p;
}

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 {
    Button::Proxy _p(AzButton_withOnClick(inner_, data.release(), callback));
    return _p;
}

inline void Button::set_button_type(AzButtonType button_type) {
    AzButton_setButtonType(&inner_, button_type);
}

inline Button Button::with_button_type(AzButtonType button_type) const {
    Button::Proxy _p(AzButton_withButtonType(inner_, button_type));
    return _p;
}

inline Dom Button::dom() const {
    Dom::Proxy _p(AzButton_dom(inner_));
    return _p;
}

inline void Button::delete_() {
    AzButton_delete(&inner_);
}

inline Button Button::clone() const {
    Button::Proxy _p(AzButton_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzButton_toDbgString(&inner_));
    return _p;
}

inline MapWidget MapWidget::create(MapTileLayer layer) {
    MapWidget::Proxy _p(AzMapWidget_create(layer.release()));
    return _p;
}

inline MapWidget MapWidget::with_viewport(MapViewport viewport) const {
    MapWidget::Proxy _p(AzMapWidget_withViewport(inner_, viewport.release()));
    return _p;
}

inline void MapWidget::set_viewport(MapViewport viewport) {
    AzMapWidget_setViewport(&inner_, viewport.release());
}

inline MapWidget MapWidget::with_container_style(CssPropertyWithConditionsVec css) const {
    MapWidget::Proxy _p(AzMapWidget_withContainerStyle(inner_, css.release()));
    return _p;
}

inline Dom MapWidget::dom() const {
    Dom::Proxy _p(AzMapWidget_dom(inner_));
    return _p;
}

inline Dom MapWidget::dom_with_fetch(AzThreadCallbackType cb) const {
    Dom::Proxy _p(AzMapWidget_domWithFetch(inner_, cb));
    return _p;
}

inline MapWidget MapWidget::with_on_viewport_changed(RefAny data, AzMapViewportChangedCallbackType callback) const {
    MapWidget::Proxy _p(AzMapWidget_withOnViewportChanged(inner_, data.release(), az_detail_wrap_cb<AzMapViewportChangedCallback>(callback)));
    return _p;
}

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 {
    MapWidget::Proxy _p(AzMapWidget_withOnPinTap(inner_, data.release(), az_detail_wrap_cb<AzMapPinTapCallback>(callback)));
    return _p;
}

inline void MapWidget::delete_() {
    AzMapWidget_delete(&inner_);
}

inline MapWidget MapWidget::clone() const {
    MapWidget::Proxy _p(AzMapWidget_clone(&inner_));
    return _p;
}

inline bool MapWidget::partialEq(const MapWidget& b) const {
    return AzMapWidget_partialEq(&inner_, b.ptr());
}

inline String MapWidget::toDbgString() const {
    String::Proxy _p(AzMapWidget_toDbgString(&inner_));
    return _p;
}

inline FileInputStateWrapper FileInputStateWrapper::default_() {
    FileInputStateWrapper::Proxy _p(AzFileInputStateWrapper_default());
    return _p;
}

inline void FileInputStateWrapper::delete_() {
    AzFileInputStateWrapper_delete(&inner_);
}

inline FileInputStateWrapper FileInputStateWrapper::clone() const {
    FileInputStateWrapper::Proxy _p(AzFileInputStateWrapper_clone(&inner_));
    return _p;
}

inline bool FileInputStateWrapper::partialEq(const FileInputStateWrapper& b) const {
    return AzFileInputStateWrapper_partialEq(&inner_, b.ptr());
}

inline String FileInputStateWrapper::toDbgString() const {
    String::Proxy _p(AzFileInputStateWrapper_toDbgString(&inner_));
    return _p;
}

inline CheckBoxStateWrapper CheckBoxStateWrapper::default_() {
    CheckBoxStateWrapper::Proxy _p(AzCheckBoxStateWrapper_default());
    return _p;
}

inline void CheckBoxStateWrapper::delete_() {
    AzCheckBoxStateWrapper_delete(&inner_);
}

inline CheckBoxStateWrapper CheckBoxStateWrapper::clone() const {
    CheckBoxStateWrapper::Proxy _p(AzCheckBoxStateWrapper_clone(&inner_));
    return _p;
}

inline bool CheckBoxStateWrapper::partialEq(const CheckBoxStateWrapper& b) const {
    return AzCheckBoxStateWrapper_partialEq(&inner_, b.ptr());
}

inline String CheckBoxStateWrapper::toDbgString() const {
    String::Proxy _p(AzCheckBoxStateWrapper_toDbgString(&inner_));
    return _p;
}

inline DropDown DropDown::create(StringVec choices) {
    DropDown::Proxy _p(AzDropDown_create(choices.release()));
    return _p;
}

inline DropDown DropDown::default_() {
    DropDown::Proxy _p(AzDropDown_default());
    return _p;
}

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 {
    DropDown::Proxy _p(AzDropDown_withOnChoiceChange(inner_, data.release(), callback));
    return _p;
}

inline Dom DropDown::dom() const {
    Dom::Proxy _p(AzDropDown_dom(inner_));
    return _p;
}

inline void DropDown::delete_() {
    AzDropDown_delete(&inner_);
}

inline DropDown DropDown::clone() const {
    DropDown::Proxy _p(AzDropDown_clone(&inner_));
    return _p;
}

inline bool DropDown::partialEq(const DropDown& b) const {
    return AzDropDown_partialEq(&inner_, b.ptr());
}

inline String DropDown::toDbgString() const {
    String::Proxy _p(AzDropDown_toDbgString(&inner_));
    return _p;
}

inline ColorInputStateWrapper ColorInputStateWrapper::default_() {
    ColorInputStateWrapper::Proxy _p(AzColorInputStateWrapper_default());
    return _p;
}

inline void ColorInputStateWrapper::delete_() {
    AzColorInputStateWrapper_delete(&inner_);
}

inline ColorInputStateWrapper ColorInputStateWrapper::clone() const {
    ColorInputStateWrapper::Proxy _p(AzColorInputStateWrapper_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzColorInputStateWrapper_toDbgString(&inner_));
    return _p;
}

inline TextInputStateWrapper TextInputStateWrapper::default_() {
    TextInputStateWrapper::Proxy _p(AzTextInputStateWrapper_default());
    return _p;
}

inline void TextInputStateWrapper::delete_() {
    AzTextInputStateWrapper_delete(&inner_);
}

inline TextInputStateWrapper TextInputStateWrapper::clone() const {
    TextInputStateWrapper::Proxy _p(AzTextInputStateWrapper_clone(&inner_));
    return _p;
}

inline bool TextInputStateWrapper::partialEq(const TextInputStateWrapper& b) const {
    return AzTextInputStateWrapper_partialEq(&inner_, b.ptr());
}

inline String TextInputStateWrapper::toDbgString() const {
    String::Proxy _p(AzTextInputStateWrapper_toDbgString(&inner_));
    return _p;
}

inline NumberInputStateWrapper NumberInputStateWrapper::default_() {
    NumberInputStateWrapper::Proxy _p(AzNumberInputStateWrapper_default());
    return _p;
}

inline void NumberInputStateWrapper::delete_() {
    AzNumberInputStateWrapper_delete(&inner_);
}

inline NumberInputStateWrapper NumberInputStateWrapper::clone() const {
    NumberInputStateWrapper::Proxy _p(AzNumberInputStateWrapper_clone(&inner_));
    return _p;
}

inline bool NumberInputStateWrapper::partialEq(const NumberInputStateWrapper& b) const {
    return AzNumberInputStateWrapper_partialEq(&inner_, b.ptr());
}

inline String NumberInputStateWrapper::toDbgString() const {
    String::Proxy _p(AzNumberInputStateWrapper_toDbgString(&inner_));
    return _p;
}

inline TabHeader TabHeader::create(StringVec tabs) {
    TabHeader::Proxy _p(AzTabHeader_create(tabs.release()));
    return _p;
}

inline TabHeader TabHeader::default_() {
    TabHeader::Proxy _p(AzTabHeader_default());
    return _p;
}

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 {
    TabHeader::Proxy _p(AzTabHeader_withActiveTab(inner_, active_tab));
    return _p;
}

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 {
    TabHeader::Proxy _p(AzTabHeader_withOnClick(inner_, data.release(), callback));
    return _p;
}

inline Dom TabHeader::dom() const {
    Dom::Proxy _p(AzTabHeader_dom(inner_));
    return _p;
}

inline void TabHeader::delete_() {
    AzTabHeader_delete(&inner_);
}

inline TabHeader TabHeader::clone() const {
    TabHeader::Proxy _p(AzTabHeader_clone(&inner_));
    return _p;
}

inline String TabHeader::toDbgString() const {
    String::Proxy _p(AzTabHeader_toDbgString(&inner_));
    return _p;
}

inline ListView ListView::create(StringVec columns) {
    ListView::Proxy _p(AzListView_create(columns.release()));
    return _p;
}

inline ListView ListView::default_() {
    ListView::Proxy _p(AzListView_default());
    return _p;
}

inline ListView ListView::with_rows(ListViewRowVec rows) const {
    ListView::Proxy _p(AzListView_withRows(inner_, rows.release()));
    return _p;
}

inline Dom ListView::dom() const {
    Dom::Proxy _p(AzListView_dom(inner_));
    return _p;
}

inline void ListView::delete_() {
    AzListView_delete(&inner_);
}

inline ListView ListView::clone() const {
    ListView::Proxy _p(AzListView_clone(&inner_));
    return _p;
}

inline String ListView::toDbgString() const {
    String::Proxy _p(AzListView_toDbgString(&inner_));
    return _p;
}

inline Ribbon Ribbon::new_(RibbonTabVec tabs) {
    Ribbon::Proxy _p(AzRibbon_new(tabs.release()));
    return _p;
}

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 {
    Ribbon::Proxy _p(AzRibbon_withOnTabClick(inner_, data.release(), cb));
    return _p;
}

inline Dom Ribbon::dom() const {
    Dom::Proxy _p(AzRibbon_dom(inner_));
    return _p;
}

inline void Ribbon::delete_() {
    AzRibbon_delete(&inner_);
}

inline Ribbon Ribbon::clone() const {
    Ribbon::Proxy _p(AzRibbon_clone(&inner_));
    return _p;
}

inline String Ribbon::toDbgString() const {
    String::Proxy _p(AzRibbon_toDbgString(&inner_));
    return _p;
}

inline TreeView TreeView::new_(TreeViewNode root) {
    TreeView::Proxy _p(AzTreeView_new(root.release()));
    return _p;
}

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 {
    TreeView::Proxy _p(AzTreeView_withOnNodeClick(inner_, data.release(), callback));
    return _p;
}

inline Dom TreeView::dom() const {
    Dom::Proxy _p(AzTreeView_dom(inner_));
    return _p;
}

inline void TreeView::delete_() {
    AzTreeView_delete(&inner_);
}

inline TreeView TreeView::clone() const {
    TreeView::Proxy _p(AzTreeView_clone(&inner_));
    return _p;
}

inline bool TreeView::partialEq(const TreeView& b) const {
    return AzTreeView_partialEq(&inner_, b.ptr());
}

inline String TreeView::toDbgString() const {
    String::Proxy _p(AzTreeView_toDbgString(&inner_));
    return _p;
}

inline CameraWidget CameraWidget::create(CameraConfig config) {
    CameraWidget::Proxy _p(AzCameraWidget_create(config.release()));
    return _p;
}

inline Dom CameraWidget::dom() const {
    Dom::Proxy _p(AzCameraWidget_dom(inner_));
    return _p;
}

inline CameraWidget CameraWidget::with_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame) const {
    CameraWidget::Proxy _p(AzCameraWidget_withOnFrame(inner_, data.release(), az_detail_wrap_cb<AzOnVideoFrameCallback>(on_frame)));
    return _p;
}

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) {
    ScreenCaptureWidget::Proxy _p(AzScreenCaptureWidget_create(config.release()));
    return _p;
}

inline Dom ScreenCaptureWidget::dom() const {
    Dom::Proxy _p(AzScreenCaptureWidget_dom(inner_));
    return _p;
}

inline ScreenCaptureWidget ScreenCaptureWidget::with_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame) const {
    ScreenCaptureWidget::Proxy _p(AzScreenCaptureWidget_withOnFrame(inner_, data.release(), az_detail_wrap_cb<AzOnVideoFrameCallback>(on_frame)));
    return _p;
}

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) {
    VideoWidget::Proxy _p(AzVideoWidget_create(config.release()));
    return _p;
}

inline Dom VideoWidget::dom() const {
    Dom::Proxy _p(AzVideoWidget_dom(inner_));
    return _p;
}

inline VideoWidget VideoWidget::with_on_frame(RefAny data, AzOnVideoFrameCallbackType on_frame) const {
    VideoWidget::Proxy _p(AzVideoWidget_withOnFrame(inner_, data.release(), az_detail_wrap_cb<AzOnVideoFrameCallback>(on_frame)));
    return _p;
}

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) {
    MicrophoneWidget::Proxy _p(AzMicrophoneWidget_create(config.release()));
    return _p;
}

inline MicrophoneWidget MicrophoneWidget::with_on_frame(RefAny data, AzOnAudioFrameCallbackType on_frame) const {
    MicrophoneWidget::Proxy _p(AzMicrophoneWidget_withOnFrame(inner_, data.release(), az_detail_wrap_cb<AzOnAudioFrameCallback>(on_frame)));
    return _p;
}

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 {
    Dom::Proxy _p(AzMicrophoneWidget_dom(inner_));
    return _p;
}

inline void MicrophoneWidget::delete_() {
    AzMicrophoneWidget_delete(&inner_);
}

inline TessellatedGPUSvgNode TessellatedGPUSvgNode::create(TessellatedSvgNode node, GlContextPtr gl) {
    TessellatedGPUSvgNode::Proxy _p(AzTessellatedGPUSvgNode_create(node.release(), gl.release()));
    return _p;
}

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 {
    TessellatedGPUSvgNode::Proxy _p(AzTessellatedGPUSvgNode_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTessellatedGPUSvgNode_toDbgString(&inner_));
    return _p;
}

inline void TessellatedColoredGPUSvgNode::delete_() {
    AzTessellatedColoredGPUSvgNode_delete(&inner_);
}

inline TessellatedColoredGPUSvgNode TessellatedColoredGPUSvgNode::clone() const {
    TessellatedColoredGPUSvgNode::Proxy _p(AzTessellatedColoredGPUSvgNode_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzTessellatedColoredGPUSvgNode_toDbgString(&inner_));
    return _p;
}

inline void XmlTextError::delete_() {
    AzXmlTextError_delete(&inner_);
}

inline XmlTextError XmlTextError::clone() const {
    XmlTextError::Proxy _p(AzXmlTextError_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzXmlTextError_toDbgString(&inner_));
    return _p;
}

inline JsonKeyValue JsonKeyValue::create(String key, Json value) {
    JsonKeyValue::Proxy _p(AzJsonKeyValue_create(key.release(), value.release()));
    return _p;
}

inline void JsonKeyValue::delete_() {
    AzJsonKeyValue_delete(&inner_);
}

inline JsonKeyValue JsonKeyValue::clone() const {
    JsonKeyValue::Proxy _p(AzJsonKeyValue_clone(&inner_));
    return _p;
}

inline bool JsonKeyValue::partialEq(const JsonKeyValue& b) const {
    return AzJsonKeyValue_partialEq(&inner_, b.ptr());
}

inline String JsonKeyValue::toDbgString() const {
    String::Proxy _p(AzJsonKeyValue_toDbgString(&inner_));
    return _p;
}

inline void ExternalResource::delete_() {
    AzExternalResource_delete(&inner_);
}

inline ExternalResource ExternalResource::clone() const {
    ExternalResource::Proxy _p(AzExternalResource_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzExternalResource_toDbgString(&inner_));
    return _p;
}

inline void ComponentCallbackArg::delete_() {
    AzComponentCallbackArg_delete(&inner_);
}

inline ComponentCallbackArg ComponentCallbackArg::clone() const {
    ComponentCallbackArg::Proxy _p(AzComponentCallbackArg_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzComponentCallbackArg_toDbgString(&inner_));
    return _p;
}

inline PlatformSpecificOptions PlatformSpecificOptions::default_() {
    PlatformSpecificOptions::Proxy _p(AzPlatformSpecificOptions_default());
    return _p;
}

inline void PlatformSpecificOptions::delete_() {
    AzPlatformSpecificOptions_delete(&inner_);
}

inline PlatformSpecificOptions PlatformSpecificOptions::clone() const {
    PlatformSpecificOptions::Proxy _p(AzPlatformSpecificOptions_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzPlatformSpecificOptions_toDbgString(&inner_));
    return _p;
}

inline void TextChangeset::delete_() {
    AzTextChangeset_delete(&inner_);
}

inline TextChangeset TextChangeset::clone() const {
    TextChangeset::Proxy _p(AzTextChangeset_clone(&inner_));
    return _p;
}

inline String TextChangeset::toDbgString() const {
    String::Proxy _p(AzTextChangeset_toDbgString(&inner_));
    return _p;
}

inline Dom Dom::create_body() {
    Dom::Proxy _p(AzDom_createBody());
    return _p;
}

inline Dom Dom::create_div() {
    Dom::Proxy _p(AzDom_createDiv());
    return _p;
}

inline Dom Dom::create_br() {
    Dom::Proxy _p(AzDom_createBr());
    return _p;
}

inline Dom Dom::create_text(String value) {
    Dom::Proxy _p(AzDom_createText(value.release()));
    return _p;
}

inline Dom Dom::create_image(ImageRef image) {
    Dom::Proxy _p(AzDom_createImage(image.release()));
    return _p;
}

inline Dom Dom::create_icon(String icon_name) {
    Dom::Proxy _p(AzDom_createIcon(icon_name.release()));
    return _p;
}

inline Dom Dom::create_virtual_view(RefAny data, AzVirtualViewCallbackType callback) {
    Dom::Proxy _p(AzDom_createVirtualView(data.release(), callback));
    return _p;
}

inline Dom Dom::create_node(AzNodeType node_type) {
    Dom::Proxy _p(AzDom_createNode(node_type));
    return _p;
}

inline Dom Dom::create_from_data(NodeData node_data) {
    Dom::Proxy _p(AzDom_createFromData(node_data.release()));
    return _p;
}

inline Dom Dom::create_from_parsed_xml(AzXml xml) {
    Dom::Proxy _p(AzDom_createFromParsedXml(xml));
    return _p;
}

inline Dom Dom::create_html() {
    Dom::Proxy _p(AzDom_createHtml());
    return _p;
}

inline Dom Dom::create_head() {
    Dom::Proxy _p(AzDom_createHead());
    return _p;
}

inline Dom Dom::create_article() {
    Dom::Proxy _p(AzDom_createArticle());
    return _p;
}

inline Dom Dom::create_section() {
    Dom::Proxy _p(AzDom_createSection());
    return _p;
}

inline Dom Dom::create_nav() {
    Dom::Proxy _p(AzDom_createNav());
    return _p;
}

inline Dom Dom::create_aside() {
    Dom::Proxy _p(AzDom_createAside());
    return _p;
}

inline Dom Dom::create_header() {
    Dom::Proxy _p(AzDom_createHeader());
    return _p;
}

inline Dom Dom::create_footer() {
    Dom::Proxy _p(AzDom_createFooter());
    return _p;
}

inline Dom Dom::create_main() {
    Dom::Proxy _p(AzDom_createMain());
    return _p;
}

inline Dom Dom::create_figure() {
    Dom::Proxy _p(AzDom_createFigure());
    return _p;
}

inline Dom Dom::create_figcaption() {
    Dom::Proxy _p(AzDom_createFigcaption());
    return _p;
}

inline Dom Dom::create_details(SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createDetails(aria.release()));
    return _p;
}

inline Dom Dom::create_details_no_a11y() {
    Dom::Proxy _p(AzDom_createDetailsNoA11y());
    return _p;
}

inline Dom Dom::create_summary(SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createSummary(aria.release()));
    return _p;
}

inline Dom Dom::create_summary_no_a11y() {
    Dom::Proxy _p(AzDom_createSummaryNoA11y());
    return _p;
}

inline Dom Dom::create_summary_with_text(String text, SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createSummaryWithText(text.release(), aria.release()));
    return _p;
}

inline Dom Dom::create_summary_with_text_no_a11y(String text) {
    Dom::Proxy _p(AzDom_createSummaryWithTextNoA11y(text.release()));
    return _p;
}

inline Dom Dom::create_dialog(DialogAriaInfo aria) {
    Dom::Proxy _p(AzDom_createDialog(aria.release()));
    return _p;
}

inline Dom Dom::create_dialog_no_a11y() {
    Dom::Proxy _p(AzDom_createDialogNoA11y());
    return _p;
}

inline Dom Dom::create_p() {
    Dom::Proxy _p(AzDom_createP());
    return _p;
}

inline Dom Dom::create_h1() {
    Dom::Proxy _p(AzDom_createH1());
    return _p;
}

inline Dom Dom::create_h1_with_text(String text) {
    Dom::Proxy _p(AzDom_createH1WithText(text.release()));
    return _p;
}

inline Dom Dom::create_h2() {
    Dom::Proxy _p(AzDom_createH2());
    return _p;
}

inline Dom Dom::create_h2_with_text(String text) {
    Dom::Proxy _p(AzDom_createH2WithText(text.release()));
    return _p;
}

inline Dom Dom::create_h3() {
    Dom::Proxy _p(AzDom_createH3());
    return _p;
}

inline Dom Dom::create_h3_with_text(String text) {
    Dom::Proxy _p(AzDom_createH3WithText(text.release()));
    return _p;
}

inline Dom Dom::create_h4() {
    Dom::Proxy _p(AzDom_createH4());
    return _p;
}

inline Dom Dom::create_h4_with_text(String text) {
    Dom::Proxy _p(AzDom_createH4WithText(text.release()));
    return _p;
}

inline Dom Dom::create_h5() {
    Dom::Proxy _p(AzDom_createH5());
    return _p;
}

inline Dom Dom::create_h5_with_text(String text) {
    Dom::Proxy _p(AzDom_createH5WithText(text.release()));
    return _p;
}

inline Dom Dom::create_h6() {
    Dom::Proxy _p(AzDom_createH6());
    return _p;
}

inline Dom Dom::create_h6_with_text(String text) {
    Dom::Proxy _p(AzDom_createH6WithText(text.release()));
    return _p;
}

inline Dom Dom::create_span() {
    Dom::Proxy _p(AzDom_createSpan());
    return _p;
}

inline Dom Dom::create_span_with_text(String text) {
    Dom::Proxy _p(AzDom_createSpanWithText(text.release()));
    return _p;
}

inline Dom Dom::create_strong() {
    Dom::Proxy _p(AzDom_createStrong());
    return _p;
}

inline Dom Dom::create_strong_with_text(String text) {
    Dom::Proxy _p(AzDom_createStrongWithText(text.release()));
    return _p;
}

inline Dom Dom::create_em() {
    Dom::Proxy _p(AzDom_createEm());
    return _p;
}

inline Dom Dom::create_em_with_text(String text) {
    Dom::Proxy _p(AzDom_createEmWithText(text.release()));
    return _p;
}

inline Dom Dom::create_code() {
    Dom::Proxy _p(AzDom_createCode());
    return _p;
}

inline Dom Dom::create_code_with_text(String code) {
    Dom::Proxy _p(AzDom_createCodeWithText(code.release()));
    return _p;
}

inline Dom Dom::create_pre() {
    Dom::Proxy _p(AzDom_createPre());
    return _p;
}

inline Dom Dom::create_pre_with_text(String text) {
    Dom::Proxy _p(AzDom_createPreWithText(text.release()));
    return _p;
}

inline Dom Dom::create_blockquote() {
    Dom::Proxy _p(AzDom_createBlockquote());
    return _p;
}

inline Dom Dom::create_blockquote_with_text(String text) {
    Dom::Proxy _p(AzDom_createBlockquoteWithText(text.release()));
    return _p;
}

inline Dom Dom::create_cite() {
    Dom::Proxy _p(AzDom_createCite());
    return _p;
}

inline Dom Dom::create_cite_with_text(String text) {
    Dom::Proxy _p(AzDom_createCiteWithText(text.release()));
    return _p;
}

inline Dom Dom::create_abbr() {
    Dom::Proxy _p(AzDom_createAbbr());
    return _p;
}

inline Dom Dom::create_abbr_with_title(String abbr_text, String title) {
    Dom::Proxy _p(AzDom_createAbbrWithTitle(abbr_text.release(), title.release()));
    return _p;
}

inline Dom Dom::create_kbd() {
    Dom::Proxy _p(AzDom_createKbd());
    return _p;
}

inline Dom Dom::create_kbd_with_text(String text) {
    Dom::Proxy _p(AzDom_createKbdWithText(text.release()));
    return _p;
}

inline Dom Dom::create_samp() {
    Dom::Proxy _p(AzDom_createSamp());
    return _p;
}

inline Dom Dom::create_samp_with_text(String text) {
    Dom::Proxy _p(AzDom_createSampWithText(text.release()));
    return _p;
}

inline Dom Dom::create_var() {
    Dom::Proxy _p(AzDom_createVar());
    return _p;
}

inline Dom Dom::create_var_with_text(String text) {
    Dom::Proxy _p(AzDom_createVarWithText(text.release()));
    return _p;
}

inline Dom Dom::create_sub() {
    Dom::Proxy _p(AzDom_createSub());
    return _p;
}

inline Dom Dom::create_sub_with_text(String text) {
    Dom::Proxy _p(AzDom_createSubWithText(text.release()));
    return _p;
}

inline Dom Dom::create_sup() {
    Dom::Proxy _p(AzDom_createSup());
    return _p;
}

inline Dom Dom::create_sup_with_text(String text) {
    Dom::Proxy _p(AzDom_createSupWithText(text.release()));
    return _p;
}

inline Dom Dom::create_u() {
    Dom::Proxy _p(AzDom_createU());
    return _p;
}

inline Dom Dom::create_u_with_text(String text) {
    Dom::Proxy _p(AzDom_createUWithText(text.release()));
    return _p;
}

inline Dom Dom::create_s() {
    Dom::Proxy _p(AzDom_createS());
    return _p;
}

inline Dom Dom::create_s_with_text(String text) {
    Dom::Proxy _p(AzDom_createSWithText(text.release()));
    return _p;
}

inline Dom Dom::create_mark() {
    Dom::Proxy _p(AzDom_createMark());
    return _p;
}

inline Dom Dom::create_mark_with_text(String text) {
    Dom::Proxy _p(AzDom_createMarkWithText(text.release()));
    return _p;
}

inline Dom Dom::create_del() {
    Dom::Proxy _p(AzDom_createDel());
    return _p;
}

inline Dom Dom::create_del_with_text(String text) {
    Dom::Proxy _p(AzDom_createDelWithText(text.release()));
    return _p;
}

inline Dom Dom::create_ins() {
    Dom::Proxy _p(AzDom_createIns());
    return _p;
}

inline Dom Dom::create_ins_with_text(String text) {
    Dom::Proxy _p(AzDom_createInsWithText(text.release()));
    return _p;
}

inline Dom Dom::create_dfn() {
    Dom::Proxy _p(AzDom_createDfn());
    return _p;
}

inline Dom Dom::create_dfn_with_text(String text) {
    Dom::Proxy _p(AzDom_createDfnWithText(text.release()));
    return _p;
}

inline Dom Dom::create_time(String text, OptionString datetime) {
    Dom::Proxy _p(AzDom_createTime(text.release(), datetime.release()));
    return _p;
}

inline Dom Dom::create_bdo() {
    Dom::Proxy _p(AzDom_createBdo());
    return _p;
}

inline Dom Dom::create_bdo_with_text(String text) {
    Dom::Proxy _p(AzDom_createBdoWithText(text.release()));
    return _p;
}

inline Dom Dom::create_a(String href, String text, SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createA(href.release(), text.release(), aria.release()));
    return _p;
}

inline Dom Dom::create_a_no_a11y(String href, OptionString label) {
    Dom::Proxy _p(AzDom_createANoA11y(href.release(), label.release()));
    return _p;
}

inline Dom Dom::create_button(String text, SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createButton(text.release(), aria.release()));
    return _p;
}

inline Dom Dom::create_button_no_a11y(String text) {
    Dom::Proxy _p(AzDom_createButtonNoA11y(text.release()));
    return _p;
}

inline Dom Dom::create_label(String for_id, String text, SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createLabel(for_id.release(), text.release(), aria.release()));
    return _p;
}

inline Dom Dom::create_label_no_a11y(String for_id, String text) {
    Dom::Proxy _p(AzDom_createLabelNoA11y(for_id.release(), text.release()));
    return _p;
}

inline Dom Dom::create_input(String input_type, String name, String label, SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createInput(input_type.release(), name.release(), label.release(), aria.release()));
    return _p;
}

inline Dom Dom::create_input_no_a11y(String input_type, String name, String label) {
    Dom::Proxy _p(AzDom_createInputNoA11y(input_type.release(), name.release(), label.release()));
    return _p;
}

inline Dom Dom::create_textarea(String name, String label, SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createTextarea(name.release(), label.release(), aria.release()));
    return _p;
}

inline Dom Dom::create_textarea_no_a11y(String name, String label) {
    Dom::Proxy _p(AzDom_createTextareaNoA11y(name.release(), label.release()));
    return _p;
}

inline Dom Dom::create_select(String name, String label, SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createSelect(name.release(), label.release(), aria.release()));
    return _p;
}

inline Dom Dom::create_select_no_a11y(String name, String label) {
    Dom::Proxy _p(AzDom_createSelectNoA11y(name.release(), label.release()));
    return _p;
}

inline Dom Dom::create_option(String value, String text, SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createOption(value.release(), text.release(), aria.release()));
    return _p;
}

inline Dom Dom::create_option_no_a11y(String value, String text) {
    Dom::Proxy _p(AzDom_createOptionNoA11y(value.release(), text.release()));
    return _p;
}

inline Dom Dom::create_ul() {
    Dom::Proxy _p(AzDom_createUl());
    return _p;
}

inline Dom Dom::create_ol() {
    Dom::Proxy _p(AzDom_createOl());
    return _p;
}

inline Dom Dom::create_li() {
    Dom::Proxy _p(AzDom_createLi());
    return _p;
}

inline Dom Dom::create_table(String caption, SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createTable(caption.release(), aria.release()));
    return _p;
}

inline Dom Dom::create_table_no_a11y() {
    Dom::Proxy _p(AzDom_createTableNoA11y());
    return _p;
}

inline Dom Dom::create_caption() {
    Dom::Proxy _p(AzDom_createCaption());
    return _p;
}

inline Dom Dom::create_thead() {
    Dom::Proxy _p(AzDom_createThead());
    return _p;
}

inline Dom Dom::create_tbody() {
    Dom::Proxy _p(AzDom_createTbody());
    return _p;
}

inline Dom Dom::create_tfoot() {
    Dom::Proxy _p(AzDom_createTfoot());
    return _p;
}

inline Dom Dom::create_tr() {
    Dom::Proxy _p(AzDom_createTr());
    return _p;
}

inline Dom Dom::create_th() {
    Dom::Proxy _p(AzDom_createTh());
    return _p;
}

inline Dom Dom::create_td() {
    Dom::Proxy _p(AzDom_createTd());
    return _p;
}

inline Dom Dom::create_form(SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createForm(aria.release()));
    return _p;
}

inline Dom Dom::create_form_no_a11y() {
    Dom::Proxy _p(AzDom_createFormNoA11y());
    return _p;
}

inline Dom Dom::create_fieldset(SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createFieldset(aria.release()));
    return _p;
}

inline Dom Dom::create_fieldset_no_a11y() {
    Dom::Proxy _p(AzDom_createFieldsetNoA11y());
    return _p;
}

inline Dom Dom::create_legend(SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createLegend(aria.release()));
    return _p;
}

inline Dom Dom::create_legend_no_a11y() {
    Dom::Proxy _p(AzDom_createLegendNoA11y());
    return _p;
}

inline Dom Dom::create_hr() {
    Dom::Proxy _p(AzDom_createHr());
    return _p;
}

inline Dom Dom::create_address() {
    Dom::Proxy _p(AzDom_createAddress());
    return _p;
}

inline Dom Dom::create_dl() {
    Dom::Proxy _p(AzDom_createDl());
    return _p;
}

inline Dom Dom::create_dt() {
    Dom::Proxy _p(AzDom_createDt());
    return _p;
}

inline Dom Dom::create_dd() {
    Dom::Proxy _p(AzDom_createDd());
    return _p;
}

inline Dom Dom::create_colgroup() {
    Dom::Proxy _p(AzDom_createColgroup());
    return _p;
}

inline Dom Dom::create_col(int32_t span) {
    Dom::Proxy _p(AzDom_createCol(span));
    return _p;
}

inline Dom Dom::create_optgroup(String label, SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createOptgroup(label.release(), aria.release()));
    return _p;
}

inline Dom Dom::create_optgroup_no_a11y(String label) {
    Dom::Proxy _p(AzDom_createOptgroupNoA11y(label.release()));
    return _p;
}

inline Dom Dom::create_q() {
    Dom::Proxy _p(AzDom_createQ());
    return _p;
}

inline Dom Dom::create_acronym() {
    Dom::Proxy _p(AzDom_createAcronym());
    return _p;
}

inline Dom Dom::create_acronym_with_text(String text) {
    Dom::Proxy _p(AzDom_createAcronymWithText(text.release()));
    return _p;
}

inline Dom Dom::create_menu(SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createMenu(aria.release()));
    return _p;
}

inline Dom Dom::create_menu_no_a11y() {
    Dom::Proxy _p(AzDom_createMenuNoA11y());
    return _p;
}

inline Dom Dom::create_menuitem(SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createMenuitem(aria.release()));
    return _p;
}

inline Dom Dom::create_menuitem_no_a11y() {
    Dom::Proxy _p(AzDom_createMenuitemNoA11y());
    return _p;
}

inline Dom Dom::create_menuitem_with_text(String text, SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createMenuitemWithText(text.release(), aria.release()));
    return _p;
}

inline Dom Dom::create_menuitem_with_text_no_a11y(String text) {
    Dom::Proxy _p(AzDom_createMenuitemWithTextNoA11y(text.release()));
    return _p;
}

inline Dom Dom::create_output(SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createOutput(aria.release()));
    return _p;
}

inline Dom Dom::create_output_no_a11y() {
    Dom::Proxy _p(AzDom_createOutputNoA11y());
    return _p;
}

inline Dom Dom::create_progress(ProgressAriaInfo aria) {
    Dom::Proxy _p(AzDom_createProgress(aria.release()));
    return _p;
}

inline Dom Dom::create_progress_no_a11y(float value, float max) {
    Dom::Proxy _p(AzDom_createProgressNoA11y(value, max));
    return _p;
}

inline Dom Dom::create_meter(MeterAriaInfo aria) {
    Dom::Proxy _p(AzDom_createMeter(aria.release()));
    return _p;
}

inline Dom Dom::create_meter_no_a11y(float value, float min, float max) {
    Dom::Proxy _p(AzDom_createMeterNoA11y(value, min, max));
    return _p;
}

inline Dom Dom::create_datalist(SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createDatalist(aria.release()));
    return _p;
}

inline Dom Dom::create_datalist_no_a11y() {
    Dom::Proxy _p(AzDom_createDatalistNoA11y());
    return _p;
}

inline Dom Dom::create_canvas(SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createCanvas(aria.release()));
    return _p;
}

inline Dom Dom::create_canvas_no_a11y() {
    Dom::Proxy _p(AzDom_createCanvasNoA11y());
    return _p;
}

inline Dom Dom::create_object() {
    Dom::Proxy _p(AzDom_createObject());
    return _p;
}

inline Dom Dom::create_param(String name, String value) {
    Dom::Proxy _p(AzDom_createParam(name.release(), value.release()));
    return _p;
}

inline Dom Dom::create_embed() {
    Dom::Proxy _p(AzDom_createEmbed());
    return _p;
}

inline Dom Dom::create_audio(SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createAudio(aria.release()));
    return _p;
}

inline Dom Dom::create_audio_no_a11y() {
    Dom::Proxy _p(AzDom_createAudioNoA11y());
    return _p;
}

inline Dom Dom::create_video(SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createVideo(aria.release()));
    return _p;
}

inline Dom Dom::create_video_no_a11y() {
    Dom::Proxy _p(AzDom_createVideoNoA11y());
    return _p;
}

inline Dom Dom::create_source(String src, String media_type) {
    Dom::Proxy _p(AzDom_createSource(src.release(), media_type.release()));
    return _p;
}

inline Dom Dom::create_track(String src, String kind) {
    Dom::Proxy _p(AzDom_createTrack(src.release(), kind.release()));
    return _p;
}

inline Dom Dom::create_map() {
    Dom::Proxy _p(AzDom_createMap());
    return _p;
}

inline Dom Dom::create_area(SmallAriaInfo aria) {
    Dom::Proxy _p(AzDom_createArea(aria.release()));
    return _p;
}

inline Dom Dom::create_area_no_a11y() {
    Dom::Proxy _p(AzDom_createAreaNoA11y());
    return _p;
}

inline Dom Dom::create_title() {
    Dom::Proxy _p(AzDom_createTitle());
    return _p;
}

inline Dom Dom::create_title_with_text(String text) {
    Dom::Proxy _p(AzDom_createTitleWithText(text.release()));
    return _p;
}

inline Dom Dom::create_meta() {
    Dom::Proxy _p(AzDom_createMeta());
    return _p;
}

inline Dom Dom::create_link() {
    Dom::Proxy _p(AzDom_createLink());
    return _p;
}

inline Dom Dom::create_script() {
    Dom::Proxy _p(AzDom_createScript());
    return _p;
}

inline Dom Dom::create_style() {
    Dom::Proxy _p(AzDom_createStyle());
    return _p;
}

inline Dom Dom::create_style_with_text(String text) {
    Dom::Proxy _p(AzDom_createStyleWithText(text.release()));
    return _p;
}

inline Dom Dom::create_base(String href) {
    Dom::Proxy _p(AzDom_createBase(href.release()));
    return _p;
}

inline Dom Dom::create_b() {
    Dom::Proxy _p(AzDom_createB());
    return _p;
}

inline Dom Dom::create_b_with_text(String text) {
    Dom::Proxy _p(AzDom_createBWithText(text.release()));
    return _p;
}

inline Dom Dom::create_i() {
    Dom::Proxy _p(AzDom_createI());
    return _p;
}

inline Dom Dom::create_i_with_text(String text) {
    Dom::Proxy _p(AzDom_createIWithText(text.release()));
    return _p;
}

inline Dom Dom::create_small() {
    Dom::Proxy _p(AzDom_createSmall());
    return _p;
}

inline Dom Dom::create_small_with_text(String text) {
    Dom::Proxy _p(AzDom_createSmallWithText(text.release()));
    return _p;
}

inline Dom Dom::create_big() {
    Dom::Proxy _p(AzDom_createBig());
    return _p;
}

inline Dom Dom::create_big_with_text(String text) {
    Dom::Proxy _p(AzDom_createBigWithText(text.release()));
    return _p;
}

inline Dom Dom::create_bdi() {
    Dom::Proxy _p(AzDom_createBdi());
    return _p;
}

inline Dom Dom::create_bdi_with_text(String text) {
    Dom::Proxy _p(AzDom_createBdiWithText(text.release()));
    return _p;
}

inline Dom Dom::create_wbr() {
    Dom::Proxy _p(AzDom_createWbr());
    return _p;
}

inline Dom Dom::create_ruby() {
    Dom::Proxy _p(AzDom_createRuby());
    return _p;
}

inline Dom Dom::create_rt() {
    Dom::Proxy _p(AzDom_createRt());
    return _p;
}

inline Dom Dom::create_rt_with_text(String text) {
    Dom::Proxy _p(AzDom_createRtWithText(text.release()));
    return _p;
}

inline Dom Dom::create_rtc() {
    Dom::Proxy _p(AzDom_createRtc());
    return _p;
}

inline Dom Dom::create_rp() {
    Dom::Proxy _p(AzDom_createRp());
    return _p;
}

inline Dom Dom::create_rp_with_text(String text) {
    Dom::Proxy _p(AzDom_createRpWithText(text.release()));
    return _p;
}

inline Dom Dom::create_data(String value) {
    Dom::Proxy _p(AzDom_createData(value.release()));
    return _p;
}

inline Dom Dom::create_data_with_text(String value, String text) {
    Dom::Proxy _p(AzDom_createDataWithText(value.release(), text.release()));
    return _p;
}

inline Dom Dom::create_dir() {
    Dom::Proxy _p(AzDom_createDir());
    return _p;
}

inline Dom Dom::create_svg() {
    Dom::Proxy _p(AzDom_createSvg());
    return _p;
}

inline Dom Dom::create_th_with_scope(String scope, String text) {
    Dom::Proxy _p(AzDom_createThWithScope(scope.release(), text.release()));
    return _p;
}

inline Dom Dom::create_td_with_text(String text) {
    Dom::Proxy _p(AzDom_createTdWithText(text.release()));
    return _p;
}

inline Dom Dom::create_th_with_text(String text) {
    Dom::Proxy _p(AzDom_createThWithText(text.release()));
    return _p;
}

inline Dom Dom::create_li_with_text(String text) {
    Dom::Proxy _p(AzDom_createLiWithText(text.release()));
    return _p;
}

inline Dom Dom::create_p_with_text(String text) {
    Dom::Proxy _p(AzDom_createPWithText(text.release()));
    return _p;
}

inline Dom Dom::create_geolocation_probe(GeolocationProbeConfig config) {
    Dom::Proxy _p(AzDom_createGeolocationProbe(config.release()));
    return _p;
}

inline Dom Dom::default_() {
    Dom::Proxy _p(AzDom_default());
    return _p;
}

inline Dom Dom::with_dataset(OptionRefAny data) const {
    Dom::Proxy _p(AzDom_withDataset(inner_, data.release()));
    return _p;
}

inline Dom Dom::with_ids_and_classes(IdOrClassVec ids_and_classes) const {
    Dom::Proxy _p(AzDom_withIdsAndClasses(inner_, ids_and_classes.release()));
    return _p;
}

inline Dom Dom::with_callbacks(CoreCallbackDataVec callbacks) const {
    Dom::Proxy _p(AzDom_withCallbacks(inner_, callbacks.release()));
    return _p;
}

inline Dom Dom::with_callback(AzEventFilter event, RefAny data, AzCallbackType callback) const {
    Dom::Proxy _p(AzDom_withCallback(inner_, event, data.release(), callback));
    return _p;
}

inline void Dom::add_child(Dom child) {
    AzDom_addChild(&inner_, child.release());
}

inline Dom Dom::with_child(Dom child) const {
    Dom::Proxy _p(AzDom_withChild(inner_, child.release()));
    return _p;
}

inline void Dom::set_children(DomVec children) {
    AzDom_setChildren(&inner_, children.release());
}

inline Dom Dom::with_children(DomVec children) const {
    Dom::Proxy _p(AzDom_withChildren(inner_, children.release()));
    return _p;
}

inline Dom Dom::with_id(String id) const {
    Dom::Proxy _p(AzDom_withId(inner_, id.release()));
    return _p;
}

inline Dom Dom::with_class(String class_) const {
    Dom::Proxy _p(AzDom_withClass(inner_, class_.release()));
    return _p;
}

inline void Dom::add_css_property(CssPropertyWithConditions prop) {
    AzDom_addCssProperty(&inner_, prop.release());
}

inline Dom Dom::with_css_property(CssPropertyWithConditions prop) const {
    Dom::Proxy _p(AzDom_withCssProperty(inner_, prop.release()));
    return _p;
}

inline Dom Dom::with_clip_mask(ImageMask clip_mask) const {
    Dom::Proxy _p(AzDom_withClipMask(inner_, clip_mask.release()));
    return _p;
}

inline Dom Dom::with_tab_index(AzTabIndex tab_index) const {
    Dom::Proxy _p(AzDom_withTabIndex(inner_, tab_index));
    return _p;
}

inline Dom Dom::with_contenteditable(bool contenteditable) const {
    Dom::Proxy _p(AzDom_withContenteditable(inner_, contenteditable));
    return _p;
}

inline Dom Dom::with_accessibility_info(AccessibilityInfo accessibility_info) const {
    Dom::Proxy _p(AzDom_withAccessibilityInfo(inner_, accessibility_info.release()));
    return _p;
}

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 {
    Dom::Proxy _p(AzDom_withMenuBar(inner_, menu_bar.release()));
    return _p;
}

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 {
    Dom::Proxy _p(AzDom_withContextMenu(inner_, context_menu.release()));
    return _p;
}

inline size_t Dom::node_count() const {
    return AzDom_nodeCount(&inner_);
}

inline Dom Dom::with_component_css(Css css) const {
    Dom::Proxy _p(AzDom_withComponentCss(inner_, css.release()));
    return _p;
}

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() {
    Dom::Proxy _p(AzDom_swapWithDefault(&inner_));
    return _p;
}

inline Dom Dom::copy_except_for_root() {
    Dom::Proxy _p(AzDom_copyExceptForRoot(&inner_));
    return _p;
}

inline Dom Dom::with_attribute(AzAttributeType attr) const {
    Dom::Proxy _p(AzDom_withAttribute(inner_, attr));
    return _p;
}

inline Dom Dom::with_attributes(AttributeTypeVec attributes) const {
    Dom::Proxy _p(AzDom_withAttributes(inner_, attributes.release()));
    return _p;
}

inline size_t Dom::fixup_children_estimated() {
    return AzDom_fixupChildrenEstimated(&inner_);
}

inline Dom Dom::with_merge_callback(AzDatasetMergeCallbackType callback) const {
    Dom::Proxy _p(AzDom_withMergeCallback(inner_, az_detail_wrap_cb<AzDatasetMergeCallback>(callback)));
    return _p;
}

inline Dom Dom::with_css(String style) const {
    Dom::Proxy _p(AzDom_withCss(inner_, style.release()));
    return _p;
}

inline Dom Dom::with_css_props(CssPropertyWithConditionsVec css_props) const {
    Dom::Proxy _p(AzDom_withCssProps(inner_, css_props.release()));
    return _p;
}

inline Dom Dom::with_node_type(AzNodeType node_type) const {
    Dom::Proxy _p(AzDom_withNodeType(inner_, node_type));
    return _p;
}

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 {
    Dom::Proxy _p(AzDom_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDom_toDbgString(&inner_));
    return _p;
}

inline SystemStyle SystemStyle::detect() {
    SystemStyle::Proxy _p(AzSystemStyle_detect());
    return _p;
}

inline SystemStyle SystemStyle::default_() {
    SystemStyle::Proxy _p(AzSystemStyle_default());
    return _p;
}

inline Css SystemStyle::create_csd_stylesheet() const {
    Css::Proxy _p(AzSystemStyle_createCsdStylesheet(&inner_));
    return _p;
}

inline void SystemStyle::delete_() {
    AzSystemStyle_delete(&inner_);
}

inline SystemStyle SystemStyle::clone() const {
    SystemStyle::Proxy _p(AzSystemStyle_clone(&inner_));
    return _p;
}

inline bool SystemStyle::partialEq(const SystemStyle& b) const {
    return AzSystemStyle_partialEq(&inner_, b.ptr());
}

inline String SystemStyle::toDbgString() const {
    String::Proxy _p(AzSystemStyle_toDbgString(&inner_));
    return _p;
}

inline void CssStyleBorderRadiusParseErrorOwned::delete_() {
    AzCssStyleBorderRadiusParseErrorOwned_delete(&inner_);
}

inline CssStyleBorderRadiusParseErrorOwned CssStyleBorderRadiusParseErrorOwned::clone() const {
    CssStyleBorderRadiusParseErrorOwned::Proxy _p(AzCssStyleBorderRadiusParseErrorOwned_clone(&inner_));
    return _p;
}

inline bool CssStyleBorderRadiusParseErrorOwned::partialEq(const CssStyleBorderRadiusParseErrorOwned& b) const {
    return AzCssStyleBorderRadiusParseErrorOwned_partialEq(&inner_, b.ptr());
}

inline String CssStyleBorderRadiusParseErrorOwned::toDbgString() const {
    String::Proxy _p(AzCssStyleBorderRadiusParseErrorOwned_toDbgString(&inner_));
    return _p;
}

inline FileInput FileInput::create(OptionString path) {
    FileInput::Proxy _p(AzFileInput_create(path.release()));
    return _p;
}

inline FileInput FileInput::default_() {
    FileInput::Proxy _p(AzFileInput_default());
    return _p;
}

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 {
    FileInput::Proxy _p(AzFileInput_withDefaultText(inner_, default_text.release()));
    return _p;
}

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 {
    FileInput::Proxy _p(AzFileInput_withOnPathChange(inner_, data.release(), callback));
    return _p;
}

inline Dom FileInput::dom() const {
    Dom::Proxy _p(AzFileInput_dom(inner_));
    return _p;
}

inline void FileInput::delete_() {
    AzFileInput_delete(&inner_);
}

inline FileInput FileInput::clone() const {
    FileInput::Proxy _p(AzFileInput_clone(&inner_));
    return _p;
}

inline bool FileInput::partialEq(const FileInput& b) const {
    return AzFileInput_partialEq(&inner_, b.ptr());
}

inline String FileInput::toDbgString() const {
    String::Proxy _p(AzFileInput_toDbgString(&inner_));
    return _p;
}

inline CheckBox CheckBox::create(bool checked) {
    CheckBox::Proxy _p(AzCheckBox_create(checked));
    return _p;
}

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 {
    CheckBox::Proxy _p(AzCheckBox_withOnToggle(inner_, data.release(), callback));
    return _p;
}

inline Dom CheckBox::dom() const {
    Dom::Proxy _p(AzCheckBox_dom(inner_));
    return _p;
}

inline void CheckBox::delete_() {
    AzCheckBox_delete(&inner_);
}

inline CheckBox CheckBox::clone() const {
    CheckBox::Proxy _p(AzCheckBox_clone(&inner_));
    return _p;
}

inline bool CheckBox::partialEq(const CheckBox& b) const {
    return AzCheckBox_partialEq(&inner_, b.ptr());
}

inline String CheckBox::toDbgString() const {
    String::Proxy _p(AzCheckBox_toDbgString(&inner_));
    return _p;
}

inline ColorInput ColorInput::create(ColorU color) {
    ColorInput::Proxy _p(AzColorInput_create(color.release()));
    return _p;
}

inline ColorInput ColorInput::default_() {
    ColorInput::Proxy _p(AzColorInput_default());
    return _p;
}

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 {
    ColorInput::Proxy _p(AzColorInput_withOnValueChange(inner_, data.release(), callback));
    return _p;
}

inline Dom ColorInput::dom() const {
    Dom::Proxy _p(AzColorInput_dom(inner_));
    return _p;
}

inline void ColorInput::delete_() {
    AzColorInput_delete(&inner_);
}

inline ColorInput ColorInput::clone() const {
    ColorInput::Proxy _p(AzColorInput_clone(&inner_));
    return _p;
}

inline bool ColorInput::partialEq(const ColorInput& b) const {
    return AzColorInput_partialEq(&inner_, b.ptr());
}

inline String ColorInput::toDbgString() const {
    String::Proxy _p(AzColorInput_toDbgString(&inner_));
    return _p;
}

inline TextInput TextInput::create() {
    TextInput::Proxy _p(AzTextInput_create());
    return _p;
}

inline TextInput TextInput::default_() {
    TextInput::Proxy _p(AzTextInput_default());
    return _p;
}

inline void TextInput::set_text(String text) {
    AzTextInput_setText(&inner_, text.release());
}

inline TextInput TextInput::with_text(String text) const {
    TextInput::Proxy _p(AzTextInput_withText(inner_, text.release()));
    return _p;
}

inline void TextInput::set_placeholder(String text) {
    AzTextInput_setPlaceholder(&inner_, text.release());
}

inline TextInput TextInput::with_placeholder(String text) const {
    TextInput::Proxy _p(AzTextInput_withPlaceholder(inner_, text.release()));
    return _p;
}

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 {
    TextInput::Proxy _p(AzTextInput_withOnTextInput(inner_, data.release(), callback));
    return _p;
}

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 {
    TextInput::Proxy _p(AzTextInput_withOnVirtualKeyDown(inner_, data.release(), callback));
    return _p;
}

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 {
    TextInput::Proxy _p(AzTextInput_withOnFocusLost(inner_, data.release(), callback));
    return _p;
}

inline Dom TextInput::dom() const {
    Dom::Proxy _p(AzTextInput_dom(inner_));
    return _p;
}

inline void TextInput::delete_() {
    AzTextInput_delete(&inner_);
}

inline TextInput TextInput::clone() const {
    TextInput::Proxy _p(AzTextInput_clone(&inner_));
    return _p;
}

inline bool TextInput::partialEq(const TextInput& b) const {
    return AzTextInput_partialEq(&inner_, b.ptr());
}

inline String TextInput::toDbgString() const {
    String::Proxy _p(AzTextInput_toDbgString(&inner_));
    return _p;
}

inline void ComponentDataField::delete_() {
    AzComponentDataField_delete(&inner_);
}

inline ComponentDataField ComponentDataField::clone() const {
    ComponentDataField::Proxy _p(AzComponentDataField_clone(&inner_));
    return _p;
}

inline bool ComponentDataField::partialEq(const ComponentDataField& b) const {
    return AzComponentDataField_partialEq(&inner_, b.ptr());
}

inline String ComponentDataField::toDbgString() const {
    String::Proxy _p(AzComponentDataField_toDbgString(&inner_));
    return _p;
}

inline FullWindowState FullWindowState::default_() {
    FullWindowState::Proxy _p(AzFullWindowState_default());
    return _p;
}

inline void FullWindowState::delete_() {
    AzFullWindowState_delete(&inner_);
}

inline FullWindowState FullWindowState::clone() const {
    FullWindowState::Proxy _p(AzFullWindowState_clone(&inner_));
    return _p;
}

inline bool FullWindowState::partialEq(const FullWindowState& b) const {
    return AzFullWindowState_partialEq(&inner_, b.ptr());
}

inline String FullWindowState::toDbgString() const {
    String::Proxy _p(AzFullWindowState_toDbgString(&inner_));
    return _p;
}

inline void UndoableOperation::delete_() {
    AzUndoableOperation_delete(&inner_);
}

inline UndoableOperation UndoableOperation::clone() const {
    UndoableOperation::Proxy _p(AzUndoableOperation_clone(&inner_));
    return _p;
}

inline String UndoableOperation::toDbgString() const {
    String::Proxy _p(AzUndoableOperation_toDbgString(&inner_));
    return _p;
}

inline NumberInput NumberInput::create(float number) {
    NumberInput::Proxy _p(AzNumberInput_create(number));
    return _p;
}

inline NumberInput NumberInput::default_() {
    NumberInput::Proxy _p(AzNumberInput_default());
    return _p;
}

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 {
    NumberInput::Proxy _p(AzNumberInput_withOnTextInput(inner_, data.release(), callback));
    return _p;
}

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 {
    NumberInput::Proxy _p(AzNumberInput_withOnVirtualKeyDown(inner_, data.release(), callback));
    return _p;
}

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 {
    NumberInput::Proxy _p(AzNumberInput_withOnFocusLost(inner_, data.release(), callback));
    return _p;
}

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 {
    NumberInput::Proxy _p(AzNumberInput_withOnValueChange(inner_, data.release(), callback));
    return _p;
}

inline Dom NumberInput::dom() const {
    Dom::Proxy _p(AzNumberInput_dom(inner_));
    return _p;
}

inline void NumberInput::delete_() {
    AzNumberInput_delete(&inner_);
}

inline NumberInput NumberInput::clone() const {
    NumberInput::Proxy _p(AzNumberInput_clone(&inner_));
    return _p;
}

inline bool NumberInput::partialEq(const NumberInput& b) const {
    return AzNumberInput_partialEq(&inner_, b.ptr());
}

inline String NumberInput::toDbgString() const {
    String::Proxy _p(AzNumberInput_toDbgString(&inner_));
    return _p;
}

inline Frame Frame::create(String title, Dom dom) {
    Frame::Proxy _p(AzFrame_create(title.release(), dom.release()));
    return _p;
}

inline void Frame::set_flex_grow(float flex_grow) {
    AzFrame_setFlexGrow(&inner_, flex_grow);
}

inline Frame Frame::with_flex_grow(float flex_grow) const {
    Frame::Proxy _p(AzFrame_withFlexGrow(inner_, flex_grow));
    return _p;
}

inline Dom Frame::dom() const {
    Dom::Proxy _p(AzFrame_dom(inner_));
    return _p;
}

inline void Frame::delete_() {
    AzFrame_delete(&inner_);
}

inline Frame Frame::clone() const {
    Frame::Proxy _p(AzFrame_clone(&inner_));
    return _p;
}

inline String Frame::toDbgString() const {
    String::Proxy _p(AzFrame_toDbgString(&inner_));
    return _p;
}

inline RibbonSection RibbonSection::new_(String title, Dom content) {
    RibbonSection::Proxy _p(AzRibbonSection_new(title.release(), content.release()));
    return _p;
}

inline void RibbonSection::delete_() {
    AzRibbonSection_delete(&inner_);
}

inline RibbonSection RibbonSection::clone() const {
    RibbonSection::Proxy _p(AzRibbonSection_clone(&inner_));
    return _p;
}

inline String RibbonSection::toDbgString() const {
    String::Proxy _p(AzRibbonSection_toDbgString(&inner_));
    return _p;
}

inline AppConfig AppConfig::create() {
    AppConfig::Proxy _p(AzAppConfig_create());
    return _p;
}

inline AppConfig AppConfig::default_() {
    AppConfig::Proxy _p(AzAppConfig_default());
    return _p;
}

inline void AppConfig::delete_() {
    AzAppConfig_delete(&inner_);
}

inline AppConfig AppConfig::clone() const {
    AppConfig::Proxy _p(AzAppConfig_clone(&inner_));
    return _p;
}

inline String AppConfig::toDbgString() const {
    String::Proxy _p(AzAppConfig_toDbgString(&inner_));
    return _p;
}

inline WindowCreateOptions WindowCreateOptions::create(AzLayoutCallbackType layout_callback) {
    WindowCreateOptions::Proxy _p(AzWindowCreateOptions_create(layout_callback));
    return _p;
}

inline WindowCreateOptions WindowCreateOptions::default_() {
    WindowCreateOptions::Proxy _p(AzWindowCreateOptions_default());
    return _p;
}

inline void WindowCreateOptions::delete_() {
    AzWindowCreateOptions_delete(&inner_);
}

inline WindowCreateOptions WindowCreateOptions::clone() const {
    WindowCreateOptions::Proxy _p(AzWindowCreateOptions_clone(&inner_));
    return _p;
}

inline bool WindowCreateOptions::partialEq(const WindowCreateOptions& b) const {
    return AzWindowCreateOptions_partialEq(&inner_, b.ptr());
}

inline String WindowCreateOptions::toDbgString() const {
    String::Proxy _p(AzWindowCreateOptions_toDbgString(&inner_));
    return _p;
}

inline VirtualViewReturn VirtualViewReturn::with_dom(Dom dom, LogicalSize scroll_size, LogicalPosition scroll_offset, LogicalSize virtual_scroll_size, LogicalPosition virtual_scroll_offset) {
    VirtualViewReturn::Proxy _p(AzVirtualViewReturn_withDom(dom.release(), scroll_size.release(), scroll_offset.release(), virtual_scroll_size.release(), virtual_scroll_offset.release()));
    return _p;
}

inline VirtualViewReturn VirtualViewReturn::keep_current(LogicalSize scroll_size, LogicalPosition scroll_offset, LogicalSize virtual_scroll_size, LogicalPosition virtual_scroll_offset) {
    VirtualViewReturn::Proxy _p(AzVirtualViewReturn_keepCurrent(scroll_size.release(), scroll_offset.release(), virtual_scroll_size.release(), virtual_scroll_offset.release()));
    return _p;
}

inline VirtualViewReturn VirtualViewReturn::default_() {
    VirtualViewReturn::Proxy _p(AzVirtualViewReturn_default());
    return _p;
}

inline void VirtualViewReturn::delete_() {
    AzVirtualViewReturn_delete(&inner_);
}

inline VirtualViewReturn VirtualViewReturn::clone() const {
    VirtualViewReturn::Proxy _p(AzVirtualViewReturn_clone(&inner_));
    return _p;
}

inline bool VirtualViewReturn::partialEq(const VirtualViewReturn& b) const {
    return AzVirtualViewReturn_partialEq(&inner_, b.ptr());
}

inline String VirtualViewReturn::toDbgString() const {
    String::Proxy _p(AzVirtualViewReturn_toDbgString(&inner_));
    return _p;
}

inline void DynamicCssProperty::delete_() {
    AzDynamicCssProperty_delete(&inner_);
}

inline DynamicCssProperty DynamicCssProperty::clone() const {
    DynamicCssProperty::Proxy _p(AzDynamicCssProperty_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzDynamicCssProperty_toDbgString(&inner_));
    return _p;
}

inline CssPropertyWithConditions CssPropertyWithConditions::simple(AzCssProperty property) {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_simple(property));
    return _p;
}

inline CssPropertyWithConditions CssPropertyWithConditions::with_condition(AzCssProperty property, AzDynamicSelector condition) {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_withCondition(property, condition));
    return _p;
}

inline CssPropertyWithConditions CssPropertyWithConditions::with_conditions(AzCssProperty property, DynamicSelectorVec conditions) {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_withConditions(property, conditions.release()));
    return _p;
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_hover(AzCssProperty property) {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_onHover(property));
    return _p;
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_active(AzCssProperty property) {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_onActive(property));
    return _p;
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_focus(AzCssProperty property) {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_onFocus(property));
    return _p;
}

inline CssPropertyWithConditions CssPropertyWithConditions::when_disabled(AzCssProperty property) {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_whenDisabled(property));
    return _p;
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_os(AzCssProperty property, AzOsCondition os) {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_onOs(property, os));
    return _p;
}

inline CssPropertyWithConditions CssPropertyWithConditions::dark_theme(AzCssProperty property) {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_darkTheme(property));
    return _p;
}

inline CssPropertyWithConditions CssPropertyWithConditions::light_theme(AzCssProperty property) {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_lightTheme(property));
    return _p;
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_windows(AzCssProperty property) {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_onWindows(property));
    return _p;
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_macos(AzCssProperty property) {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_onMacos(property));
    return _p;
}

inline CssPropertyWithConditions CssPropertyWithConditions::on_linux(AzCssProperty property) {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_onLinux(property));
    return _p;
}

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 {
    CssPropertyWithConditions::Proxy _p(AzCssPropertyWithConditions_clone(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzCssPropertyWithConditions_toDbgString(&inner_));
    return _p;
}

inline void CssBorderParseErrorOwned::delete_() {
    AzCssBorderParseErrorOwned_delete(&inner_);
}

inline CssBorderParseErrorOwned CssBorderParseErrorOwned::clone() const {
    CssBorderParseErrorOwned::Proxy _p(AzCssBorderParseErrorOwned_clone(&inner_));
    return _p;
}

inline bool CssBorderParseErrorOwned::partialEq(const CssBorderParseErrorOwned& b) const {
    return AzCssBorderParseErrorOwned_partialEq(&inner_, b.ptr());
}

inline String CssBorderParseErrorOwned::toDbgString() const {
    String::Proxy _p(AzCssBorderParseErrorOwned_toDbgString(&inner_));
    return _p;
}

inline void CssParseErrorOwned::delete_() {
    AzCssParseErrorOwned_delete(&inner_);
}

inline CssParseErrorOwned CssParseErrorOwned::clone() const {
    CssParseErrorOwned::Proxy _p(AzCssParseErrorOwned_clone(&inner_));
    return _p;
}

inline bool CssParseErrorOwned::partialEq(const CssParseErrorOwned& b) const {
    return AzCssParseErrorOwned_partialEq(&inner_, b.ptr());
}

inline String CssParseErrorOwned::toDbgString() const {
    String::Proxy _p(AzCssParseErrorOwned_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionI16_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionU16_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionU32_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionUsize_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionF32_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionF64_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionBool_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionI64_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionI32_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionU64_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionU8_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTimerId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionThread_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionImageRef_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionLayoutSize_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionColorU_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTabIndex_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionLogicalPosition_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionScreenPosition_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCursorNodePosition_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDragDelta_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionMouseCursorType_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionHwndHandle_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionLinuxDecorationsState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionLogicalSize_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionVirtualKeyCode_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionX11Visual_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionWindowTheme_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionAccessibilityRole_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionPenTilt_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionGestureDirection_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionThreadId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDomId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionAccessibilityState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionSvgVertex_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCascadeInfo_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionNodeHierarchyItem_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionXWindowType_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionStyleBackgroundRepeat_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionShapePoint_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionU8VecRef_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionNodeHierarchyItemId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionLinuxDesktopEnv_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionOsCondition_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionSvgDashPattern_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionSvgPoint_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionLocationFix_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionBiometricResult_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionWacomPadState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionScrollState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionPixelValue_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTextInputSelection_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionMenuItemIcon_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionFontRef_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionRefAny_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionLayoutRect_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDomNodeId_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDuration_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionLogicalRect_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionRendererOptions_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionGlContextPtr_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTextCursor_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionWindowFlags_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDetectedPinch_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDetectedRotation_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDetectedLongPress_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionPenState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionStyledNode_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionVideoMode_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionOsVersion_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTouchPoint_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionSensorReading_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionGamepadState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionPixelValueNoPercent_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionSelectionRange_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionMouseState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionThreadSendMsg_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTagIdToNodeIdMapping_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionNormalizedRadialColorStop_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionNormalizedLinearColorStop_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionStringVec_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionJsonVec_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionJsonKeyValueVec_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCalcAstItem_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionSvgPathElement_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionU8Vec_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultU8VecEncodeImageError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionMenu_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionVirtualKeyCodeCombo_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionString_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCallback_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTaskBarIcon_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionInstant_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionKeyboardState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionSelectionState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDatasetMergeCallback_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionStyleTransform_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionStyleBackgroundPosition_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCss_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionStyleBackgroundSize_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionSelection_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionContentGroup_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionSvgPath_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionVideoFrame_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultRefAnyString_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultU8VecString_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultVoidString_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultStringString_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionListViewOnRowClick_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionListViewOnColumnClick_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionListViewOnLazyLoadScroll_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionColorInputOnValueChange_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionButtonOnClick_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTabOnClick_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionFileInputOnPathChange_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCheckBoxOnToggle_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDropDownOnChoiceChange_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTextInputOnTextInput_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTextInputOnVirtualKeyDown_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTextInputOnFocusLost_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionNumberInputOnFocusLost_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionNumberInputOnValueChange_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionRawImage_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCoreMenuCallback_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionWaylandTheme_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionWindowIcon_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCoreImageCallback_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionSelectAllResult_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDeleteResult_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionClipboardContent_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionFilePath_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionPendingTextEdit_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionMimeTypeHint_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionAccessibilityAction_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDirEntry_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionNamedFont_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionStyleFilter_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionHttpHeader_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCssRuleBlock_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCoreCallbackData_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionVertexAttribute_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDebugMessage_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionListViewRow_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionIdOrClass_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionStyleFontFamily_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionStringPair_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionMimeTypeData_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionThemeCondition_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionComponentLibrary_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionComponentDataModel_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionComponentEnumModel_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionComponentEnumVariant_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionRibbonOnTabClick_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTreeViewOnNodeClick_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionRibbonTab_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTreeViewNode_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionRoute_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionRouteMatch_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionFileTypeList_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionKeyringResult_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDbValue_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionOnVideoFrame_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionMapViewportChanged_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionMapPinTap_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionOnAudioFrame_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionLoadedFont_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultRawImageDecodeImageError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultEmptyStructFileError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultu64FileError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultU8VecFileError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultFileMetadataFileError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultStringFileError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultDirEntryVecFileError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultFilePathFileError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultUrlUrlParseError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionTimer_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDragState_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionJson_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionFmtArg_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionMonitor_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionStyleBackgroundContent_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionStyledTextRun_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDynamicSelector_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionAttributeType_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionComponentDefaultValue_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionComponentFieldOverride_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultHttpResponseHttpError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultU8VecHttpError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultJsonJsonParseError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionExternalResource_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionJsonKeyValue_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionXmlNodeChild_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCssPathSelector_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionNodeData_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCssMockEnvironment_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionComponentCallbackArg_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionDom_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionMenuItem_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionComponentDataField_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCssProperty_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionUndoableOperation_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionRibbonSection_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCssPropertyWithConditions_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultSvgSvgParseError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultParsedSvgSvgParseError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzOptionCssDeclaration_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultStyledDomRenderDomError_toDbgString(&inner_));
    return _p;
}

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 {
    String::Proxy _p(AzResultStringCompileError_toDbgString(&inner_));
    return _p;
}

} // namespace azul

#endif // AZUL_CPP03_HPP