operator==( var1 : inkWidgetRef, var2 : inkWidgetRef ) : Bool
{
	return inkWidgetRef.Equals( var1, var2 );
}

import struct inkWidgetRef
{
	public import static function Get( self : inkWidgetRef ) : weak< inkWidget >;
	public import static function IsValid( self : inkWidgetRef ) : Bool;
	public import static function Equals( self : inkWidgetRef, other : inkWidgetRef ) : Bool;
	public import static function GetName( self : inkWidgetRef ) : CName;
	public import static function SetName( self : inkWidgetRef, widgetName : CName );
	public import static function GetController( self : inkWidgetRef ) : weak< inkLogicController >;
	public import static function GetControllerByType( self : inkWidgetRef, controllerType : CName ) : weak< inkLogicController >;
	public import static function GetControllers( self : inkWidgetRef ) : array< weak< inkLogicController > >;
	public import static function GetControllersByType( self : inkWidgetRef, controllerType : CName ) : array< weak< inkLogicController > >;
	public import static function GetNumControllers( self : inkWidgetRef ) : Int32;
	public import static function GetNumControllersOfType( self : inkWidgetRef, controllerType : CName ) : Int32;
	public import static function GetStylePath( self : inkWidgetRef ) : ResRef;
	public import static function SetStyle( self : inkWidgetRef, styleResPath : ResRef );
	public import static function GetState( self : inkWidgetRef ) : CName;
	public import static function SetState( self : inkWidgetRef, state : CName );

	public constexpr static function DefaultState( self : inkWidgetRef ) : CName
	{
		return 'Default';
	}

	public import static function IsVisible( self : inkWidgetRef ) : Bool;
	public import static function SetVisible( self : inkWidgetRef, visible : Bool );
	public import static function IsInteractive( self : inkWidgetRef ) : Bool;
	public import static function SetInteractive( self : inkWidgetRef, value : Bool );
	public import static function SetLayout( self : inkWidgetRef, layout : inkWidgetLayout );
	public import static function GetMargin( self : inkWidgetRef ) : inkMargin;
	public import static function SetMargin( self : inkWidgetRef, margin : inkMargin );

	public static function SetMargin( self : inkWidgetRef, left : Float, top : Float, right : Float, bottom : Float )
	{
		inkWidgetRef.SetMargin( self, inkMargin( left, top, right, bottom ) );
	}

	public static function UpdateMargin( self : inkWidgetRef, left : Float, top : Float, right : Float, bottom : Float )
	{
		var currentMargin : inkMargin;
		currentMargin = inkWidgetRef.GetMargin( self );
		currentMargin.left += left;
		currentMargin.top += top;
		currentMargin.right += right;
		currentMargin.bottom += bottom;
		inkWidgetRef.SetMargin( self, currentMargin );
	}

	public import static function GetPadding( self : inkWidgetRef ) : inkMargin;
	public import static function SetPadding( self : inkWidgetRef, padding : inkMargin );

	public static function SetPadding( self : inkWidgetRef, left : Float, top : Float, right : Float, bottom : Float )
	{
		inkWidgetRef.SetPadding( self, inkMargin( left, top, right, bottom ) );
	}

	public import static function GetHAlign( self : inkWidgetRef ) : inkEHorizontalAlign;
	public import static function SetHAlign( self : inkWidgetRef, hAlign : inkEHorizontalAlign );
	public import static function GetVAlign( self : inkWidgetRef ) : inkEVerticalAlign;
	public import static function SetVAlign( self : inkWidgetRef, vAlign : inkEVerticalAlign );
	public import static function GetAnchor( self : inkWidgetRef ) : inkEAnchor;
	public import static function SetAnchor( self : inkWidgetRef, anchor : inkEAnchor );
	public import static function GetAnchorPoint( self : inkWidgetRef ) : Vector2;
	public import static function SetAnchorPoint( self : inkWidgetRef, anchorPoint : Vector2 );

	public static function SetAnchorPoint( self : inkWidgetRef, x : Float, y : Float )
	{
		inkWidgetRef.SetAnchorPoint( self, Vector2( x, y ) );
	}

	public import static function GetSizeRule( self : inkWidgetRef ) : inkESizeRule;
	public import static function SetSizeRule( self : inkWidgetRef, sizeRule : inkESizeRule );
	public import static function GetSizeCoefficient( self : inkWidgetRef ) : Float;
	public import static function SetSizeCoefficient( self : inkWidgetRef, sizeCoefficient : Float );
	public import static function GetFitToContent( self : inkWidgetRef ) : Bool;
	public import static function SetFitToContent( self : inkWidgetRef, fitToContent : Bool );
	public import static function GetSize( self : inkWidgetRef ) : Vector2;
	public import static function SetSize( self : inkWidgetRef, size : Vector2 );

	public static function SetSize( self : inkWidgetRef, width : Float, height : Float )
	{
		inkWidgetRef.SetSize( self, Vector2( width, height ) );
	}

	public static function GetWidth( self : inkWidgetRef ) : Float
	{
		var size : Vector2;
		size = inkWidgetRef.GetSize( self );
		return size.X;
	}

	public static function GetHeight( self : inkWidgetRef ) : Float
	{
		var size : Vector2;
		size = inkWidgetRef.GetSize( self );
		return size.Y;
	}

	public static function SetWidth( self : inkWidgetRef, width : Float )
	{
		inkWidgetRef.SetSize( self, width, inkWidgetRef.GetHeight( self ) );
	}

	public static function SetHeight( self : inkWidgetRef, height : Float )
	{
		inkWidgetRef.SetSize( self, inkWidgetRef.GetWidth( self ), height );
	}

	public import static function GetDesiredSize( self : inkWidgetRef ) : Vector2;

	public static function GetDesiredWidth( self : inkWidgetRef ) : Float
	{
		var size : Vector2;
		size = inkWidgetRef.GetDesiredSize( self );
		return size.X;
	}

	public static function GetDesiredHeight( self : inkWidgetRef ) : Float
	{
		var size : Vector2;
		size = inkWidgetRef.GetDesiredSize( self );
		return size.Y;
	}

	public import static function GetTintColor( self : inkWidgetRef ) : HDRColor;
	public import static function SetTintColor( self : inkWidgetRef, color : HDRColor );

	public static function SetTintColor( self : inkWidgetRef, color : Color )
	{
		inkWidgetRef.SetTintColor( self, Color.ToHDRColorDirect( color ) );
	}

	public static function SetTintColor( self : inkWidgetRef, r : Uint8, g : Uint8, b : Uint8, a : Uint8 )
	{
		inkWidgetRef.SetTintColor( self, Color( r, g, b, a ) );
	}

	public import static function GetOpacity( self : inkWidgetRef ) : Float;
	public import static function SetOpacity( self : inkWidgetRef, opacity : Float );
	public import static function GetRenderTransformPivot( self : inkWidgetRef ) : Vector2;
	public import static function SetRenderTransformPivot( self : inkWidgetRef, pivot : Vector2 );

	public static function SetRenderTransformPivot( self : inkWidgetRef, x : Float, y : Float )
	{
		inkWidgetRef.SetRenderTransformPivot( self, Vector2( x, y ) );
	}

	public import static function SetScale( self : inkWidgetRef, scale : Vector2 );
	public import static function GetScale( self : inkWidgetRef ) : Vector2;
	public import static function SetShear( self : inkWidgetRef, shear : Vector2 );
	public import static function GetShear( self : inkWidgetRef ) : Vector2;
	public import static function SetRotation( self : inkWidgetRef, angleInDegrees : Float );
	public import static function GetRotation( self : inkWidgetRef ) : Float;
	public import static function SetTranslation( self : inkWidgetRef, translationVector : Vector2 );
	public import static function GetTranslation( self : inkWidgetRef ) : Vector2;
	public import static function ChangeTranslation( self : inkWidgetRef, translationVector : Vector2 );

	public static function SetTranslation( self : inkWidgetRef, x : Float, y : Float )
	{
		inkWidgetRef.SetTranslation( self, Vector2( x, y ) );
	}

	public import static function PlayAnimation( self : inkWidgetRef, animationDefinition : inkAnimDef ) : inkAnimProxy;
	public import static function PlayAnimationWithOptions( self : inkWidgetRef, animationDefinition : inkAnimDef, playbackOptions : inkAnimOptions ) : inkAnimProxy;
	public import static function StopAllAnimations( self : inkWidgetRef );
	public import static function CallCustomCallback( self : inkWidgetRef, eventName : CName );
	public import static function RegisterToCallback( self : inkWidgetRef, eventName : CName, object : IScriptable, functionName : CName );
	public import static function UnregisterFromCallback( self : inkWidgetRef, eventName : CName, object : IScriptable, functionName : CName );
	public import static function HasUserDataObject( self : inkWidgetRef, userDataTypeName : CName ) : Bool;
	public import static function GetUserDataObjectCount( self : inkWidgetRef, userDataTypeName : CName ) : Uint32;
	public import static function GetUserData( self : inkWidgetRef, userDataTypeName : CName ) : inkUserData;
	public import static function GetUserDataArray( self : inkWidgetRef, userDataTypeName : CName ) : array< inkUserData >;
	public import static function GatherUserData( self : inkWidgetRef, userDataTypeName : CName, userDataCollection : array< inkUserData > );
	public import static function Reparent( self : inkWidgetRef, newParent : weak< inkCompoundWidget >, optional index : Int32 );
}

import struct inkLeafRef extends inkWidgetRef
{
}

import struct inkCompoundRef extends inkWidgetRef
{
	public import static function GetNumChildren( self : inkCompoundRef ) : Int32;
	public import static function AddChild( self : inkCompoundRef, widgetTypeName : CName ) : weak< inkWidget >;
	public import static function AddChildWidget( self : inkCompoundRef, widget : weak< inkWidget > );
	public import static function GetWidgetByPath( self : inkCompoundRef, path : inkWidgetPath ) : weak< inkWidget >;
	public import static function GetWidgetByIndex( self : inkCompoundRef, index : Int32 ) : weak< inkWidget >;

	public static function GetWidget( self : inkCompoundRef, path : inkWidgetPath ) : weak< inkWidget >
	{
		return inkCompoundRef.GetWidgetByPath( self, path );
	}

	public static function GetWidget( self : inkCompoundRef, index : Int32 ) : weak< inkWidget >
	{
		return inkCompoundRef.GetWidgetByIndex( self, index );
	}

	public import static function GetWidgetByPathName( self : inkCompoundRef, widgetNamePath : CName ) : weak< inkWidget >;

	public static function GetWidget( self : inkCompoundRef, path : CName ) : weak< inkWidget >
	{
		return inkCompoundRef.GetWidgetByPathName( self, path );
	}

	public import static function RemoveChild( self : inkCompoundRef, childWidget : weak< inkWidget > );
	public import static function RemoveChildByIndex( self : inkCompoundRef, index : Int32 );
	public import static function RemoveChildByName( self : inkCompoundRef, widgetName : CName );
	public import static function RemoveAllChildren( self : inkCompoundRef );
	public import static function ReorderChild( self : inkCompoundRef, childWidget : weak< inkWidget >, newIndex : Int32 );
	public import static function GetChildOrder( self : inkBasePanelRef ) : inkEChildOrder;
	public import static function SetChildOrder( self : inkBasePanelRef, newOrder : inkEChildOrder );
	public import static function GetChildPosition( self : inkCompoundRef, childWidget : weak< inkWidget > ) : Vector2;
	public import static function GetChildSize( self : inkCompoundRef, childWidget : weak< inkWidget > ) : Vector2;
}

import struct inkCanvasRef extends inkCompoundRef
{
}

import struct inkBasePanelRef extends inkCompoundRef
{
}

import struct inkHorizontalPanelRef extends inkBasePanelRef
{
}

import struct inkVerticalPanelRef extends inkBasePanelRef
{
}

import struct inkFlexRef extends inkCompoundRef
{
}

import struct inkUniformGridRef extends inkCompoundRef
{
	public import static function SetWrappingWidgetCount( self : inkUniformGridRef, count : Uint32 );
	public import static function GetWrappingWidgetCount( self : inkUniformGridRef ) : Uint32;
	public import static function SetOrientation( self : inkUniformGridRef, orientation : inkEOrientation );
	public import static function GetOrientation( self : inkUniformGridRef ) : inkEOrientation;
}

import struct inkGridRef extends inkCompoundRef
{
}

import struct inkVirtualCompoundRef extends inkCompoundRef
{
}

import struct inkScrollAreaRef extends inkCompoundRef
{
	public import static function ScrollVertical( self : inkScrollAreaRef, value : Float );
	public import static function ScrollHorizontal( self : inkScrollAreaRef, value : Float );
	public import static function GetVerticalScrollPosition( self : inkScrollAreaRef ) : Float;
	public import static function GetHorizontalScrollPosition( self : inkScrollAreaRef ) : Float;
	public import static function GetRealVerticalScrollPosition( self : inkScrollAreaRef ) : Float;
	public import static function GetRealHorizontalScrollPosition( self : inkScrollAreaRef ) : Float;
	public import static function GetContentSize( self : inkScrollAreaRef ) : Vector2;
	public import static function GetViewportSize( self : inkScrollAreaRef ) : Vector2;
	public import static function GetUseInternalMask( self : inkScrollAreaRef ) : Bool;
	public import static function SetUseInternalMask( self : inkScrollAreaRef, value : Bool );
}

import struct inkCacheRef extends inkCompoundRef
{
}

import struct inkTextRef extends inkLeafRef
{
	public import static function GetText( self : inkTextRef ) : String;
	public import static function SetText( self : inkTextRef, displayText : String, optional textParams : inkTextParams );
	public import static function SetTextDirect( self : inkTextRef, displayText : String );
	public import static function SetLocalizedText( self : inkTextRef, locKey : CName, optional textParams : inkTextParams );
	public import static function SetLocalizedTextString( self : inkTextRef, locKey : String, optional textParams : inkTextParams );

	public static function SetLocalizedTextScript( self : inkTextRef, const locKey : ref< String >, optional textParams : inkTextParams )
	{
		if( IsStringNumber( locKey ) )
		{
			inkTextRef.SetText( self, locKey, textParams );
		}
		else if( !( IsStringValid( locKey ) ) )
		{
			inkTextRef.SetText( self, "", textParams );
		}
		else
		{
			inkTextRef.SetLocalizedTextString( self, locKey, textParams );
		}
	}

	public static function SetLocalizedTextScript( self : inkTextRef, locKey : CName, optional textParams : inkTextParams )
	{
		if( !( IsNameValid( locKey ) ) )
		{
			inkTextRef.SetText( self, "", textParams );
		}
		else
		{
			inkTextRef.SetLocalizedText( self, locKey, textParams );
		}
	}

	public import static function GetTextParameters( self : inkTextRef ) : inkTextParams;
	public import static function SetTextParameters( self : inkTextRef, textParams : inkTextParams );
	public import static function GetLocalizationKey( self : inkTextRef ) : CName;
	public import static function SetLocalizationKey( self : inkTextRef, displayText : CName );
	public import static function SetLocalizationKeyString( self : inkTextRef, displayText : String );
	public import static function UpdateLanguageResources( self : inkTextRef, optional applyFontModifiers : Bool );
	public import static function SetTextFromParts( self : inkTextRef, textpart1 : String, optional textpart2 : String, optional textpart3 : String );
	public import static function GetVerticalAlignment( self : inkTextRef ) : textVerticalAlignment;
	public import static function SetVerticalAlignment( self : inkTextRef, verticalAlignment : textVerticalAlignment );

	public static function GetVerticalAlignmentEnumValue( self : inkTextRef, nameValue : CName ) : textVerticalAlignment
	{
		var returnValue : textVerticalAlignment;
		if( nameValue == 'Top' )
		{
			returnValue = textVerticalAlignment.Top;
		}
		else if( nameValue == 'Bottom' )
		{
			returnValue = textVerticalAlignment.Bottom;
		}
		else if( nameValue == 'Center' )
		{
			returnValue = textVerticalAlignment.Center;
		}
		return returnValue;
	}

	public import static function GetHorizontalAlignment( self : inkTextRef ) : textHorizontalAlignment;
	public import static function SetHorizontalAlignment( self : inkTextRef, horizontalAlignment : textHorizontalAlignment );

	public static function GetHorizontalAlignmentEnumValue( self : inkTextRef, nameValue : CName ) : textHorizontalAlignment
	{
		var returnValue : textHorizontalAlignment;
		if( nameValue == 'Left' )
		{
			returnValue = textHorizontalAlignment.Left;
		}
		else if( nameValue == 'Right' )
		{
			returnValue = textHorizontalAlignment.Right;
		}
		else if( nameValue == 'Center' )
		{
			returnValue = textHorizontalAlignment.Center;
		}
		return returnValue;
	}

	public import static function SetFontFamily( self : inkTextRef, fontFamilyPath : String, optional fontStyle : CName );
	public import static function GetFontStyle( self : inkTextRef ) : CName;
	public import static function SetFontStyle( self : inkTextRef, fontStyle : CName );
	public import static function GetFontSize( self : inkTextRef ) : Int32;
	public import static function SetFontSize( self : inkTextRef, textSize : Int32 );
	public import static function GetLetterCase( self : inkTextRef ) : textLetterCase;
	public import static function SetLetterCase( self : inkTextRef, letterCase : textLetterCase );
	public import static function EnableAutoScroll( self : inkTextRef, enableState : Bool );
	public import static function SetDateTimeByTimestamp( self : inkTextRef, timestamp : Uint64 );
	public import static function GetScrollTextSpeed( self : inkTextRef ) : Float;
	public import static function SetScrollTextSpeed( self : inkTextRef, scrollTextSpeed : Float );
	public import static function SetWrappingAtPosition( self : inkTextRef, position : Float );
}

import struct inkTextInputRef extends inkLeafRef
{
}

import struct inkImageRef extends inkLeafRef
{
	public import static function SetBrushTileType( self : inkImageRef, tileType : inkBrushTileType );
	public import static function SetBrushMirrorType( self : inkImageRef, mirrorType : inkBrushMirrorType );
	public import static function SetTexturePart( self : inkImageRef, texturePart : CName ) : Bool;
	public import static function IsTexturePartExist( self : inkImageRef, texturePart : CName ) : Bool;
	public import static function GetTexturePart( self : inkImageRef ) : CName;
	public import static function SetAtlasResource( self : inkImageRef, atlasResourcePath : ResRef );
	public import static function SetActiveTextureType( self : inkImageRef, activeTextureType : inkTextureType );
	public import static function GetActiveTextureType( self : inkImageRef ) : inkTextureType;
	public import static function RequestSetImage( self : inkImageRef, iconRefernce : inkIconReference, optional callbackTarget : weak< IScriptable >, optional callbackName : CName );
}

import struct inkVideoRef extends inkLeafRef
{
	public import static function SetVideoPath( self : inkVideoRef, videoPath : ResRef );
	public import static function ForceVideoFrameRate( self : inkVideoRef, forceVideoFrameRate : Bool );
	public import static function Play( self : inkVideoRef );
	public import static function Stop( self : inkVideoRef );
	public import static function Pause( self : inkVideoRef );
	public import static function Resume( self : inkVideoRef );
	public import static function SkipFrames( self : inkVideoRef, numberOfFrames : Int32 );
	public import static function FastForwardTo( self : inkVideoRef, numberOfFrames : Uint32 );
	public import static function RewindTo( self : inkVideoRef, numberOfFrames : Uint32 );
	public import static function JumpToFrame( self : inkVideoRef, frameNumber : Uint32 );
	public import static function JumpToTime( self : inkVideoRef, timeInSeconds : Float );
	public import static function SetLoop( self : inkVideoRef, isLooped : Bool );
	public import static function GetVideoWidgetSummary( self : inkVideoRef ) : VideoWidgetSummary;
	public import static function PreloadNextVideo( self : inkVideoRef, videoPath : String );
	public import static function IsPlayingVideo( self : inkVideoRef ) : Bool;
	public import static function IsPaused( self : inkVideoRef ) : Bool;
	public import static function IsParallaxEnabled( self : inkVideoRef ) : Bool;
}

import struct inkBorderRef extends inkLeafRef
{
	public import static function SetThickness( self : inkBorderRef, thickness : Float );
}

import struct inkRectangleRef extends inkLeafRef
{
}

import struct inkCircleRef extends inkLeafRef
{
}

import struct inkShapeRef extends inkLeafRef
{
	public import static function ChangeShape( self : inkShapeRef, shapeName : CName );
}

import struct inkMaskRef extends inkLeafRef
{
	public import static function SetTexturePart( self : inkMaskRef, texturePart : CName ) : Bool;
	public import static function IsTexturePartExist( self : inkMaskRef, texturePart : CName ) : Bool;
	public import static function GetTexturePart( self : inkMaskRef ) : CName;
}

import struct inkRichTextBoxRef extends inkTextRef
{
}

