@galacean/engine-spine 4.2.6 → 4.2.7

package/types/spine-core/IkConstraint.d.ts

@@ -1,38 +0,0 @@
-import { Updatable } from "./Updatable";
-import { IkConstraintData } from "./IkConstraintData";
-import { Bone } from "./Bone";
-import { Skeleton } from "./Skeleton";
-/** Stores the current pose for an IK constraint. An IK constraint adjusts the rotation of 1 or 2 constrained bones so the tip of
- * the last bone is as close to the target bone as possible.
- *
- * See [IK constraints](http://esotericsoftware.com/spine-ik-constraints) in the Spine User Guide. */
-export declare class IkConstraint implements Updatable {
-    /** The IK constraint's setup pose data. */
-    data: IkConstraintData;
-    /** The bones that will be modified by this IK constraint. */
-    bones: Array<Bone>;
-    /** The bone that is the IK target. */
-    target: Bone;
-    /** Controls the bend direction of the IK bones, either 1 or -1. */
-    bendDirection: number;
-    /** When true and only a single bone is being constrained, if the target is too close, the bone is scaled to reach it. */
-    compress: boolean;
-    /** When true, if the target is out of range, the parent bone is scaled to reach it. If more than one bone is being constrained
-     * and the parent bone has local nonuniform scale, stretch is not applied. */
-    stretch: boolean;
-    /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
-    mix: number;
-    /** For two bone IK, the distance from the maximum reach of the bones that rotation will slow. */
-    softness: number;
-    active: boolean;
-    constructor(data: IkConstraintData, skeleton: Skeleton);
-    isActive(): boolean;
-    /** Applies the constraint to the constrained bones. */
-    apply(): void;
-    update(): void;
-    /** Applies 1 bone IK. The target is specified in the world coordinate system. */
-    apply1(bone: Bone, targetX: number, targetY: number, compress: boolean, stretch: boolean, uniform: boolean, alpha: number): void;
-    /** Applies 2 bone IK. The target is specified in the world coordinate system.
-     * @param child A direct descendant of the parent bone. */
-    apply2(parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, stretch: boolean, softness: number, alpha: number): void;
-}

package/types/spine-core/IkConstraintData.d.ts

@@ -1,26 +0,0 @@
-import { ConstraintData } from "./ConstraintData";
-import { BoneData } from "./BoneData";
-/** Stores the setup pose for an {@link IkConstraint}.
- * <p>
- * See [IK constraints](http://esotericsoftware.com/spine-ik-constraints) in the Spine User Guide. */
-export declare class IkConstraintData extends ConstraintData {
-    /** The bones that are constrained by this IK constraint. */
-    bones: BoneData[];
-    /** The bone that is the IK target. */
-    target: BoneData;
-    /** Controls the bend direction of the IK bones, either 1 or -1. */
-    bendDirection: number;
-    /** When true and only a single bone is being constrained, if the target is too close, the bone is scaled to reach it. */
-    compress: boolean;
-    /** When true, if the target is out of range, the parent bone is scaled to reach it. If more than one bone is being constrained
-     * and the parent bone has local nonuniform scale, stretch is not applied. */
-    stretch: boolean;
-    /** When true, only a single bone is being constrained, and {@link #getCompress()} or {@link #getStretch()} is used, the bone
-     * is scaled on both the X and Y axes. */
-    uniform: boolean;
-    /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
-    mix: number;
-    /** For two bone IK, the distance from the maximum reach of the bones that rotation will slow. */
-    softness: number;
-    constructor(name: string);
-}

package/types/spine-core/PathConstraint.d.ts

@@ -1,46 +0,0 @@
-import { Updatable } from "./Updatable";
-import { PathConstraintData } from "./PathConstraintData";
-import { Bone } from "./Bone";
-import { Slot } from "./Slot";
-import { Skeleton } from "./Skeleton";
-import { PathAttachment } from "./attachments/PathAttachment";
-/** Stores the current pose for a path constraint. A path constraint adjusts the rotation, translation, and scale of the
- * constrained bones so they follow a {@link PathAttachment}.
- *
- * See [Path constraints](http://esotericsoftware.com/spine-path-constraints) in the Spine User Guide. */
-export declare class PathConstraint implements Updatable {
-    static NONE: number;
-    static BEFORE: number;
-    static AFTER: number;
-    static epsilon: number;
-    /** The path constraint's setup pose data. */
-    data: PathConstraintData;
-    /** The bones that will be modified by this path constraint. */
-    bones: Array<Bone>;
-    /** The slot whose path attachment will be used to constrained the bones. */
-    target: Slot;
-    /** The position along the path. */
-    position: number;
-    /** The spacing between bones. */
-    spacing: number;
-    /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
-    rotateMix: number;
-    /** A percentage (0-1) that controls the mix between the constrained and unconstrained translations. */
-    translateMix: number;
-    spaces: number[];
-    positions: number[];
-    world: number[];
-    curves: number[];
-    lengths: number[];
-    segments: number[];
-    active: boolean;
-    constructor(data: PathConstraintData, skeleton: Skeleton);
-    isActive(): boolean;
-    /** Applies the constraint to the constrained bones. */
-    apply(): void;
-    update(): void;
-    computeWorldPositions(path: PathAttachment, spacesCount: number, tangents: boolean, percentPosition: boolean, percentSpacing: boolean): number[];
-    addBeforePosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
-    addAfterPosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
-    addCurvePosition(p: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, out: Array<number>, o: number, tangents: boolean): void;
-}

package/types/spine-core/PathConstraintData.d.ts

@@ -1,52 +0,0 @@
-import { ConstraintData } from "./ConstraintData";
-import { BoneData } from "./BoneData";
-import { SlotData } from "./SlotData";
-/** Stores the setup pose for a {@link PathConstraint}.
- *
- * See [Path constraints](http://esotericsoftware.com/spine-path-constraints) in the Spine User Guide. */
-export declare class PathConstraintData extends ConstraintData {
-    /** The bones that will be modified by this path constraint. */
-    bones: BoneData[];
-    /** The slot whose path attachment will be used to constrained the bones. */
-    target: SlotData;
-    /** The mode for positioning the first bone on the path. */
-    positionMode: PositionMode;
-    /** The mode for positioning the bones after the first bone on the path. */
-    spacingMode: SpacingMode;
-    /** The mode for adjusting the rotation of the bones. */
-    rotateMode: RotateMode;
-    /** An offset added to the constrained bone rotation. */
-    offsetRotation: number;
-    /** The position along the path. */
-    position: number;
-    /** The spacing between bones. */
-    spacing: number;
-    /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
-    rotateMix: number;
-    /** A percentage (0-1) that controls the mix between the constrained and unconstrained translations. */
-    translateMix: number;
-    constructor(name: string);
-}
-/** Controls how the first bone is positioned along the path.
- *
- * See [Position mode](http://esotericsoftware.com/spine-path-constraints#Position-mode) in the Spine User Guide. */
-export declare enum PositionMode {
-    Fixed = 0,
-    Percent = 1
-}
-/** Controls how bones after the first bone are positioned along the path.
- *
- * [Spacing mode](http://esotericsoftware.com/spine-path-constraints#Spacing-mode) in the Spine User Guide. */
-export declare enum SpacingMode {
-    Length = 0,
-    Fixed = 1,
-    Percent = 2
-}
-/** Controls how bones are rotated, translated, and scaled to match the path.
- *
- * [Rotate mode](http://esotericsoftware.com/spine-path-constraints#Rotate-mod) in the Spine User Guide. */
-export declare enum RotateMode {
-    Tangent = 0,
-    Chain = 1,
-    ChainScale = 2
-}

package/types/spine-core/SharedAssetManager.d.ts

@@ -1,19 +0,0 @@
-import { Disposable, Map } from "./Utils";
-export declare class SharedAssetManager implements Disposable {
-    private pathPrefix;
-    private clientAssets;
-    private queuedAssets;
-    private rawAssets;
-    private errors;
-    constructor(pathPrefix?: string);
-    private queueAsset;
-    loadText(clientId: string, path: string): void;
-    loadJson(clientId: string, path: string): void;
-    loadTexture(clientId: string, textureLoader: (image: HTMLImageElement | ImageBitmap) => any, path: string): void;
-    get(clientId: string, path: string): any;
-    private updateClientAssets;
-    isLoadingComplete(clientId: string): boolean;
-    dispose(): void;
-    hasErrors(): boolean;
-    getErrors(): Map<string>;
-}

package/types/spine-core/Skeleton.d.ts

@@ -1,134 +0,0 @@
-import { SkeletonData } from "./SkeletonData";
-import { Bone } from "./Bone";
-import { Slot } from "./Slot";
-import { IkConstraint } from "./IkConstraint";
-import { TransformConstraint } from "./TransformConstraint";
-import { PathConstraint } from "./PathConstraint";
-import { Updatable } from "./Updatable";
-import { Skin } from "./Skin";
-import { Color, Vector2 } from "./Utils";
-import { Attachment } from "./attachments/Attachment";
-/** Stores the current pose for a skeleton.
- *
- * See [Instance objects](http://esotericsoftware.com/spine-runtime-architecture#Instance-objects) in the Spine Runtimes Guide. */
-export declare class Skeleton {
-    /** The skeleton's setup pose data. */
-    data: SkeletonData;
-    /** The skeleton's bones, sorted parent first. The root bone is always the first bone. */
-    bones: Array<Bone>;
-    /** The skeleton's slots. */
-    slots: Array<Slot>;
-    /** The skeleton's slots in the order they should be drawn. The returned array may be modified to change the draw order. */
-    drawOrder: Array<Slot>;
-    /** The skeleton's IK constraints. */
-    ikConstraints: Array<IkConstraint>;
-    /** The skeleton's transform constraints. */
-    transformConstraints: Array<TransformConstraint>;
-    /** The skeleton's path constraints. */
-    pathConstraints: Array<PathConstraint>;
-    /** The list of bones and constraints, sorted in the order they should be updated, as computed by {@link #updateCache()}. */
-    _updateCache: Updatable[];
-    updateCacheReset: Updatable[];
-    /** The skeleton's current skin. May be null. */
-    skin: Skin;
-    /** The color to tint all the skeleton's attachments. */
-    color: Color;
-    /** Returns the skeleton's time. This can be used for tracking, such as with Slot {@link Slot#attachmentTime}.
-     * <p>
-     * See {@link #update()}. */
-    time: number;
-    /** Scales the entire skeleton on the X axis. This affects all bones, even if the bone's transform mode disallows scale
-    * inheritance. */
-    scaleX: number;
-    /** Scales the entire skeleton on the Y axis. This affects all bones, even if the bone's transform mode disallows scale
-    * inheritance. */
-    scaleY: number;
-    /** Sets the skeleton X position, which is added to the root bone worldX position. */
-    x: number;
-    /** Sets the skeleton Y position, which is added to the root bone worldY position. */
-    y: number;
-    constructor(data: SkeletonData);
-    /** Caches information about bones and constraints. Must be called if the {@link #getSkin()} is modified or if bones,
-     * constraints, or weighted path attachments are added or removed. */
-    updateCache(): void;
-    sortIkConstraint(constraint: IkConstraint): void;
-    sortPathConstraint(constraint: PathConstraint): void;
-    sortTransformConstraint(constraint: TransformConstraint): void;
-    sortPathConstraintAttachment(skin: Skin, slotIndex: number, slotBone: Bone): void;
-    sortPathConstraintAttachmentWith(attachment: Attachment, slotBone: Bone): void;
-    sortBone(bone: Bone): void;
-    sortReset(bones: Array<Bone>): void;
-    /** Updates the world transform for each bone and applies all constraints.
-     *
-     * See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
-     * Runtimes Guide. */
-    updateWorldTransform(): void;
-    /** Sets the bones, constraints, and slots to their setup pose values. */
-    setToSetupPose(): void;
-    /** Sets the bones and constraints to their setup pose values. */
-    setBonesToSetupPose(): void;
-    /** Sets the slots and draw order to their setup pose values. */
-    setSlotsToSetupPose(): void;
-    /** @returns May return null. */
-    getRootBone(): Bone;
-    /** @returns May be null. */
-    findBone(boneName: string): Bone;
-    /** @returns -1 if the bone was not found. */
-    findBoneIndex(boneName: string): number;
-    /** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it
-     * repeatedly.
-     * @returns May be null. */
-    findSlot(slotName: string): Slot;
-    /** @returns -1 if the bone was not found. */
-    findSlotIndex(slotName: string): number;
-    /** Sets a skin by name.
-     *
-     * See {@link #setSkin()}. */
-    setSkinByName(skinName: string): void;
-    /** Sets the skin used to look up attachments before looking in the {@link SkeletonData#defaultSkin default skin}. If the
-     * skin is changed, {@link #updateCache()} is called.
-     *
-     * Attachments from the new skin are attached if the corresponding attachment from the old skin was attached. If there was no
-     * old skin, each slot's setup mode attachment is attached from the new skin.
-     *
-     * After changing the skin, the visible attachments can be reset to those attached in the setup pose by calling
-     * {@link #setSlotsToSetupPose()}. Also, often {@link AnimationState#apply()} is called before the next time the
-     * skeleton is rendered to allow any attachment keys in the current animation(s) to hide or show attachments from the new skin.
-     * @param newSkin May be null. */
-    setSkin(newSkin: Skin): void;
-    /** Finds an attachment by looking in the {@link #skin} and {@link SkeletonData#defaultSkin} using the slot name and attachment
-     * name.
-     *
-     * See {@link #getAttachment()}.
-     * @returns May be null. */
-    getAttachmentByName(slotName: string, attachmentName: string): Attachment;
-    /** Finds an attachment by looking in the {@link #skin} and {@link SkeletonData#defaultSkin} using the slot index and
-     * attachment name. First the skin is checked and if the attachment was not found, the default skin is checked.
-     *
-     * See [Runtime skins](http://esotericsoftware.com/spine-runtime-skins) in the Spine Runtimes Guide.
-     * @returns May be null. */
-    getAttachment(slotIndex: number, attachmentName: string): Attachment;
-    /** A convenience method to set an attachment by finding the slot with {@link #findSlot()}, finding the attachment with
-     * {@link #getAttachment()}, then setting the slot's {@link Slot#attachment}.
-     * @param attachmentName May be null to clear the slot's attachment. */
-    setAttachment(slotName: string, attachmentName: string): void;
-    /** Finds an IK constraint by comparing each IK constraint's name. It is more efficient to cache the results of this method
-     * than to call it repeatedly.
-     * @return May be null. */
-    findIkConstraint(constraintName: string): IkConstraint;
-    /** Finds a transform constraint by comparing each transform constraint's name. It is more efficient to cache the results of
-     * this method than to call it repeatedly.
-     * @return May be null. */
-    findTransformConstraint(constraintName: string): TransformConstraint;
-    /** Finds a path constraint by comparing each path constraint's name. It is more efficient to cache the results of this method
-     * than to call it repeatedly.
-     * @return May be null. */
-    findPathConstraint(constraintName: string): PathConstraint;
-    /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the current pose.
-     * @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.
-     * @param size An output value, the width and height of the AABB.
-     * @param temp Working memory to temporarily store attachments' computed world vertices. */
-    getBounds(offset: Vector2, size: Vector2, temp?: Array<number>): void;
-    /** Increments the skeleton's {@link #time}. */
-    update(delta: number): void;
-}

package/types/spine-core/SkeletonBinary.d.ts

@@ -1,49 +0,0 @@
-import { TransformMode } from "./BoneData";
-import { PositionMode, SpacingMode, RotateMode } from "./PathConstraintData";
-import { BlendMode } from "./BlendMode";
-import { AttachmentLoader } from "./attachments/AttachmentLoader";
-import { SkeletonData } from "./SkeletonData";
-import { CurveTimeline } from "./Animation";
-/** Loads skeleton data in the Spine binary format.
- *
- * See [Spine binary format](http://esotericsoftware.com/spine-binary-format) and
- * [JSON and binary data](http://esotericsoftware.com/spine-loading-skeleton-data#JSON-and-binary-data) in the Spine
- * Runtimes Guide. */
-export declare class SkeletonBinary {
-    static AttachmentTypeValues: number[];
-    static TransformModeValues: TransformMode[];
-    static PositionModeValues: PositionMode[];
-    static SpacingModeValues: SpacingMode[];
-    static RotateModeValues: RotateMode[];
-    static BlendModeValues: BlendMode[];
-    static BONE_ROTATE: number;
-    static BONE_TRANSLATE: number;
-    static BONE_SCALE: number;
-    static BONE_SHEAR: number;
-    static SLOT_ATTACHMENT: number;
-    static SLOT_COLOR: number;
-    static SLOT_TWO_COLOR: number;
-    static PATH_POSITION: number;
-    static PATH_SPACING: number;
-    static PATH_MIX: number;
-    static CURVE_LINEAR: number;
-    static CURVE_STEPPED: number;
-    static CURVE_BEZIER: number;
-    /** Scales bone positions, image sizes, and translations as they are loaded. This allows different size images to be used at
-     * runtime than were used in Spine.
-     *
-     * See [Scaling](http://esotericsoftware.com/spine-loading-skeleton-data#Scaling) in the Spine Runtimes Guide. */
-    scale: number;
-    attachmentLoader: AttachmentLoader;
-    private linkedMeshes;
-    constructor(attachmentLoader: AttachmentLoader);
-    readSkeletonData(binary: Uint8Array): SkeletonData;
-    private readSkin;
-    private readAttachment;
-    private readVertices;
-    private readFloatArray;
-    private readShortArray;
-    private readAnimation;
-    private readCurve;
-    setCurve(timeline: CurveTimeline, frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void;
-}

package/types/spine-core/SkeletonBounds.d.ts

@@ -1,48 +0,0 @@
-import { BoundingBoxAttachment } from "./attachments/BoundingBoxAttachment";
-import { Skeleton } from "./Skeleton";
-/** Collects each visible {@link BoundingBoxAttachment} and computes the world vertices for its polygon. The polygon vertices are
- * provided along with convenience methods for doing hit detection. */
-export declare class SkeletonBounds {
-    /** The left edge of the axis aligned bounding box. */
-    minX: number;
-    /** The bottom edge of the axis aligned bounding box. */
-    minY: number;
-    /** The right edge of the axis aligned bounding box. */
-    maxX: number;
-    /** The top edge of the axis aligned bounding box. */
-    maxY: number;
-    /** The visible bounding boxes. */
-    boundingBoxes: BoundingBoxAttachment[];
-    /** The world vertices for the bounding box polygons. */
-    polygons: ArrayLike<number>[];
-    private polygonPool;
-    /** Clears any previous polygons, finds all visible bounding box attachments, and computes the world vertices for each bounding
-     * box's polygon.
-     * @param updateAabb If true, the axis aligned bounding box containing all the polygons is computed. If false, the
-     *           SkeletonBounds AABB methods will always return true. */
-    update(skeleton: Skeleton, updateAabb: boolean): void;
-    aabbCompute(): void;
-    /** Returns true if the axis aligned bounding box contains the point. */
-    aabbContainsPoint(x: number, y: number): boolean;
-    /** Returns true if the axis aligned bounding box intersects the line segment. */
-    aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean;
-    /** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
-    aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean;
-    /** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
-     * efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */
-    containsPoint(x: number, y: number): BoundingBoxAttachment;
-    /** Returns true if the polygon contains the point. */
-    containsPointPolygon(polygon: ArrayLike<number>, x: number, y: number): boolean;
-    /** Returns the first bounding box attachment that contains any part of the line segment, or null. When doing many checks, it
-     * is usually more efficient to only call this method if {@link #aabbIntersectsSegment()} returns
-     * true. */
-    intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment;
-    /** Returns true if the polygon contains any part of the line segment. */
-    intersectsSegmentPolygon(polygon: ArrayLike<number>, x1: number, y1: number, x2: number, y2: number): boolean;
-    /** Returns the polygon for the specified bounding box, or null. */
-    getPolygon(boundingBox: BoundingBoxAttachment): ArrayLike<number>;
-    /** The width of the axis aligned bounding box. */
-    getWidth(): number;
-    /** The height of the axis aligned bounding box. */
-    getHeight(): number;
-}

package/types/spine-core/SkeletonClipping.d.ts

@@ -1,22 +0,0 @@
-import { ClippingAttachment } from "./attachments/ClippingAttachment";
-import { Slot } from "./Slot";
-import { Color, ArrayLike } from "./Utils";
-export declare class SkeletonClipping {
-    private triangulator;
-    private clippingPolygon;
-    private clipOutput;
-    clippedVertices: number[];
-    clippedTriangles: number[];
-    private scratch;
-    private clipAttachment;
-    private clippingPolygons;
-    clipStart(slot: Slot, clip: ClippingAttachment): number;
-    clipEndWithSlot(slot: Slot): void;
-    clipEnd(): void;
-    isClipping(): boolean;
-    clipTriangles(vertices: ArrayLike<number>, verticesLength: number, triangles: ArrayLike<number>, trianglesLength: number, uvs: ArrayLike<number>, light: Color, dark: Color, twoColor: boolean): void;
-    /** Clips the input triangle against the convex, clockwise clipping area. If the triangle lies entirely within the clipping
-     * area, false is returned. The clipping area must duplicate the first vertex at the end of the vertices list. */
-    clip(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, clippingArea: Array<number>, output: Array<number>): boolean;
-    static makeClockwise(polygon: ArrayLike<number>): void;
-}

package/types/spine-core/SkeletonData.d.ts

@@ -1,89 +0,0 @@
-import { BoneData } from "./BoneData";
-import { SlotData } from "./SlotData";
-import { Skin } from "./Skin";
-import { EventData } from "./EventData";
-import { IkConstraintData } from "./IkConstraintData";
-import { TransformConstraintData } from "./TransformConstraintData";
-import { PathConstraintData } from "./PathConstraintData";
-import { Animation } from "./Animation";
-/** Stores the setup pose and all of the stateless data for a skeleton.
- *
- * See [Data objects](http://esotericsoftware.com/spine-runtime-architecture#Data-objects) in the Spine Runtimes
- * Guide. */
-export declare class SkeletonData {
-    /** The skeleton's name, which by default is the name of the skeleton data file, if possible. May be null. */
-    name: string;
-    /** The skeleton's bones, sorted parent first. The root bone is always the first bone. */
-    bones: BoneData[];
-    /** The skeleton's slots. */
-    slots: SlotData[];
-    skins: Skin[];
-    /** The skeleton's default skin. By default this skin contains all attachments that were not in a skin in Spine.
-     *
-     * See {@link Skeleton#getAttachmentByName()}.
-     * May be null. */
-    defaultSkin: Skin;
-    /** The skeleton's events. */
-    events: EventData[];
-    /** The skeleton's animations. */
-    animations: Animation[];
-    /** The skeleton's IK constraints. */
-    ikConstraints: IkConstraintData[];
-    /** The skeleton's transform constraints. */
-    transformConstraints: TransformConstraintData[];
-    /** The skeleton's path constraints. */
-    pathConstraints: PathConstraintData[];
-    /** The X coordinate of the skeleton's axis aligned bounding box in the setup pose. */
-    x: number;
-    /** The Y coordinate of the skeleton's axis aligned bounding box in the setup pose. */
-    y: number;
-    /** The width of the skeleton's axis aligned bounding box in the setup pose. */
-    width: number;
-    /** The height of the skeleton's axis aligned bounding box in the setup pose. */
-    height: number;
-    /** The Spine version used to export the skeleton data, or null. */
-    version: string;
-    /** The skeleton data hash. This value will change if any of the skeleton data has changed. May be null. */
-    hash: string;
-    /** The dopesheet FPS in Spine. Available only when nonessential data was exported. */
-    fps: number;
-    /** The path to the images directory as defined in Spine. Available only when nonessential data was exported. May be null. */
-    imagesPath: string;
-    /** The path to the audio directory as defined in Spine. Available only when nonessential data was exported. May be null. */
-    audioPath: string;
-    /** Finds a bone by comparing each bone's name. It is more efficient to cache the results of this method than to call it
-     * multiple times.
-     * @returns May be null. */
-    findBone(boneName: string): BoneData;
-    findBoneIndex(boneName: string): number;
-    /** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it
-     * multiple times.
-     * @returns May be null. */
-    findSlot(slotName: string): SlotData;
-    findSlotIndex(slotName: string): number;
-    /** Finds a skin by comparing each skin's name. It is more efficient to cache the results of this method than to call it
-     * multiple times.
-     * @returns May be null. */
-    findSkin(skinName: string): Skin;
-    /** Finds an event by comparing each events's name. It is more efficient to cache the results of this method than to call it
-     * multiple times.
-     * @returns May be null. */
-    findEvent(eventDataName: string): EventData;
-    /** Finds an animation by comparing each animation's name. It is more efficient to cache the results of this method than to
-     * call it multiple times.
-     * @returns May be null. */
-    findAnimation(animationName: string): Animation;
-    /** Finds an IK constraint by comparing each IK constraint's name. It is more efficient to cache the results of this method
-     * than to call it multiple times.
-     * @return May be null. */
-    findIkConstraint(constraintName: string): IkConstraintData;
-    /** Finds a transform constraint by comparing each transform constraint's name. It is more efficient to cache the results of
-     * this method than to call it multiple times.
-     * @return May be null. */
-    findTransformConstraint(constraintName: string): TransformConstraintData;
-    /** Finds a path constraint by comparing each path constraint's name. It is more efficient to cache the results of this method
-     * than to call it multiple times.
-     * @return May be null. */
-    findPathConstraint(constraintName: string): PathConstraintData;
-    findPathConstraintIndex(pathConstraintName: string): number;
-}

package/types/spine-core/SkeletonJson.d.ts

@@ -1,34 +0,0 @@
-import { AttachmentLoader } from "./attachments/AttachmentLoader";
-import { SkeletonData } from "./SkeletonData";
-import { TransformMode } from "./BoneData";
-import { PositionMode, SpacingMode, RotateMode } from "./PathConstraintData";
-import { Skin } from "./Skin";
-import { VertexAttachment, Attachment } from "./attachments/Attachment";
-import { CurveTimeline } from "./Animation";
-import { BlendMode } from "./BlendMode";
-/** Loads skeleton data in the Spine JSON format.
- *
- * See [Spine JSON format](http://esotericsoftware.com/spine-json-format) and
- * [JSON and binary data](http://esotericsoftware.com/spine-loading-skeleton-data#JSON-and-binary-data) in the Spine
- * Runtimes Guide. */
-export declare class SkeletonJson {
-    attachmentLoader: AttachmentLoader;
-    /** Scales bone positions, image sizes, and translations as they are loaded. This allows different size images to be used at
-     * runtime than were used in Spine.
-     *
-     * See [Scaling](http://esotericsoftware.com/spine-loading-skeleton-data#Scaling) in the Spine Runtimes Guide. */
-    scale: number;
-    private linkedMeshes;
-    constructor(attachmentLoader: AttachmentLoader);
-    readSkeletonData(json: string | any): SkeletonData;
-    readAttachment(map: any, skin: Skin, slotIndex: number, name: string, skeletonData: SkeletonData): Attachment;
-    readVertices(map: any, attachment: VertexAttachment, verticesLength: number): void;
-    readAnimation(map: any, name: string, skeletonData: SkeletonData): void;
-    readCurve(map: any, timeline: CurveTimeline, frameIndex: number): void;
-    getValue(map: any, prop: string, defaultValue: any): any;
-    static blendModeFromString(str: string): BlendMode;
-    static positionModeFromString(str: string): PositionMode;
-    static spacingModeFromString(str: string): SpacingMode;
-    static rotateModeFromString(str: string): RotateMode;
-    static transformModeFromString(str: string): TransformMode;
-}

package/types/spine-core/Skin.d.ts

@@ -1,43 +0,0 @@
-import { Attachment } from "./attachments/Attachment";
-import { BoneData } from "./BoneData";
-import { ConstraintData } from "./ConstraintData";
-import { Skeleton } from "./Skeleton";
-import { Map } from './Utils';
-/** Stores an entry in the skin consisting of the slot index, name, and attachment **/
-export declare class SkinEntry {
-    slotIndex: number;
-    name: string;
-    attachment: Attachment;
-    constructor(slotIndex: number, name: string, attachment: Attachment);
-}
-/** Stores attachments by slot index and attachment name.
- *
- * See SkeletonData {@link SkeletonData#defaultSkin}, Skeleton {@link Skeleton#skin}, and
- * [Runtime skins](http://esotericsoftware.com/spine-runtime-skins) in the Spine Runtimes Guide. */
-export declare class Skin {
-    /** The skin's name, which is unique across all skins in the skeleton. */
-    name: string;
-    attachments: Map<Attachment>[];
-    bones: BoneData[];
-    constraints: ConstraintData[];
-    constructor(name: string);
-    /** Adds an attachment to the skin for the specified slot index and name. */
-    setAttachment(slotIndex: number, name: string, attachment: Attachment): void;
-    /** Adds all attachments, bones, and constraints from the specified skin to this skin. */
-    addSkin(skin: Skin): void;
-    /** Adds all bones and constraints and copies of all attachments from the specified skin to this skin. Mesh attachments are not
-     * copied, instead a new linked mesh is created. The attachment copies can be modified without affecting the originals. */
-    copySkin(skin: Skin): void;
-    /** Returns the attachment for the specified slot index and name, or null. */
-    getAttachment(slotIndex: number, name: string): Attachment;
-    /** Removes the attachment in the skin for the specified slot index and name, if any. */
-    removeAttachment(slotIndex: number, name: string): void;
-    /** Returns all attachments in this skin. */
-    getAttachments(): Array<SkinEntry>;
-    /** Returns all attachments in this skin for the specified slot index. */
-    getAttachmentsForSlot(slotIndex: number, attachments: Array<SkinEntry>): void;
-    /** Clears all attachments, bones, and constraints. */
-    clear(): void;
-    /** Attach each attachment in this skin if the corresponding attachment in the old skin is currently attached. */
-    attachAll(skeleton: Skeleton, oldSkin: Skin): void;
-}

package/types/spine-core/Slot.d.ts

@@ -1,42 +0,0 @@
-import { SlotData } from "./SlotData";
-import { Bone } from "./Bone";
-import { Color } from "./Utils";
-import { Attachment } from "./attachments/Attachment";
-import { Skeleton } from "./Skeleton";
-/** Stores a slot's current pose. Slots organize attachments for {@link Skeleton#drawOrder} purposes and provide a place to store
- * state for an attachment. State cannot be stored in an attachment itself because attachments are stateless and may be shared
- * across multiple skeletons. */
-export declare class Slot {
-    /** The slot's setup pose data. */
-    data: SlotData;
-    /** The bone this slot belongs to. */
-    bone: Bone;
-    /** The color used to tint the slot's attachment. If {@link #getDarkColor()} is set, this is used as the light color for two
-     * color tinting. */
-    color: Color;
-    /** The dark color used to tint the slot's attachment for two color tinting, or null if two color tinting is not used. The dark
-     * color's alpha is not used. */
-    darkColor: Color;
-    attachment: Attachment;
-    private attachmentTime;
-    attachmentState: number;
-    /** Values to deform the slot's attachment. For an unweighted mesh, the entries are local positions for each vertex. For a
-     * weighted mesh, the entries are an offset for each vertex which will be added to the mesh's local vertex positions.
-     *
-     * See {@link VertexAttachment#computeWorldVertices()} and {@link DeformTimeline}. */
-    deform: number[];
-    constructor(data: SlotData, bone: Bone);
-    /** The skeleton this slot belongs to. */
-    getSkeleton(): Skeleton;
-    /** The current attachment for the slot, or null if the slot has no attachment. */
-    getAttachment(): Attachment;
-    /** Sets the slot's attachment and, if the attachment changed, resets {@link #attachmentTime} and clears {@link #deform}.
-     * @param attachment May be null. */
-    setAttachment(attachment: Attachment): void;
-    setAttachmentTime(time: number): void;
-    /** The time that has elapsed since the last time the attachment was set or cleared. Relies on Skeleton
-     * {@link Skeleton#time}. */
-    getAttachmentTime(): number;
-    /** Sets this slot to the setup pose. */
-    setToSetupPose(): void;
-}