#ifndef _RIVE_CORE_REGISTRY_HPP_
#define _RIVE_CORE_REGISTRY_HPP_
#include "rive/animation/animation.hpp"
#include "rive/animation/animation_state.hpp"
#include "rive/animation/any_state.hpp"
#include "rive/animation/blend_animation.hpp"
#include "rive/animation/blend_animation_1d.hpp"
#include "rive/animation/blend_animation_direct.hpp"
#include "rive/animation/blend_state.hpp"
#include "rive/animation/blend_state_1d.hpp"
#include "rive/animation/blend_state_direct.hpp"
#include "rive/animation/blend_state_transition.hpp"
#include "rive/animation/cubic_interpolator.hpp"
#include "rive/animation/entry_state.hpp"
#include "rive/animation/exit_state.hpp"
#include "rive/animation/keyed_object.hpp"
#include "rive/animation/keyed_property.hpp"
#include "rive/animation/keyframe.hpp"
#include "rive/animation/keyframe_bool.hpp"
#include "rive/animation/keyframe_color.hpp"
#include "rive/animation/keyframe_double.hpp"
#include "rive/animation/keyframe_id.hpp"
#include "rive/animation/layer_state.hpp"
#include "rive/animation/linear_animation.hpp"
#include "rive/animation/nested_linear_animation.hpp"
#include "rive/animation/nested_remap_animation.hpp"
#include "rive/animation/nested_simple_animation.hpp"
#include "rive/animation/nested_state_machine.hpp"
#include "rive/animation/state_machine.hpp"
#include "rive/animation/state_machine_bool.hpp"
#include "rive/animation/state_machine_component.hpp"
#include "rive/animation/state_machine_input.hpp"
#include "rive/animation/state_machine_layer.hpp"
#include "rive/animation/state_machine_layer_component.hpp"
#include "rive/animation/state_machine_number.hpp"
#include "rive/animation/state_machine_trigger.hpp"
#include "rive/animation/state_transition.hpp"
#include "rive/animation/transition_bool_condition.hpp"
#include "rive/animation/transition_condition.hpp"
#include "rive/animation/transition_number_condition.hpp"
#include "rive/animation/transition_trigger_condition.hpp"
#include "rive/animation/transition_value_condition.hpp"
#include "rive/artboard.hpp"
#include "rive/assets/asset.hpp"
#include "rive/assets/drawable_asset.hpp"
#include "rive/assets/file_asset.hpp"
#include "rive/assets/file_asset_contents.hpp"
#include "rive/assets/folder.hpp"
#include "rive/assets/image_asset.hpp"
#include "rive/backboard.hpp"
#include "rive/bones/bone.hpp"
#include "rive/bones/cubic_weight.hpp"
#include "rive/bones/root_bone.hpp"
#include "rive/bones/skeletal_component.hpp"
#include "rive/bones/skin.hpp"
#include "rive/bones/tendon.hpp"
#include "rive/bones/weight.hpp"
#include "rive/component.hpp"
#include "rive/constraints/constraint.hpp"
#include "rive/constraints/distance_constraint.hpp"
#include "rive/constraints/ik_constraint.hpp"
#include "rive/constraints/rotation_constraint.hpp"
#include "rive/constraints/scale_constraint.hpp"
#include "rive/constraints/targeted_constraint.hpp"
#include "rive/constraints/transform_component_constraint.hpp"
#include "rive/constraints/transform_component_constraint_y.hpp"
#include "rive/constraints/transform_constraint.hpp"
#include "rive/constraints/transform_space_constraint.hpp"
#include "rive/constraints/translation_constraint.hpp"
#include "rive/container_component.hpp"
#include "rive/draw_rules.hpp"
#include "rive/draw_target.hpp"
#include "rive/drawable.hpp"
#include "rive/nested_animation.hpp"
#include "rive/nested_artboard.hpp"
#include "rive/node.hpp"
#include "rive/shapes/clipping_shape.hpp"
#include "rive/shapes/cubic_asymmetric_vertex.hpp"
#include "rive/shapes/cubic_detached_vertex.hpp"
#include "rive/shapes/cubic_mirrored_vertex.hpp"
#include "rive/shapes/cubic_vertex.hpp"
#include "rive/shapes/ellipse.hpp"
#include "rive/shapes/image.hpp"
#include "rive/shapes/paint/fill.hpp"
#include "rive/shapes/paint/gradient_stop.hpp"
#include "rive/shapes/paint/linear_gradient.hpp"
#include "rive/shapes/paint/radial_gradient.hpp"
#include "rive/shapes/paint/shape_paint.hpp"
#include "rive/shapes/paint/solid_color.hpp"
#include "rive/shapes/paint/stroke.hpp"
#include "rive/shapes/paint/trim_path.hpp"
#include "rive/shapes/parametric_path.hpp"
#include "rive/shapes/path.hpp"
#include "rive/shapes/path_vertex.hpp"
#include "rive/shapes/points_path.hpp"
#include "rive/shapes/polygon.hpp"
#include "rive/shapes/rectangle.hpp"
#include "rive/shapes/shape.hpp"
#include "rive/shapes/star.hpp"
#include "rive/shapes/straight_vertex.hpp"
#include "rive/shapes/triangle.hpp"
#include "rive/transform_component.hpp"
#include "rive/world_transform_component.hpp"
namespace rive
{
	class CoreRegistry
	{
	public:
		static Core* makeCoreInstance(int typeKey)
		{
			switch (typeKey)
			{
				case DrawTargetBase::typeKey:
					return new DrawTarget();
				case DistanceConstraintBase::typeKey:
					return new DistanceConstraint();
				case IKConstraintBase::typeKey:
					return new IKConstraint();
				case TranslationConstraintBase::typeKey:
					return new TranslationConstraint();
				case TransformConstraintBase::typeKey:
					return new TransformConstraint();
				case ScaleConstraintBase::typeKey:
					return new ScaleConstraint();
				case RotationConstraintBase::typeKey:
					return new RotationConstraint();
				case NodeBase::typeKey:
					return new Node();
				case NestedArtboardBase::typeKey:
					return new NestedArtboard();
				case NestedSimpleAnimationBase::typeKey:
					return new NestedSimpleAnimation();
				case AnimationStateBase::typeKey:
					return new AnimationState();
				case KeyedObjectBase::typeKey:
					return new KeyedObject();
				case BlendAnimationDirectBase::typeKey:
					return new BlendAnimationDirect();
				case StateMachineNumberBase::typeKey:
					return new StateMachineNumber();
				case TransitionTriggerConditionBase::typeKey:
					return new TransitionTriggerCondition();
				case KeyedPropertyBase::typeKey:
					return new KeyedProperty();
				case KeyFrameIdBase::typeKey:
					return new KeyFrameId();
				case KeyFrameBoolBase::typeKey:
					return new KeyFrameBool();
				case TransitionNumberConditionBase::typeKey:
					return new TransitionNumberCondition();
				case AnyStateBase::typeKey:
					return new AnyState();
				case StateMachineLayerBase::typeKey:
					return new StateMachineLayer();
				case AnimationBase::typeKey:
					return new Animation();
				case CubicInterpolatorBase::typeKey:
					return new CubicInterpolator();
				case StateTransitionBase::typeKey:
					return new StateTransition();
				case KeyFrameDoubleBase::typeKey:
					return new KeyFrameDouble();
				case KeyFrameColorBase::typeKey:
					return new KeyFrameColor();
				case StateMachineBase::typeKey:
					return new StateMachine();
				case EntryStateBase::typeKey:
					return new EntryState();
				case LinearAnimationBase::typeKey:
					return new LinearAnimation();
				case StateMachineTriggerBase::typeKey:
					return new StateMachineTrigger();
				case BlendStateDirectBase::typeKey:
					return new BlendStateDirect();
				case NestedStateMachineBase::typeKey:
					return new NestedStateMachine();
				case ExitStateBase::typeKey:
					return new ExitState();
				case BlendState1DBase::typeKey:
					return new BlendState1D();
				case NestedRemapAnimationBase::typeKey:
					return new NestedRemapAnimation();
				case TransitionBoolConditionBase::typeKey:
					return new TransitionBoolCondition();
				case BlendStateTransitionBase::typeKey:
					return new BlendStateTransition();
				case StateMachineBoolBase::typeKey:
					return new StateMachineBool();
				case BlendAnimation1DBase::typeKey:
					return new BlendAnimation1D();
				case LinearGradientBase::typeKey:
					return new LinearGradient();
				case RadialGradientBase::typeKey:
					return new RadialGradient();
				case StrokeBase::typeKey:
					return new Stroke();
				case SolidColorBase::typeKey:
					return new SolidColor();
				case GradientStopBase::typeKey:
					return new GradientStop();
				case TrimPathBase::typeKey:
					return new TrimPath();
				case FillBase::typeKey:
					return new Fill();
				case ShapeBase::typeKey:
					return new Shape();
				case StraightVertexBase::typeKey:
					return new StraightVertex();
				case CubicAsymmetricVertexBase::typeKey:
					return new CubicAsymmetricVertex();
				case PointsPathBase::typeKey:
					return new PointsPath();
				case RectangleBase::typeKey:
					return new Rectangle();
				case CubicMirroredVertexBase::typeKey:
					return new CubicMirroredVertex();
				case TriangleBase::typeKey:
					return new Triangle();
				case EllipseBase::typeKey:
					return new Ellipse();
				case ClippingShapeBase::typeKey:
					return new ClippingShape();
				case PolygonBase::typeKey:
					return new Polygon();
				case StarBase::typeKey:
					return new Star();
				case ImageBase::typeKey:
					return new Image();
				case CubicDetachedVertexBase::typeKey:
					return new CubicDetachedVertex();
				case DrawRulesBase::typeKey:
					return new DrawRules();
				case ArtboardBase::typeKey:
					return new Artboard();
				case BackboardBase::typeKey:
					return new Backboard();
				case WeightBase::typeKey:
					return new Weight();
				case BoneBase::typeKey:
					return new Bone();
				case RootBoneBase::typeKey:
					return new RootBone();
				case SkinBase::typeKey:
					return new Skin();
				case TendonBase::typeKey:
					return new Tendon();
				case CubicWeightBase::typeKey:
					return new CubicWeight();
				case FolderBase::typeKey:
					return new Folder();
				case ImageAssetBase::typeKey:
					return new ImageAsset();
				case FileAssetContentsBase::typeKey:
					return new FileAssetContents();
			}
			return nullptr;
		}
		static void setString(Core* object, int propertyKey, std::string value)
		{
			switch (propertyKey)
			{
				case ComponentBase::namePropertyKey:
					object->as<ComponentBase>()->name(value);
					break;
				case StateMachineComponentBase::namePropertyKey:
					object->as<StateMachineComponentBase>()->name(value);
					break;
				case AnimationBase::namePropertyKey:
					object->as<AnimationBase>()->name(value);
					break;
				case AssetBase::namePropertyKey:
					object->as<AssetBase>()->name(value);
					break;
			}
		}
		static void setUint(Core* object, int propertyKey, int value)
		{
			switch (propertyKey)
			{
				case ComponentBase::parentIdPropertyKey:
					object->as<ComponentBase>()->parentId(value);
					break;
				case DrawTargetBase::drawableIdPropertyKey:
					object->as<DrawTargetBase>()->drawableId(value);
					break;
				case DrawTargetBase::placementValuePropertyKey:
					object->as<DrawTargetBase>()->placementValue(value);
					break;
				case TargetedConstraintBase::targetIdPropertyKey:
					object->as<TargetedConstraintBase>()->targetId(value);
					break;
				case DistanceConstraintBase::modeValuePropertyKey:
					object->as<DistanceConstraintBase>()->modeValue(value);
					break;
				case TransformSpaceConstraintBase::sourceSpaceValuePropertyKey:
					object->as<TransformSpaceConstraintBase>()
					    ->sourceSpaceValue(value);
					break;
				case TransformSpaceConstraintBase::destSpaceValuePropertyKey:
					object->as<TransformSpaceConstraintBase>()->destSpaceValue(
					    value);
					break;
				case TransformComponentConstraintBase::
				    minMaxSpaceValuePropertyKey:
					object->as<TransformComponentConstraintBase>()
					    ->minMaxSpaceValue(value);
					break;
				case IKConstraintBase::parentBoneCountPropertyKey:
					object->as<IKConstraintBase>()->parentBoneCount(value);
					break;
				case DrawableBase::blendModeValuePropertyKey:
					object->as<DrawableBase>()->blendModeValue(value);
					break;
				case DrawableBase::drawableFlagsPropertyKey:
					object->as<DrawableBase>()->drawableFlags(value);
					break;
				case NestedArtboardBase::artboardIdPropertyKey:
					object->as<NestedArtboardBase>()->artboardId(value);
					break;
				case NestedAnimationBase::animationIdPropertyKey:
					object->as<NestedAnimationBase>()->animationId(value);
					break;
				case AnimationStateBase::animationIdPropertyKey:
					object->as<AnimationStateBase>()->animationId(value);
					break;
				case KeyedObjectBase::objectIdPropertyKey:
					object->as<KeyedObjectBase>()->objectId(value);
					break;
				case BlendAnimationBase::animationIdPropertyKey:
					object->as<BlendAnimationBase>()->animationId(value);
					break;
				case BlendAnimationDirectBase::inputIdPropertyKey:
					object->as<BlendAnimationDirectBase>()->inputId(value);
					break;
				case TransitionConditionBase::inputIdPropertyKey:
					object->as<TransitionConditionBase>()->inputId(value);
					break;
				case KeyedPropertyBase::propertyKeyPropertyKey:
					object->as<KeyedPropertyBase>()->propertyKey(value);
					break;
				case KeyFrameBase::framePropertyKey:
					object->as<KeyFrameBase>()->frame(value);
					break;
				case KeyFrameBase::interpolationTypePropertyKey:
					object->as<KeyFrameBase>()->interpolationType(value);
					break;
				case KeyFrameBase::interpolatorIdPropertyKey:
					object->as<KeyFrameBase>()->interpolatorId(value);
					break;
				case KeyFrameIdBase::valuePropertyKey:
					object->as<KeyFrameIdBase>()->value(value);
					break;
				case TransitionValueConditionBase::opValuePropertyKey:
					object->as<TransitionValueConditionBase>()->opValue(value);
					break;
				case StateTransitionBase::stateToIdPropertyKey:
					object->as<StateTransitionBase>()->stateToId(value);
					break;
				case StateTransitionBase::flagsPropertyKey:
					object->as<StateTransitionBase>()->flags(value);
					break;
				case StateTransitionBase::durationPropertyKey:
					object->as<StateTransitionBase>()->duration(value);
					break;
				case StateTransitionBase::exitTimePropertyKey:
					object->as<StateTransitionBase>()->exitTime(value);
					break;
				case LinearAnimationBase::fpsPropertyKey:
					object->as<LinearAnimationBase>()->fps(value);
					break;
				case LinearAnimationBase::durationPropertyKey:
					object->as<LinearAnimationBase>()->duration(value);
					break;
				case LinearAnimationBase::loopValuePropertyKey:
					object->as<LinearAnimationBase>()->loopValue(value);
					break;
				case LinearAnimationBase::workStartPropertyKey:
					object->as<LinearAnimationBase>()->workStart(value);
					break;
				case LinearAnimationBase::workEndPropertyKey:
					object->as<LinearAnimationBase>()->workEnd(value);
					break;
				case BlendState1DBase::inputIdPropertyKey:
					object->as<BlendState1DBase>()->inputId(value);
					break;
				case BlendStateTransitionBase::exitBlendAnimationIdPropertyKey:
					object->as<BlendStateTransitionBase>()
					    ->exitBlendAnimationId(value);
					break;
				case StrokeBase::capPropertyKey:
					object->as<StrokeBase>()->cap(value);
					break;
				case StrokeBase::joinPropertyKey:
					object->as<StrokeBase>()->join(value);
					break;
				case TrimPathBase::modeValuePropertyKey:
					object->as<TrimPathBase>()->modeValue(value);
					break;
				case FillBase::fillRulePropertyKey:
					object->as<FillBase>()->fillRule(value);
					break;
				case PathBase::pathFlagsPropertyKey:
					object->as<PathBase>()->pathFlags(value);
					break;
				case ClippingShapeBase::sourceIdPropertyKey:
					object->as<ClippingShapeBase>()->sourceId(value);
					break;
				case ClippingShapeBase::fillRulePropertyKey:
					object->as<ClippingShapeBase>()->fillRule(value);
					break;
				case PolygonBase::pointsPropertyKey:
					object->as<PolygonBase>()->points(value);
					break;
				case ImageBase::assetIdPropertyKey:
					object->as<ImageBase>()->assetId(value);
					break;
				case DrawRulesBase::drawTargetIdPropertyKey:
					object->as<DrawRulesBase>()->drawTargetId(value);
					break;
				case WeightBase::valuesPropertyKey:
					object->as<WeightBase>()->values(value);
					break;
				case WeightBase::indicesPropertyKey:
					object->as<WeightBase>()->indices(value);
					break;
				case TendonBase::boneIdPropertyKey:
					object->as<TendonBase>()->boneId(value);
					break;
				case CubicWeightBase::inValuesPropertyKey:
					object->as<CubicWeightBase>()->inValues(value);
					break;
				case CubicWeightBase::inIndicesPropertyKey:
					object->as<CubicWeightBase>()->inIndices(value);
					break;
				case CubicWeightBase::outValuesPropertyKey:
					object->as<CubicWeightBase>()->outValues(value);
					break;
				case CubicWeightBase::outIndicesPropertyKey:
					object->as<CubicWeightBase>()->outIndices(value);
					break;
				case FileAssetBase::assetIdPropertyKey:
					object->as<FileAssetBase>()->assetId(value);
					break;
			}
		}
		static void setDouble(Core* object, int propertyKey, float value)
		{
			switch (propertyKey)
			{
				case ConstraintBase::strengthPropertyKey:
					object->as<ConstraintBase>()->strength(value);
					break;
				case DistanceConstraintBase::distancePropertyKey:
					object->as<DistanceConstraintBase>()->distance(value);
					break;
				case TransformComponentConstraintBase::copyFactorPropertyKey:
					object->as<TransformComponentConstraintBase>()->copyFactor(
					    value);
					break;
				case TransformComponentConstraintBase::minValuePropertyKey:
					object->as<TransformComponentConstraintBase>()->minValue(
					    value);
					break;
				case TransformComponentConstraintBase::maxValuePropertyKey:
					object->as<TransformComponentConstraintBase>()->maxValue(
					    value);
					break;
				case TransformComponentConstraintYBase::copyFactorYPropertyKey:
					object->as<TransformComponentConstraintYBase>()
					    ->copyFactorY(value);
					break;
				case TransformComponentConstraintYBase::minValueYPropertyKey:
					object->as<TransformComponentConstraintYBase>()->minValueY(
					    value);
					break;
				case TransformComponentConstraintYBase::maxValueYPropertyKey:
					object->as<TransformComponentConstraintYBase>()->maxValueY(
					    value);
					break;
				case WorldTransformComponentBase::opacityPropertyKey:
					object->as<WorldTransformComponentBase>()->opacity(value);
					break;
				case TransformComponentBase::rotationPropertyKey:
					object->as<TransformComponentBase>()->rotation(value);
					break;
				case TransformComponentBase::scaleXPropertyKey:
					object->as<TransformComponentBase>()->scaleX(value);
					break;
				case TransformComponentBase::scaleYPropertyKey:
					object->as<TransformComponentBase>()->scaleY(value);
					break;
				case NodeBase::xPropertyKey:
					object->as<NodeBase>()->x(value);
					break;
				case NodeBase::yPropertyKey:
					object->as<NodeBase>()->y(value);
					break;
				case NestedLinearAnimationBase::mixPropertyKey:
					object->as<NestedLinearAnimationBase>()->mix(value);
					break;
				case NestedSimpleAnimationBase::speedPropertyKey:
					object->as<NestedSimpleAnimationBase>()->speed(value);
					break;
				case StateMachineNumberBase::valuePropertyKey:
					object->as<StateMachineNumberBase>()->value(value);
					break;
				case TransitionNumberConditionBase::valuePropertyKey:
					object->as<TransitionNumberConditionBase>()->value(value);
					break;
				case CubicInterpolatorBase::x1PropertyKey:
					object->as<CubicInterpolatorBase>()->x1(value);
					break;
				case CubicInterpolatorBase::y1PropertyKey:
					object->as<CubicInterpolatorBase>()->y1(value);
					break;
				case CubicInterpolatorBase::x2PropertyKey:
					object->as<CubicInterpolatorBase>()->x2(value);
					break;
				case CubicInterpolatorBase::y2PropertyKey:
					object->as<CubicInterpolatorBase>()->y2(value);
					break;
				case KeyFrameDoubleBase::valuePropertyKey:
					object->as<KeyFrameDoubleBase>()->value(value);
					break;
				case LinearAnimationBase::speedPropertyKey:
					object->as<LinearAnimationBase>()->speed(value);
					break;
				case NestedRemapAnimationBase::timePropertyKey:
					object->as<NestedRemapAnimationBase>()->time(value);
					break;
				case BlendAnimation1DBase::valuePropertyKey:
					object->as<BlendAnimation1DBase>()->value(value);
					break;
				case LinearGradientBase::startXPropertyKey:
					object->as<LinearGradientBase>()->startX(value);
					break;
				case LinearGradientBase::startYPropertyKey:
					object->as<LinearGradientBase>()->startY(value);
					break;
				case LinearGradientBase::endXPropertyKey:
					object->as<LinearGradientBase>()->endX(value);
					break;
				case LinearGradientBase::endYPropertyKey:
					object->as<LinearGradientBase>()->endY(value);
					break;
				case LinearGradientBase::opacityPropertyKey:
					object->as<LinearGradientBase>()->opacity(value);
					break;
				case StrokeBase::thicknessPropertyKey:
					object->as<StrokeBase>()->thickness(value);
					break;
				case GradientStopBase::positionPropertyKey:
					object->as<GradientStopBase>()->position(value);
					break;
				case TrimPathBase::startPropertyKey:
					object->as<TrimPathBase>()->start(value);
					break;
				case TrimPathBase::endPropertyKey:
					object->as<TrimPathBase>()->end(value);
					break;
				case TrimPathBase::offsetPropertyKey:
					object->as<TrimPathBase>()->offset(value);
					break;
				case PathVertexBase::xPropertyKey:
					object->as<PathVertexBase>()->x(value);
					break;
				case PathVertexBase::yPropertyKey:
					object->as<PathVertexBase>()->y(value);
					break;
				case StraightVertexBase::radiusPropertyKey:
					object->as<StraightVertexBase>()->radius(value);
					break;
				case CubicAsymmetricVertexBase::rotationPropertyKey:
					object->as<CubicAsymmetricVertexBase>()->rotation(value);
					break;
				case CubicAsymmetricVertexBase::inDistancePropertyKey:
					object->as<CubicAsymmetricVertexBase>()->inDistance(value);
					break;
				case CubicAsymmetricVertexBase::outDistancePropertyKey:
					object->as<CubicAsymmetricVertexBase>()->outDistance(value);
					break;
				case ParametricPathBase::widthPropertyKey:
					object->as<ParametricPathBase>()->width(value);
					break;
				case ParametricPathBase::heightPropertyKey:
					object->as<ParametricPathBase>()->height(value);
					break;
				case ParametricPathBase::originXPropertyKey:
					object->as<ParametricPathBase>()->originX(value);
					break;
				case ParametricPathBase::originYPropertyKey:
					object->as<ParametricPathBase>()->originY(value);
					break;
				case RectangleBase::cornerRadiusTLPropertyKey:
					object->as<RectangleBase>()->cornerRadiusTL(value);
					break;
				case RectangleBase::cornerRadiusTRPropertyKey:
					object->as<RectangleBase>()->cornerRadiusTR(value);
					break;
				case RectangleBase::cornerRadiusBLPropertyKey:
					object->as<RectangleBase>()->cornerRadiusBL(value);
					break;
				case RectangleBase::cornerRadiusBRPropertyKey:
					object->as<RectangleBase>()->cornerRadiusBR(value);
					break;
				case CubicMirroredVertexBase::rotationPropertyKey:
					object->as<CubicMirroredVertexBase>()->rotation(value);
					break;
				case CubicMirroredVertexBase::distancePropertyKey:
					object->as<CubicMirroredVertexBase>()->distance(value);
					break;
				case PolygonBase::cornerRadiusPropertyKey:
					object->as<PolygonBase>()->cornerRadius(value);
					break;
				case StarBase::innerRadiusPropertyKey:
					object->as<StarBase>()->innerRadius(value);
					break;
				case CubicDetachedVertexBase::inRotationPropertyKey:
					object->as<CubicDetachedVertexBase>()->inRotation(value);
					break;
				case CubicDetachedVertexBase::inDistancePropertyKey:
					object->as<CubicDetachedVertexBase>()->inDistance(value);
					break;
				case CubicDetachedVertexBase::outRotationPropertyKey:
					object->as<CubicDetachedVertexBase>()->outRotation(value);
					break;
				case CubicDetachedVertexBase::outDistancePropertyKey:
					object->as<CubicDetachedVertexBase>()->outDistance(value);
					break;
				case ArtboardBase::widthPropertyKey:
					object->as<ArtboardBase>()->width(value);
					break;
				case ArtboardBase::heightPropertyKey:
					object->as<ArtboardBase>()->height(value);
					break;
				case ArtboardBase::xPropertyKey:
					object->as<ArtboardBase>()->x(value);
					break;
				case ArtboardBase::yPropertyKey:
					object->as<ArtboardBase>()->y(value);
					break;
				case ArtboardBase::originXPropertyKey:
					object->as<ArtboardBase>()->originX(value);
					break;
				case ArtboardBase::originYPropertyKey:
					object->as<ArtboardBase>()->originY(value);
					break;
				case BoneBase::lengthPropertyKey:
					object->as<BoneBase>()->length(value);
					break;
				case RootBoneBase::xPropertyKey:
					object->as<RootBoneBase>()->x(value);
					break;
				case RootBoneBase::yPropertyKey:
					object->as<RootBoneBase>()->y(value);
					break;
				case SkinBase::xxPropertyKey:
					object->as<SkinBase>()->xx(value);
					break;
				case SkinBase::yxPropertyKey:
					object->as<SkinBase>()->yx(value);
					break;
				case SkinBase::xyPropertyKey:
					object->as<SkinBase>()->xy(value);
					break;
				case SkinBase::yyPropertyKey:
					object->as<SkinBase>()->yy(value);
					break;
				case SkinBase::txPropertyKey:
					object->as<SkinBase>()->tx(value);
					break;
				case SkinBase::tyPropertyKey:
					object->as<SkinBase>()->ty(value);
					break;
				case TendonBase::xxPropertyKey:
					object->as<TendonBase>()->xx(value);
					break;
				case TendonBase::yxPropertyKey:
					object->as<TendonBase>()->yx(value);
					break;
				case TendonBase::xyPropertyKey:
					object->as<TendonBase>()->xy(value);
					break;
				case TendonBase::yyPropertyKey:
					object->as<TendonBase>()->yy(value);
					break;
				case TendonBase::txPropertyKey:
					object->as<TendonBase>()->tx(value);
					break;
				case TendonBase::tyPropertyKey:
					object->as<TendonBase>()->ty(value);
					break;
				case DrawableAssetBase::heightPropertyKey:
					object->as<DrawableAssetBase>()->height(value);
					break;
				case DrawableAssetBase::widthPropertyKey:
					object->as<DrawableAssetBase>()->width(value);
					break;
			}
		}
		static void setBool(Core* object, int propertyKey, bool value)
		{
			switch (propertyKey)
			{
				case TransformComponentConstraintBase::offsetPropertyKey:
					object->as<TransformComponentConstraintBase>()->offset(
					    value);
					break;
				case TransformComponentConstraintBase::doesCopyPropertyKey:
					object->as<TransformComponentConstraintBase>()->doesCopy(
					    value);
					break;
				case TransformComponentConstraintBase::minPropertyKey:
					object->as<TransformComponentConstraintBase>()->min(value);
					break;
				case TransformComponentConstraintBase::maxPropertyKey:
					object->as<TransformComponentConstraintBase>()->max(value);
					break;
				case TransformComponentConstraintYBase::doesCopyYPropertyKey:
					object->as<TransformComponentConstraintYBase>()->doesCopyY(
					    value);
					break;
				case TransformComponentConstraintYBase::minYPropertyKey:
					object->as<TransformComponentConstraintYBase>()->minY(
					    value);
					break;
				case TransformComponentConstraintYBase::maxYPropertyKey:
					object->as<TransformComponentConstraintYBase>()->maxY(
					    value);
					break;
				case IKConstraintBase::invertDirectionPropertyKey:
					object->as<IKConstraintBase>()->invertDirection(value);
					break;
				case NestedSimpleAnimationBase::isPlayingPropertyKey:
					object->as<NestedSimpleAnimationBase>()->isPlaying(value);
					break;
				case KeyFrameBoolBase::valuePropertyKey:
					object->as<KeyFrameBoolBase>()->value(value);
					break;
				case LinearAnimationBase::enableWorkAreaPropertyKey:
					object->as<LinearAnimationBase>()->enableWorkArea(value);
					break;
				case StateMachineBoolBase::valuePropertyKey:
					object->as<StateMachineBoolBase>()->value(value);
					break;
				case ShapePaintBase::isVisiblePropertyKey:
					object->as<ShapePaintBase>()->isVisible(value);
					break;
				case StrokeBase::transformAffectsStrokePropertyKey:
					object->as<StrokeBase>()->transformAffectsStroke(value);
					break;
				case PointsPathBase::isClosedPropertyKey:
					object->as<PointsPathBase>()->isClosed(value);
					break;
				case RectangleBase::linkCornerRadiusPropertyKey:
					object->as<RectangleBase>()->linkCornerRadius(value);
					break;
				case ClippingShapeBase::isVisiblePropertyKey:
					object->as<ClippingShapeBase>()->isVisible(value);
					break;
				case ArtboardBase::clipPropertyKey:
					object->as<ArtboardBase>()->clip(value);
					break;
			}
		}
		static void setColor(Core* object, int propertyKey, int value)
		{
			switch (propertyKey)
			{
				case KeyFrameColorBase::valuePropertyKey:
					object->as<KeyFrameColorBase>()->value(value);
					break;
				case SolidColorBase::colorValuePropertyKey:
					object->as<SolidColorBase>()->colorValue(value);
					break;
				case GradientStopBase::colorValuePropertyKey:
					object->as<GradientStopBase>()->colorValue(value);
					break;
			}
		}
		static void
		setBytes(Core* object, int propertyKey, std::vector<uint8_t> value)
		{
			switch (propertyKey)
			{
				case FileAssetContentsBase::bytesPropertyKey:
					object->as<FileAssetContentsBase>()->bytes(value);
					break;
			}
		}
		static std::string getString(Core* object, int propertyKey)
		{
			switch (propertyKey)
			{
				case ComponentBase::namePropertyKey:
					return object->as<ComponentBase>()->name();
				case StateMachineComponentBase::namePropertyKey:
					return object->as<StateMachineComponentBase>()->name();
				case AnimationBase::namePropertyKey:
					return object->as<AnimationBase>()->name();
				case AssetBase::namePropertyKey:
					return object->as<AssetBase>()->name();
			}
			return "";
		}
		static int getUint(Core* object, int propertyKey)
		{
			switch (propertyKey)
			{
				case ComponentBase::parentIdPropertyKey:
					return object->as<ComponentBase>()->parentId();
				case DrawTargetBase::drawableIdPropertyKey:
					return object->as<DrawTargetBase>()->drawableId();
				case DrawTargetBase::placementValuePropertyKey:
					return object->as<DrawTargetBase>()->placementValue();
				case TargetedConstraintBase::targetIdPropertyKey:
					return object->as<TargetedConstraintBase>()->targetId();
				case DistanceConstraintBase::modeValuePropertyKey:
					return object->as<DistanceConstraintBase>()->modeValue();
				case TransformSpaceConstraintBase::sourceSpaceValuePropertyKey:
					return object->as<TransformSpaceConstraintBase>()
					    ->sourceSpaceValue();
				case TransformSpaceConstraintBase::destSpaceValuePropertyKey:
					return object->as<TransformSpaceConstraintBase>()
					    ->destSpaceValue();
				case TransformComponentConstraintBase::
				    minMaxSpaceValuePropertyKey:
					return object->as<TransformComponentConstraintBase>()
					    ->minMaxSpaceValue();
				case IKConstraintBase::parentBoneCountPropertyKey:
					return object->as<IKConstraintBase>()->parentBoneCount();
				case DrawableBase::blendModeValuePropertyKey:
					return object->as<DrawableBase>()->blendModeValue();
				case DrawableBase::drawableFlagsPropertyKey:
					return object->as<DrawableBase>()->drawableFlags();
				case NestedArtboardBase::artboardIdPropertyKey:
					return object->as<NestedArtboardBase>()->artboardId();
				case NestedAnimationBase::animationIdPropertyKey:
					return object->as<NestedAnimationBase>()->animationId();
				case AnimationStateBase::animationIdPropertyKey:
					return object->as<AnimationStateBase>()->animationId();
				case KeyedObjectBase::objectIdPropertyKey:
					return object->as<KeyedObjectBase>()->objectId();
				case BlendAnimationBase::animationIdPropertyKey:
					return object->as<BlendAnimationBase>()->animationId();
				case BlendAnimationDirectBase::inputIdPropertyKey:
					return object->as<BlendAnimationDirectBase>()->inputId();
				case TransitionConditionBase::inputIdPropertyKey:
					return object->as<TransitionConditionBase>()->inputId();
				case KeyedPropertyBase::propertyKeyPropertyKey:
					return object->as<KeyedPropertyBase>()->propertyKey();
				case KeyFrameBase::framePropertyKey:
					return object->as<KeyFrameBase>()->frame();
				case KeyFrameBase::interpolationTypePropertyKey:
					return object->as<KeyFrameBase>()->interpolationType();
				case KeyFrameBase::interpolatorIdPropertyKey:
					return object->as<KeyFrameBase>()->interpolatorId();
				case KeyFrameIdBase::valuePropertyKey:
					return object->as<KeyFrameIdBase>()->value();
				case TransitionValueConditionBase::opValuePropertyKey:
					return object->as<TransitionValueConditionBase>()
					    ->opValue();
				case StateTransitionBase::stateToIdPropertyKey:
					return object->as<StateTransitionBase>()->stateToId();
				case StateTransitionBase::flagsPropertyKey:
					return object->as<StateTransitionBase>()->flags();
				case StateTransitionBase::durationPropertyKey:
					return object->as<StateTransitionBase>()->duration();
				case StateTransitionBase::exitTimePropertyKey:
					return object->as<StateTransitionBase>()->exitTime();
				case LinearAnimationBase::fpsPropertyKey:
					return object->as<LinearAnimationBase>()->fps();
				case LinearAnimationBase::durationPropertyKey:
					return object->as<LinearAnimationBase>()->duration();
				case LinearAnimationBase::loopValuePropertyKey:
					return object->as<LinearAnimationBase>()->loopValue();
				case LinearAnimationBase::workStartPropertyKey:
					return object->as<LinearAnimationBase>()->workStart();
				case LinearAnimationBase::workEndPropertyKey:
					return object->as<LinearAnimationBase>()->workEnd();
				case BlendState1DBase::inputIdPropertyKey:
					return object->as<BlendState1DBase>()->inputId();
				case BlendStateTransitionBase::exitBlendAnimationIdPropertyKey:
					return object->as<BlendStateTransitionBase>()
					    ->exitBlendAnimationId();
				case StrokeBase::capPropertyKey:
					return object->as<StrokeBase>()->cap();
				case StrokeBase::joinPropertyKey:
					return object->as<StrokeBase>()->join();
				case TrimPathBase::modeValuePropertyKey:
					return object->as<TrimPathBase>()->modeValue();
				case FillBase::fillRulePropertyKey:
					return object->as<FillBase>()->fillRule();
				case PathBase::pathFlagsPropertyKey:
					return object->as<PathBase>()->pathFlags();
				case ClippingShapeBase::sourceIdPropertyKey:
					return object->as<ClippingShapeBase>()->sourceId();
				case ClippingShapeBase::fillRulePropertyKey:
					return object->as<ClippingShapeBase>()->fillRule();
				case PolygonBase::pointsPropertyKey:
					return object->as<PolygonBase>()->points();
				case ImageBase::assetIdPropertyKey:
					return object->as<ImageBase>()->assetId();
				case DrawRulesBase::drawTargetIdPropertyKey:
					return object->as<DrawRulesBase>()->drawTargetId();
				case WeightBase::valuesPropertyKey:
					return object->as<WeightBase>()->values();
				case WeightBase::indicesPropertyKey:
					return object->as<WeightBase>()->indices();
				case TendonBase::boneIdPropertyKey:
					return object->as<TendonBase>()->boneId();
				case CubicWeightBase::inValuesPropertyKey:
					return object->as<CubicWeightBase>()->inValues();
				case CubicWeightBase::inIndicesPropertyKey:
					return object->as<CubicWeightBase>()->inIndices();
				case CubicWeightBase::outValuesPropertyKey:
					return object->as<CubicWeightBase>()->outValues();
				case CubicWeightBase::outIndicesPropertyKey:
					return object->as<CubicWeightBase>()->outIndices();
				case FileAssetBase::assetIdPropertyKey:
					return object->as<FileAssetBase>()->assetId();
			}
			return 0;
		}
		static float getDouble(Core* object, int propertyKey)
		{
			switch (propertyKey)
			{
				case ConstraintBase::strengthPropertyKey:
					return object->as<ConstraintBase>()->strength();
				case DistanceConstraintBase::distancePropertyKey:
					return object->as<DistanceConstraintBase>()->distance();
				case TransformComponentConstraintBase::copyFactorPropertyKey:
					return object->as<TransformComponentConstraintBase>()
					    ->copyFactor();
				case TransformComponentConstraintBase::minValuePropertyKey:
					return object->as<TransformComponentConstraintBase>()
					    ->minValue();
				case TransformComponentConstraintBase::maxValuePropertyKey:
					return object->as<TransformComponentConstraintBase>()
					    ->maxValue();
				case TransformComponentConstraintYBase::copyFactorYPropertyKey:
					return object->as<TransformComponentConstraintYBase>()
					    ->copyFactorY();
				case TransformComponentConstraintYBase::minValueYPropertyKey:
					return object->as<TransformComponentConstraintYBase>()
					    ->minValueY();
				case TransformComponentConstraintYBase::maxValueYPropertyKey:
					return object->as<TransformComponentConstraintYBase>()
					    ->maxValueY();
				case WorldTransformComponentBase::opacityPropertyKey:
					return object->as<WorldTransformComponentBase>()->opacity();
				case TransformComponentBase::rotationPropertyKey:
					return object->as<TransformComponentBase>()->rotation();
				case TransformComponentBase::scaleXPropertyKey:
					return object->as<TransformComponentBase>()->scaleX();
				case TransformComponentBase::scaleYPropertyKey:
					return object->as<TransformComponentBase>()->scaleY();
				case NodeBase::xPropertyKey:
					return object->as<NodeBase>()->x();
				case NodeBase::yPropertyKey:
					return object->as<NodeBase>()->y();
				case NestedLinearAnimationBase::mixPropertyKey:
					return object->as<NestedLinearAnimationBase>()->mix();
				case NestedSimpleAnimationBase::speedPropertyKey:
					return object->as<NestedSimpleAnimationBase>()->speed();
				case StateMachineNumberBase::valuePropertyKey:
					return object->as<StateMachineNumberBase>()->value();
				case TransitionNumberConditionBase::valuePropertyKey:
					return object->as<TransitionNumberConditionBase>()->value();
				case CubicInterpolatorBase::x1PropertyKey:
					return object->as<CubicInterpolatorBase>()->x1();
				case CubicInterpolatorBase::y1PropertyKey:
					return object->as<CubicInterpolatorBase>()->y1();
				case CubicInterpolatorBase::x2PropertyKey:
					return object->as<CubicInterpolatorBase>()->x2();
				case CubicInterpolatorBase::y2PropertyKey:
					return object->as<CubicInterpolatorBase>()->y2();
				case KeyFrameDoubleBase::valuePropertyKey:
					return object->as<KeyFrameDoubleBase>()->value();
				case LinearAnimationBase::speedPropertyKey:
					return object->as<LinearAnimationBase>()->speed();
				case NestedRemapAnimationBase::timePropertyKey:
					return object->as<NestedRemapAnimationBase>()->time();
				case BlendAnimation1DBase::valuePropertyKey:
					return object->as<BlendAnimation1DBase>()->value();
				case LinearGradientBase::startXPropertyKey:
					return object->as<LinearGradientBase>()->startX();
				case LinearGradientBase::startYPropertyKey:
					return object->as<LinearGradientBase>()->startY();
				case LinearGradientBase::endXPropertyKey:
					return object->as<LinearGradientBase>()->endX();
				case LinearGradientBase::endYPropertyKey:
					return object->as<LinearGradientBase>()->endY();
				case LinearGradientBase::opacityPropertyKey:
					return object->as<LinearGradientBase>()->opacity();
				case StrokeBase::thicknessPropertyKey:
					return object->as<StrokeBase>()->thickness();
				case GradientStopBase::positionPropertyKey:
					return object->as<GradientStopBase>()->position();
				case TrimPathBase::startPropertyKey:
					return object->as<TrimPathBase>()->start();
				case TrimPathBase::endPropertyKey:
					return object->as<TrimPathBase>()->end();
				case TrimPathBase::offsetPropertyKey:
					return object->as<TrimPathBase>()->offset();
				case PathVertexBase::xPropertyKey:
					return object->as<PathVertexBase>()->x();
				case PathVertexBase::yPropertyKey:
					return object->as<PathVertexBase>()->y();
				case StraightVertexBase::radiusPropertyKey:
					return object->as<StraightVertexBase>()->radius();
				case CubicAsymmetricVertexBase::rotationPropertyKey:
					return object->as<CubicAsymmetricVertexBase>()->rotation();
				case CubicAsymmetricVertexBase::inDistancePropertyKey:
					return object->as<CubicAsymmetricVertexBase>()
					    ->inDistance();
				case CubicAsymmetricVertexBase::outDistancePropertyKey:
					return object->as<CubicAsymmetricVertexBase>()
					    ->outDistance();
				case ParametricPathBase::widthPropertyKey:
					return object->as<ParametricPathBase>()->width();
				case ParametricPathBase::heightPropertyKey:
					return object->as<ParametricPathBase>()->height();
				case ParametricPathBase::originXPropertyKey:
					return object->as<ParametricPathBase>()->originX();
				case ParametricPathBase::originYPropertyKey:
					return object->as<ParametricPathBase>()->originY();
				case RectangleBase::cornerRadiusTLPropertyKey:
					return object->as<RectangleBase>()->cornerRadiusTL();
				case RectangleBase::cornerRadiusTRPropertyKey:
					return object->as<RectangleBase>()->cornerRadiusTR();
				case RectangleBase::cornerRadiusBLPropertyKey:
					return object->as<RectangleBase>()->cornerRadiusBL();
				case RectangleBase::cornerRadiusBRPropertyKey:
					return object->as<RectangleBase>()->cornerRadiusBR();
				case CubicMirroredVertexBase::rotationPropertyKey:
					return object->as<CubicMirroredVertexBase>()->rotation();
				case CubicMirroredVertexBase::distancePropertyKey:
					return object->as<CubicMirroredVertexBase>()->distance();
				case PolygonBase::cornerRadiusPropertyKey:
					return object->as<PolygonBase>()->cornerRadius();
				case StarBase::innerRadiusPropertyKey:
					return object->as<StarBase>()->innerRadius();
				case CubicDetachedVertexBase::inRotationPropertyKey:
					return object->as<CubicDetachedVertexBase>()->inRotation();
				case CubicDetachedVertexBase::inDistancePropertyKey:
					return object->as<CubicDetachedVertexBase>()->inDistance();
				case CubicDetachedVertexBase::outRotationPropertyKey:
					return object->as<CubicDetachedVertexBase>()->outRotation();
				case CubicDetachedVertexBase::outDistancePropertyKey:
					return object->as<CubicDetachedVertexBase>()->outDistance();
				case ArtboardBase::widthPropertyKey:
					return object->as<ArtboardBase>()->width();
				case ArtboardBase::heightPropertyKey:
					return object->as<ArtboardBase>()->height();
				case ArtboardBase::xPropertyKey:
					return object->as<ArtboardBase>()->x();
				case ArtboardBase::yPropertyKey:
					return object->as<ArtboardBase>()->y();
				case ArtboardBase::originXPropertyKey:
					return object->as<ArtboardBase>()->originX();
				case ArtboardBase::originYPropertyKey:
					return object->as<ArtboardBase>()->originY();
				case BoneBase::lengthPropertyKey:
					return object->as<BoneBase>()->length();
				case RootBoneBase::xPropertyKey:
					return object->as<RootBoneBase>()->x();
				case RootBoneBase::yPropertyKey:
					return object->as<RootBoneBase>()->y();
				case SkinBase::xxPropertyKey:
					return object->as<SkinBase>()->xx();
				case SkinBase::yxPropertyKey:
					return object->as<SkinBase>()->yx();
				case SkinBase::xyPropertyKey:
					return object->as<SkinBase>()->xy();
				case SkinBase::yyPropertyKey:
					return object->as<SkinBase>()->yy();
				case SkinBase::txPropertyKey:
					return object->as<SkinBase>()->tx();
				case SkinBase::tyPropertyKey:
					return object->as<SkinBase>()->ty();
				case TendonBase::xxPropertyKey:
					return object->as<TendonBase>()->xx();
				case TendonBase::yxPropertyKey:
					return object->as<TendonBase>()->yx();
				case TendonBase::xyPropertyKey:
					return object->as<TendonBase>()->xy();
				case TendonBase::yyPropertyKey:
					return object->as<TendonBase>()->yy();
				case TendonBase::txPropertyKey:
					return object->as<TendonBase>()->tx();
				case TendonBase::tyPropertyKey:
					return object->as<TendonBase>()->ty();
				case DrawableAssetBase::heightPropertyKey:
					return object->as<DrawableAssetBase>()->height();
				case DrawableAssetBase::widthPropertyKey:
					return object->as<DrawableAssetBase>()->width();
			}
			return 0.0f;
		}
		static bool getBool(Core* object, int propertyKey)
		{
			switch (propertyKey)
			{
				case TransformComponentConstraintBase::offsetPropertyKey:
					return object->as<TransformComponentConstraintBase>()
					    ->offset();
				case TransformComponentConstraintBase::doesCopyPropertyKey:
					return object->as<TransformComponentConstraintBase>()
					    ->doesCopy();
				case TransformComponentConstraintBase::minPropertyKey:
					return object->as<TransformComponentConstraintBase>()
					    ->min();
				case TransformComponentConstraintBase::maxPropertyKey:
					return object->as<TransformComponentConstraintBase>()
					    ->max();
				case TransformComponentConstraintYBase::doesCopyYPropertyKey:
					return object->as<TransformComponentConstraintYBase>()
					    ->doesCopyY();
				case TransformComponentConstraintYBase::minYPropertyKey:
					return object->as<TransformComponentConstraintYBase>()
					    ->minY();
				case TransformComponentConstraintYBase::maxYPropertyKey:
					return object->as<TransformComponentConstraintYBase>()
					    ->maxY();
				case IKConstraintBase::invertDirectionPropertyKey:
					return object->as<IKConstraintBase>()->invertDirection();
				case NestedSimpleAnimationBase::isPlayingPropertyKey:
					return object->as<NestedSimpleAnimationBase>()->isPlaying();
				case KeyFrameBoolBase::valuePropertyKey:
					return object->as<KeyFrameBoolBase>()->value();
				case LinearAnimationBase::enableWorkAreaPropertyKey:
					return object->as<LinearAnimationBase>()->enableWorkArea();
				case StateMachineBoolBase::valuePropertyKey:
					return object->as<StateMachineBoolBase>()->value();
				case ShapePaintBase::isVisiblePropertyKey:
					return object->as<ShapePaintBase>()->isVisible();
				case StrokeBase::transformAffectsStrokePropertyKey:
					return object->as<StrokeBase>()->transformAffectsStroke();
				case PointsPathBase::isClosedPropertyKey:
					return object->as<PointsPathBase>()->isClosed();
				case RectangleBase::linkCornerRadiusPropertyKey:
					return object->as<RectangleBase>()->linkCornerRadius();
				case ClippingShapeBase::isVisiblePropertyKey:
					return object->as<ClippingShapeBase>()->isVisible();
				case ArtboardBase::clipPropertyKey:
					return object->as<ArtboardBase>()->clip();
			}
			return false;
		}
		static int getColor(Core* object, int propertyKey)
		{
			switch (propertyKey)
			{
				case KeyFrameColorBase::valuePropertyKey:
					return object->as<KeyFrameColorBase>()->value();
				case SolidColorBase::colorValuePropertyKey:
					return object->as<SolidColorBase>()->colorValue();
				case GradientStopBase::colorValuePropertyKey:
					return object->as<GradientStopBase>()->colorValue();
			}
			return 0;
		}
		static std::vector<uint8_t> getBytes(Core* object, int propertyKey)
		{
			switch (propertyKey)
			{
				case FileAssetContentsBase::bytesPropertyKey:
					return object->as<FileAssetContentsBase>()->bytes();
			}
			return std::vector<uint8_t>();
		}
		static int propertyFieldId(int propertyKey)
		{
			switch (propertyKey)
			{
				case ComponentBase::namePropertyKey:
				case StateMachineComponentBase::namePropertyKey:
				case AnimationBase::namePropertyKey:
				case AssetBase::namePropertyKey:
					return CoreStringType::id;
				case ComponentBase::parentIdPropertyKey:
				case DrawTargetBase::drawableIdPropertyKey:
				case DrawTargetBase::placementValuePropertyKey:
				case TargetedConstraintBase::targetIdPropertyKey:
				case DistanceConstraintBase::modeValuePropertyKey:
				case TransformSpaceConstraintBase::sourceSpaceValuePropertyKey:
				case TransformSpaceConstraintBase::destSpaceValuePropertyKey:
				case TransformComponentConstraintBase::
				    minMaxSpaceValuePropertyKey:
				case IKConstraintBase::parentBoneCountPropertyKey:
				case DrawableBase::blendModeValuePropertyKey:
				case DrawableBase::drawableFlagsPropertyKey:
				case NestedArtboardBase::artboardIdPropertyKey:
				case NestedAnimationBase::animationIdPropertyKey:
				case AnimationStateBase::animationIdPropertyKey:
				case KeyedObjectBase::objectIdPropertyKey:
				case BlendAnimationBase::animationIdPropertyKey:
				case BlendAnimationDirectBase::inputIdPropertyKey:
				case TransitionConditionBase::inputIdPropertyKey:
				case KeyedPropertyBase::propertyKeyPropertyKey:
				case KeyFrameBase::framePropertyKey:
				case KeyFrameBase::interpolationTypePropertyKey:
				case KeyFrameBase::interpolatorIdPropertyKey:
				case KeyFrameIdBase::valuePropertyKey:
				case TransitionValueConditionBase::opValuePropertyKey:
				case StateTransitionBase::stateToIdPropertyKey:
				case StateTransitionBase::flagsPropertyKey:
				case StateTransitionBase::durationPropertyKey:
				case StateTransitionBase::exitTimePropertyKey:
				case LinearAnimationBase::fpsPropertyKey:
				case LinearAnimationBase::durationPropertyKey:
				case LinearAnimationBase::loopValuePropertyKey:
				case LinearAnimationBase::workStartPropertyKey:
				case LinearAnimationBase::workEndPropertyKey:
				case BlendState1DBase::inputIdPropertyKey:
				case BlendStateTransitionBase::exitBlendAnimationIdPropertyKey:
				case StrokeBase::capPropertyKey:
				case StrokeBase::joinPropertyKey:
				case TrimPathBase::modeValuePropertyKey:
				case FillBase::fillRulePropertyKey:
				case PathBase::pathFlagsPropertyKey:
				case ClippingShapeBase::sourceIdPropertyKey:
				case ClippingShapeBase::fillRulePropertyKey:
				case PolygonBase::pointsPropertyKey:
				case ImageBase::assetIdPropertyKey:
				case DrawRulesBase::drawTargetIdPropertyKey:
				case WeightBase::valuesPropertyKey:
				case WeightBase::indicesPropertyKey:
				case TendonBase::boneIdPropertyKey:
				case CubicWeightBase::inValuesPropertyKey:
				case CubicWeightBase::inIndicesPropertyKey:
				case CubicWeightBase::outValuesPropertyKey:
				case CubicWeightBase::outIndicesPropertyKey:
				case FileAssetBase::assetIdPropertyKey:
					return CoreUintType::id;
				case ConstraintBase::strengthPropertyKey:
				case DistanceConstraintBase::distancePropertyKey:
				case TransformComponentConstraintBase::copyFactorPropertyKey:
				case TransformComponentConstraintBase::minValuePropertyKey:
				case TransformComponentConstraintBase::maxValuePropertyKey:
				case TransformComponentConstraintYBase::copyFactorYPropertyKey:
				case TransformComponentConstraintYBase::minValueYPropertyKey:
				case TransformComponentConstraintYBase::maxValueYPropertyKey:
				case WorldTransformComponentBase::opacityPropertyKey:
				case TransformComponentBase::rotationPropertyKey:
				case TransformComponentBase::scaleXPropertyKey:
				case TransformComponentBase::scaleYPropertyKey:
				case NodeBase::xPropertyKey:
				case NodeBase::yPropertyKey:
				case NestedLinearAnimationBase::mixPropertyKey:
				case NestedSimpleAnimationBase::speedPropertyKey:
				case StateMachineNumberBase::valuePropertyKey:
				case TransitionNumberConditionBase::valuePropertyKey:
				case CubicInterpolatorBase::x1PropertyKey:
				case CubicInterpolatorBase::y1PropertyKey:
				case CubicInterpolatorBase::x2PropertyKey:
				case CubicInterpolatorBase::y2PropertyKey:
				case KeyFrameDoubleBase::valuePropertyKey:
				case LinearAnimationBase::speedPropertyKey:
				case NestedRemapAnimationBase::timePropertyKey:
				case BlendAnimation1DBase::valuePropertyKey:
				case LinearGradientBase::startXPropertyKey:
				case LinearGradientBase::startYPropertyKey:
				case LinearGradientBase::endXPropertyKey:
				case LinearGradientBase::endYPropertyKey:
				case LinearGradientBase::opacityPropertyKey:
				case StrokeBase::thicknessPropertyKey:
				case GradientStopBase::positionPropertyKey:
				case TrimPathBase::startPropertyKey:
				case TrimPathBase::endPropertyKey:
				case TrimPathBase::offsetPropertyKey:
				case PathVertexBase::xPropertyKey:
				case PathVertexBase::yPropertyKey:
				case StraightVertexBase::radiusPropertyKey:
				case CubicAsymmetricVertexBase::rotationPropertyKey:
				case CubicAsymmetricVertexBase::inDistancePropertyKey:
				case CubicAsymmetricVertexBase::outDistancePropertyKey:
				case ParametricPathBase::widthPropertyKey:
				case ParametricPathBase::heightPropertyKey:
				case ParametricPathBase::originXPropertyKey:
				case ParametricPathBase::originYPropertyKey:
				case RectangleBase::cornerRadiusTLPropertyKey:
				case RectangleBase::cornerRadiusTRPropertyKey:
				case RectangleBase::cornerRadiusBLPropertyKey:
				case RectangleBase::cornerRadiusBRPropertyKey:
				case CubicMirroredVertexBase::rotationPropertyKey:
				case CubicMirroredVertexBase::distancePropertyKey:
				case PolygonBase::cornerRadiusPropertyKey:
				case StarBase::innerRadiusPropertyKey:
				case CubicDetachedVertexBase::inRotationPropertyKey:
				case CubicDetachedVertexBase::inDistancePropertyKey:
				case CubicDetachedVertexBase::outRotationPropertyKey:
				case CubicDetachedVertexBase::outDistancePropertyKey:
				case ArtboardBase::widthPropertyKey:
				case ArtboardBase::heightPropertyKey:
				case ArtboardBase::xPropertyKey:
				case ArtboardBase::yPropertyKey:
				case ArtboardBase::originXPropertyKey:
				case ArtboardBase::originYPropertyKey:
				case BoneBase::lengthPropertyKey:
				case RootBoneBase::xPropertyKey:
				case RootBoneBase::yPropertyKey:
				case SkinBase::xxPropertyKey:
				case SkinBase::yxPropertyKey:
				case SkinBase::xyPropertyKey:
				case SkinBase::yyPropertyKey:
				case SkinBase::txPropertyKey:
				case SkinBase::tyPropertyKey:
				case TendonBase::xxPropertyKey:
				case TendonBase::yxPropertyKey:
				case TendonBase::xyPropertyKey:
				case TendonBase::yyPropertyKey:
				case TendonBase::txPropertyKey:
				case TendonBase::tyPropertyKey:
				case DrawableAssetBase::heightPropertyKey:
				case DrawableAssetBase::widthPropertyKey:
					return CoreDoubleType::id;
				case TransformComponentConstraintBase::offsetPropertyKey:
				case TransformComponentConstraintBase::doesCopyPropertyKey:
				case TransformComponentConstraintBase::minPropertyKey:
				case TransformComponentConstraintBase::maxPropertyKey:
				case TransformComponentConstraintYBase::doesCopyYPropertyKey:
				case TransformComponentConstraintYBase::minYPropertyKey:
				case TransformComponentConstraintYBase::maxYPropertyKey:
				case IKConstraintBase::invertDirectionPropertyKey:
				case NestedSimpleAnimationBase::isPlayingPropertyKey:
				case KeyFrameBoolBase::valuePropertyKey:
				case LinearAnimationBase::enableWorkAreaPropertyKey:
				case StateMachineBoolBase::valuePropertyKey:
				case ShapePaintBase::isVisiblePropertyKey:
				case StrokeBase::transformAffectsStrokePropertyKey:
				case PointsPathBase::isClosedPropertyKey:
				case RectangleBase::linkCornerRadiusPropertyKey:
				case ClippingShapeBase::isVisiblePropertyKey:
				case ArtboardBase::clipPropertyKey:
					return CoreBoolType::id;
				case KeyFrameColorBase::valuePropertyKey:
				case SolidColorBase::colorValuePropertyKey:
				case GradientStopBase::colorValuePropertyKey:
					return CoreColorType::id;
				case FileAssetContentsBase::bytesPropertyKey:
					return CoreBytesType::id;
				default:
					return -1;
			}
		}
	};
} // namespace rive

#endif