#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/listener_action.hpp"
#include "rive/animation/listener_align_target.hpp"
#include "rive/animation/listener_bool_change.hpp"
#include "rive/animation/listener_input_change.hpp"
#include "rive/animation/listener_number_change.hpp"
#include "rive/animation/listener_trigger_change.hpp"
#include "rive/animation/nested_bool.hpp"
#include "rive/animation/nested_input.hpp"
#include "rive/animation/nested_linear_animation.hpp"
#include "rive/animation/nested_number.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/nested_trigger.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_listener.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/contour_mesh_vertex.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/mesh.hpp"
#include "rive/shapes/mesh_vertex.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/shapes/vertex.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 NestedTriggerBase::typeKey:
                    return new NestedTrigger();
                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 StateMachineListenerBase::typeKey:
                    return new StateMachineListener();
                case KeyFrameIdBase::typeKey:
                    return new KeyFrameId();
                case KeyFrameBoolBase::typeKey:
                    return new KeyFrameBool();
                case ListenerBoolChangeBase::typeKey:
                    return new ListenerBoolChange();
                case ListenerAlignTargetBase::typeKey:
                    return new ListenerAlignTarget();
                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 ListenerNumberChangeBase::typeKey:
                    return new ListenerNumberChange();
                case CubicInterpolatorBase::typeKey:
                    return new CubicInterpolator();
                case StateTransitionBase::typeKey:
                    return new StateTransition();
                case NestedBoolBase::typeKey:
                    return new NestedBool();
                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 ListenerTriggerChangeBase::typeKey:
                    return new ListenerTriggerChange();
                case BlendStateDirectBase::typeKey:
                    return new BlendStateDirect();
                case NestedStateMachineBase::typeKey:
                    return new NestedStateMachine();
                case ExitStateBase::typeKey:
                    return new ExitState();
                case NestedNumberBase::typeKey:
                    return new NestedNumber();
                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 MeshVertexBase::typeKey:
                    return new MeshVertex();
                case ShapeBase::typeKey:
                    return new Shape();
                case StraightVertexBase::typeKey:
                    return new StraightVertex();
                case CubicAsymmetricVertexBase::typeKey:
                    return new CubicAsymmetricVertex();
                case MeshBase::typeKey:
                    return new Mesh();
                case PointsPathBase::typeKey:
                    return new PointsPath();
                case ContourMeshVertexBase::typeKey:
                    return new ContourMeshVertex();
                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, uint32_t 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 ListenerInputChangeBase::inputIdPropertyKey:
                    object->as<ListenerInputChangeBase>()->inputId(value);
                    break;
                case AnimationStateBase::animationIdPropertyKey:
                    object->as<AnimationStateBase>()->animationId(value);
                    break;
                case NestedInputBase::inputIdPropertyKey:
                    object->as<NestedInputBase>()->inputId(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 StateMachineListenerBase::targetIdPropertyKey:
                    object->as<StateMachineListenerBase>()->targetId(value);
                    break;
                case StateMachineListenerBase::listenerTypeValuePropertyKey:
                    object->as<StateMachineListenerBase>()->listenerTypeValue(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 ListenerBoolChangeBase::valuePropertyKey:
                    object->as<ListenerBoolChangeBase>()->value(value);
                    break;
                case ListenerAlignTargetBase::targetIdPropertyKey:
                    object->as<ListenerAlignTargetBase>()->targetId(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 ArtboardBase::defaultStateMachineIdPropertyKey:
                    object->as<ArtboardBase>()->defaultStateMachineId(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 ListenerNumberChangeBase::valuePropertyKey:
                    object->as<ListenerNumberChangeBase>()->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 NestedNumberBase::nestedValuePropertyKey:
                    object->as<NestedNumberBase>()->nestedValue(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 VertexBase::xPropertyKey:
                    object->as<VertexBase>()->x(value);
                    break;
                case VertexBase::yPropertyKey:
                    object->as<VertexBase>()->y(value);
                    break;
                case MeshVertexBase::uPropertyKey:
                    object->as<MeshVertexBase>()->u(value);
                    break;
                case MeshVertexBase::vPropertyKey:
                    object->as<MeshVertexBase>()->v(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 NestedBoolBase::nestedValuePropertyKey:
                    object->as<NestedBoolBase>()->nestedValue(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 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 uint32_t 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 ListenerInputChangeBase::inputIdPropertyKey:
                    return object->as<ListenerInputChangeBase>()->inputId();
                case AnimationStateBase::animationIdPropertyKey:
                    return object->as<AnimationStateBase>()->animationId();
                case NestedInputBase::inputIdPropertyKey:
                    return object->as<NestedInputBase>()->inputId();
                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 StateMachineListenerBase::targetIdPropertyKey:
                    return object->as<StateMachineListenerBase>()->targetId();
                case StateMachineListenerBase::listenerTypeValuePropertyKey:
                    return object->as<StateMachineListenerBase>()->listenerTypeValue();
                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 ListenerBoolChangeBase::valuePropertyKey:
                    return object->as<ListenerBoolChangeBase>()->value();
                case ListenerAlignTargetBase::targetIdPropertyKey:
                    return object->as<ListenerAlignTargetBase>()->targetId();
                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 ArtboardBase::defaultStateMachineIdPropertyKey:
                    return object->as<ArtboardBase>()->defaultStateMachineId();
                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 ListenerNumberChangeBase::valuePropertyKey:
                    return object->as<ListenerNumberChangeBase>()->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 NestedNumberBase::nestedValuePropertyKey:
                    return object->as<NestedNumberBase>()->nestedValue();
                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 VertexBase::xPropertyKey:
                    return object->as<VertexBase>()->x();
                case VertexBase::yPropertyKey:
                    return object->as<VertexBase>()->y();
                case MeshVertexBase::uPropertyKey:
                    return object->as<MeshVertexBase>()->u();
                case MeshVertexBase::vPropertyKey:
                    return object->as<MeshVertexBase>()->v();
                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 NestedBoolBase::nestedValuePropertyKey:
                    return object->as<NestedBoolBase>()->nestedValue();
                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 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 ListenerInputChangeBase::inputIdPropertyKey:
                case AnimationStateBase::animationIdPropertyKey:
                case NestedInputBase::inputIdPropertyKey:
                case KeyedObjectBase::objectIdPropertyKey:
                case BlendAnimationBase::animationIdPropertyKey:
                case BlendAnimationDirectBase::inputIdPropertyKey:
                case TransitionConditionBase::inputIdPropertyKey:
                case KeyedPropertyBase::propertyKeyPropertyKey:
                case StateMachineListenerBase::targetIdPropertyKey:
                case StateMachineListenerBase::listenerTypeValuePropertyKey:
                case KeyFrameBase::framePropertyKey:
                case KeyFrameBase::interpolationTypePropertyKey:
                case KeyFrameBase::interpolatorIdPropertyKey:
                case KeyFrameIdBase::valuePropertyKey:
                case ListenerBoolChangeBase::valuePropertyKey:
                case ListenerAlignTargetBase::targetIdPropertyKey:
                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 ArtboardBase::defaultStateMachineIdPropertyKey:
                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 ListenerNumberChangeBase::valuePropertyKey:
                case CubicInterpolatorBase::x1PropertyKey:
                case CubicInterpolatorBase::y1PropertyKey:
                case CubicInterpolatorBase::x2PropertyKey:
                case CubicInterpolatorBase::y2PropertyKey:
                case KeyFrameDoubleBase::valuePropertyKey:
                case LinearAnimationBase::speedPropertyKey:
                case NestedNumberBase::nestedValuePropertyKey:
                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 VertexBase::xPropertyKey:
                case VertexBase::yPropertyKey:
                case MeshVertexBase::uPropertyKey:
                case MeshVertexBase::vPropertyKey:
                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 NestedBoolBase::nestedValuePropertyKey:
                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 MeshBase::triangleIndexBytesPropertyKey:
                case FileAssetContentsBase::bytesPropertyKey:
                    return CoreBytesType::id;
                default:
                    return -1;
            }
        }
    };
} // namespace rive

#endif