simple-pixi-spine 0.1.0

package/dist/types/packages/runtime-4.2/src/core/SkeletonData.d.ts

@@ -0,0 +1,101 @@
+import { Animation } from './Animation';
+import { BoneData } from './BoneData.js';
+import { EventData } from './EventData.js';
+import { IkConstraintData } from './IkConstraintData.js';
+import { PathConstraintData } from './PathConstraintData.js';
+import { PhysicsConstraintData } from './PhysicsConstraintData.js';
+import { Skin } from './Skin.js';
+import { SlotData } from './SlotData.js';
+import { TransformConstraintData } from './TransformConstraintData.js';
+import type { ISkeletonData } from '@pixi-spine/base';
+/** Stores the setup pose and all of the stateless data for a skeleton.
+ * @public
+ * See [Data objects](http://esotericsoftware.com/spine-runtime-architecture#Data-objects) in the Spine Runtimes
+ * Guide. */
+export declare class SkeletonData implements ISkeletonData<BoneData, SlotData, Skin, Animation, EventData, IkConstraintData, TransformConstraintData, PathConstraintData> {
+    /** The skeleton's name, which by default is the name of the skeleton data file, if possible. May be null. */
+    name: string | null;
+    /** The skeleton's bones, sorted parent first. The root bone is always the first bone. */
+    bones: BoneData[];
+    /** The skeleton's slots in the setup pose draw order. */
+    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 | null;
+    /** 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 skeleton's physics constraints. */
+    physicsConstraints: PhysicsConstraintData[];
+    /** 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;
+    /** Baseline scale factor for applying distance-dependent effects on non-scalable properties, such as angle or scale. Default
+     * is 100. */
+    referenceScale: number;
+    /** The Spine version used to export the skeleton data, or null. */
+    version: string | null;
+    /** The skeleton data hash. This value will change if any of the skeleton data has changed. May be null. */
+    hash: string | null;
+    /** 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 | null;
+    /** The path to the audio directory as defined in Spine. Available only when nonessential data was exported. May be null. */
+    audioPath: string | null;
+    /** 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;
+    /** removed from spine-ts runtime **/
+    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;
+    /** removed from spine-ts runtime **/
+    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;
+    /** Finds a physics constraint by comparing each physics constraint's name. It is more efficient to cache the results of this method
+     * than to call it multiple times.
+     * @return May be null. */
+    findPhysicsConstraint(constraintName: string): PhysicsConstraintData;
+}

package/dist/types/packages/runtime-4.2/src/core/SkeletonJson.d.ts

@@ -0,0 +1,23 @@
+import { Attachment, AttachmentLoader, Sequence, VertexAttachment } from './attachments';
+import { SkeletonData } from './SkeletonData.js';
+import { Skin } from './Skin.js';
+/** Loads skeleton data in the Spine JSON format.
+ * @public
+ * 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 | null;
+    readSequence(map: any): Sequence;
+    readVertices(map: any, attachment: VertexAttachment, verticesLength: number): void;
+    readAnimation(map: any, name: string, skeletonData: SkeletonData): void;
+}

package/dist/types/packages/runtime-4.2/src/core/Skin.d.ts

@@ -0,0 +1,49 @@
+import { Attachment } from './attachments/Attachment.js';
+import { BoneData } from './BoneData.js';
+import { ConstraintData } from './ConstraintData.js';
+import { Skeleton } from './Skeleton.js';
+import { type ISkin, type StringMap, Color } from '@pixi-spine/base';
+/** Stores an entry in the skin consisting of the slot index, name, and attachment
+ * @public
+ * */
+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.
+ * @public
+ * */
+export declare class Skin implements ISkin {
+    /** The skin's name, which is unique across all skins in the skeleton. */
+    name: string;
+    attachments: StringMap<Attachment>[];
+    bones: BoneData[];
+    constraints: ConstraintData[];
+    /** The color of the skin as it was in Spine, or a default color if nonessential data was not exported. */
+    color: Color;
+    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 | null;
+    /** 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/dist/types/packages/runtime-4.2/src/core/Slot.d.ts

@@ -0,0 +1,44 @@
+import { Attachment } from './attachments/Attachment.js';
+import { Bone } from './Bone.js';
+import { Skeleton } from './Skeleton.js';
+import { SlotData } from './SlotData.js';
+import { Color, ISlot } from '@pixi-spine/base';
+/** 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.
+ * @public
+ * */
+export declare class Slot implements ISlot {
+    blendMode: number;
+    /** 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 | null;
+    attachment: Attachment | null;
+    attachmentState: number;
+    /** The index of the texture region to display when the slot's attachment has a {@link Sequence}. -1 represents the
+     * {@link Sequence#getSetupIndex()}. */
+    sequenceIndex: 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 | null;
+    /** Sets the slot's attachment and, if the attachment changed, resets {@link #sequenceIndex} and clears the {@link #deform}.
+     * The deform is not cleared if the old attachment has the same {@link VertexAttachment#getTimelineAttachment()} as the
+     * specified attachment. */
+    setAttachment(attachment: Attachment | null): void;
+    /** Sets this slot to the setup pose. */
+    setToSetupPose(): void;
+}

package/dist/types/packages/runtime-4.2/src/core/SlotData.d.ts

@@ -0,0 +1,28 @@
+import { BLEND_MODES } from '@pixi-spine/base';
+import { BoneData } from './BoneData.js';
+import { Color } from '@pixi-spine/base';
+import type { ISlotData } from '@pixi-spine/base';
+/** Stores the setup pose for a {@link Slot}.
+ * @public
+ * */
+export declare class SlotData implements ISlotData {
+    /** The index of the slot in {@link Skeleton#getSlots()}. */
+    index: number;
+    /** The name of the slot, which is unique across all slots in the skeleton. */
+    name: string;
+    /** The bone this slot belongs to. */
+    boneData: BoneData;
+    /** 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 | null;
+    /** The name of the attachment that is visible for this slot in the setup pose, or null if no attachment is visible. */
+    attachmentName: string | null;
+    /** The blend mode for drawing the slot's attachment. */
+    blendMode: BLEND_MODES;
+    /** False if the slot was hidden in Spine and nonessential data was exported. Does not affect runtime rendering. */
+    visible: boolean;
+    constructor(index: number, name: string, boneData: BoneData);
+}

package/dist/types/packages/runtime-4.2/src/core/TransformConstraint.d.ts

@@ -0,0 +1,33 @@
+import { Bone } from './Bone.js';
+import { Skeleton } from './Skeleton.js';
+import { TransformConstraintData } from './TransformConstraintData.js';
+import { Updatable } from './Updatable.js';
+import { Physics, Vector2 } from '@pixi-spine/base';
+/** Stores the current pose for a transform constraint. A transform constraint adjusts the world transform of the constrained
+ * bones to match that of the target bone.
+ * @public
+ * See [Transform constraints](http://esotericsoftware.com/spine-transform-constraints) in the Spine User Guide. */
+export declare class TransformConstraint implements Updatable {
+    /** The transform constraint's setup pose data. */
+    data: TransformConstraintData;
+    /** The bones that will be modified by this transform constraint. */
+    bones: Array<Bone>;
+    /** The target bone whose world transform will be copied to the constrained bones. */
+    target: Bone;
+    mixRotate: number;
+    mixX: number;
+    mixY: number;
+    mixScaleX: number;
+    mixScaleY: number;
+    mixShearY: number;
+    temp: Vector2;
+    active: boolean;
+    constructor(data: TransformConstraintData, skeleton: Skeleton);
+    isActive(): boolean;
+    setToSetupPose(): void;
+    update(physics: Physics): void;
+    applyAbsoluteWorld(): void;
+    applyRelativeWorld(): void;
+    applyAbsoluteLocal(): void;
+    applyRelativeLocal(): void;
+}

package/dist/types/packages/runtime-4.2/src/core/TransformConstraintData.d.ts

@@ -0,0 +1,34 @@
+import { BoneData } from './BoneData.js';
+import { ConstraintData } from './ConstraintData.js';
+/** Stores the setup pose for a {@link TransformConstraint}.
+ * @public
+ * See [Transform constraints](http://esotericsoftware.com/spine-transform-constraints) in the Spine User Guide. */
+export declare class TransformConstraintData extends ConstraintData {
+    /** The bones that will be modified by this transform constraint. */
+    bones: BoneData[];
+    /** The target bone whose world transform will be copied to the constrained bones. */
+    private _target;
+    set target(boneData: BoneData);
+    get target(): BoneData;
+    mixRotate: number;
+    mixX: number;
+    mixY: number;
+    mixScaleX: number;
+    mixScaleY: number;
+    mixShearY: number;
+    /** An offset added to the constrained bone rotation. */
+    offsetRotation: number;
+    /** An offset added to the constrained bone X translation. */
+    offsetX: number;
+    /** An offset added to the constrained bone Y translation. */
+    offsetY: number;
+    /** An offset added to the constrained bone scaleX. */
+    offsetScaleX: number;
+    /** An offset added to the constrained bone scaleY. */
+    offsetScaleY: number;
+    /** An offset added to the constrained bone shearY. */
+    offsetShearY: number;
+    relative: boolean;
+    local: boolean;
+    constructor(name: string);
+}

package/dist/types/packages/runtime-4.2/src/core/Triangulator.d.ts

@@ -0,0 +1,18 @@
+import { NumberArrayLike } from '@pixi-spine/base';
+/**
+ * @public
+ * */
+export declare class Triangulator {
+    private convexPolygons;
+    private convexPolygonsIndices;
+    private indicesArray;
+    private isConcaveArray;
+    private triangles;
+    private polygonPool;
+    private polygonIndicesPool;
+    triangulate(verticesArray: NumberArrayLike): Array<number>;
+    decompose(verticesArray: Array<number>, triangles: Array<number>): Array<Array<number>>;
+    private static isConcave;
+    private static positiveArea;
+    private static winding;
+}

package/dist/types/packages/runtime-4.2/src/core/Updatable.d.ts

@@ -0,0 +1,16 @@
+import { Physics } from '@pixi-spine/base';
+/** The interface for items updated by {@link Skeleton#updateWorldTransform()}.
+ * @public
+ * */
+export interface Updatable {
+    /** @param physics Determines how physics and other non-deterministic updates are applied. */
+    update(physics: Physics): void;
+    /** Returns false when this item won't be updated by
+     * {@link Skeleton#updateWorldTransform()} because a skin is required and the
+     * {@link Skeleton#getSkin() active skin} does not contain this item.
+     * @see Skin#getBones()
+     * @see Skin#getConstraints()
+     * @see BoneData#getSkinRequired()
+     * @see ConstraintData#getSkinRequired() */
+    isActive(): boolean;
+}

package/dist/types/packages/runtime-4.2/src/core/attachments/Attachment.d.ts

@@ -0,0 +1,49 @@
+import { Slot } from '../Slot.js';
+import { type IAttachment, AttachmentType, NumberArrayLike } from '@pixi-spine/base';
+/** The base class for all attachments.
+ * @public
+ * */
+export declare abstract class Attachment implements IAttachment {
+    name: string;
+    type: AttachmentType;
+    constructor(name: string);
+    abstract copy(): Attachment;
+}
+/** Base class for an attachment with vertices that are transformed by one or more bones and can be deformed by a slot's
+ * @public
+ * {@link Slot#deform}. */
+export declare abstract class VertexAttachment extends Attachment {
+    private static nextID;
+    /** The unique ID for this attachment. */
+    id: number;
+    /** The bones which affect the {@link #getVertices()}. The array entries are, for each vertex, the number of bones affecting
+     * the vertex followed by that many bone indices, which is the index of the bone in {@link Skeleton#bones}. Will be null
+     * if this attachment has no weights. */
+    bones: Array<number> | null;
+    /** The vertex positions in the bone's coordinate system. For a non-weighted attachment, the values are `x,y`
+     * entries for each vertex. For a weighted attachment, the values are `x,y,weight` entries for each bone affecting
+     * each vertex. */
+    vertices: NumberArrayLike;
+    /** The maximum number of world vertex values that can be output by
+     * {@link #computeWorldVertices()} using the `count` parameter. */
+    worldVerticesLength: number;
+    /** Timelines for the timeline attachment are also applied to this attachment.
+     * May be null if no attachment-specific timelines should be applied. */
+    timelineAttachment: Attachment;
+    constructor(name: string);
+    computeWorldVerticesOld(slot: Slot, worldVertices: ArrayLike<number>): void;
+    /** Transforms the attachment's local {@link #vertices} to world coordinates. If the slot's {@link Slot#deform} is
+     * not empty, it is used to deform the vertices.
+     *
+     * See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
+     * Runtimes Guide.
+     * @param start The index of the first {@link #vertices} value to transform. Each vertex has 2 values, x and y.
+     * @param count The number of world vertex values to output. Must be <= {@link #worldVerticesLength} - `start`.
+     * @param worldVertices The output world vertices. Must have a length >= `offset` + `count` *
+     *           `stride` / 2.
+     * @param offset The `worldVertices` index to begin writing values.
+     * @param stride The number of `worldVertices` entries between the value pairs written. */
+    computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: NumberArrayLike, offset: number, stride: number): void;
+    /** Does not copy id (generated) or name (set on construction). **/
+    copyTo(attachment: VertexAttachment): void;
+}

package/dist/types/packages/runtime-4.2/src/core/attachments/AttachmentLoader.d.ts

@@ -0,0 +1,27 @@
+import { Skin } from '../Skin.js';
+import { BoundingBoxAttachment } from './BoundingBoxAttachment.js';
+import { ClippingAttachment } from './ClippingAttachment.js';
+import { MeshAttachment } from './MeshAttachment.js';
+import { PathAttachment } from './PathAttachment.js';
+import { PointAttachment } from './PointAttachment.js';
+import { RegionAttachment } from './RegionAttachment.js';
+import { Sequence } from './Sequence.js';
+/** The interface which can be implemented to customize creating and populating attachments.
+ * See [Loading skeleton data](http://esotericsoftware.com/spine-loading-skeleton-data#AttachmentLoader) in the Spine
+ * Runtimes Guide.
+ * @public
+ * */
+export interface AttachmentLoader {
+    /** @return May be null to not load an attachment. */
+    newRegionAttachment(skin: Skin, name: string, path: string, sequence: Sequence | null): RegionAttachment;
+    /** @return May be null to not load an attachment. */
+    newMeshAttachment(skin: Skin, name: string, path: string, sequence: Sequence | null): MeshAttachment;
+    /** @return May be null to not load an attachment. */
+    newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
+    /** @return May be null to not load an attachment */
+    newPathAttachment(skin: Skin, name: string): PathAttachment;
+    /** @return May be null to not load an attachment */
+    newPointAttachment(skin: Skin, name: string): PointAttachment;
+    /** @return May be null to not load an attachment */
+    newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
+}

package/dist/types/packages/runtime-4.2/src/core/attachments/BoundingBoxAttachment.d.ts

@@ -0,0 +1,12 @@
+import { Attachment, VertexAttachment } from './Attachment.js';
+import { Color } from '@pixi-spine/base';
+/** An attachment with vertices that make up a polygon. Can be used for hit detection, creating physics bodies, spawning particle
+ * effects, and more.
+ * @public
+ * See {@link SkeletonBounds} and [Bounding Boxes](http://esotericsoftware.com/spine-bounding-boxes) in the Spine User
+ * Guide. */
+export declare class BoundingBoxAttachment extends VertexAttachment {
+    color: Color;
+    constructor(name: string);
+    copy(): Attachment;
+}

package/dist/types/packages/runtime-4.2/src/core/attachments/ClippingAttachment.d.ts

@@ -0,0 +1,16 @@
+import { SlotData } from '../SlotData.js';
+import { Attachment, VertexAttachment } from './Attachment.js';
+import { Color } from '@pixi-spine/base';
+/** An attachment with vertices that make up a polygon used for clipping the rendering of other attachments.
+ * @public
+ * */
+export declare class ClippingAttachment extends VertexAttachment {
+    /** Clipping is performed between the clipping polygon's slot and the end slot. Returns null if clipping is done until the end of
+     * the skeleton's rendering. */
+    endSlot: SlotData | null;
+    /** The color of the clipping polygon as it was in Spine. Available only when nonessential data was exported. Clipping polygons
+     * are not usually rendered at runtime. */
+    color: Color;
+    constructor(name: string);
+    copy(): Attachment;
+}

package/dist/types/packages/runtime-4.2/src/core/attachments/MeshAttachment.d.ts

@@ -0,0 +1,46 @@
+import { Slot } from '../Slot.js';
+import { Attachment, VertexAttachment } from './Attachment.js';
+import { Sequence } from './Sequence.js';
+import { Color, IHasTextureRegion, IMeshAttachment, NumberArrayLike, TextureRegion } from '@pixi-spine/base';
+/** An attachment that displays a textured mesh. A mesh has hull vertices and internal vertices within the hull. Holes are not
+ * supported. Each vertex has UVs (texture coordinates) and triangles are used to map an image on to the mesh.
+ * @public
+ * See [Mesh attachments](http://esotericsoftware.com/spine-meshes) in the Spine User Guide. */
+export declare class MeshAttachment extends VertexAttachment implements IMeshAttachment, IHasTextureRegion {
+    region: TextureRegion | null;
+    /** The name of the texture region for this attachment. */
+    path: string;
+    /** The UV pair for each vertex, normalized within the texture region. */
+    regionUVs: Float32Array;
+    /** The UV pair for each vertex, normalized within the entire texture.
+     *
+     * See {@link #updateUVs}. */
+    uvs: NumberArrayLike;
+    /** Triplets of vertex indices which describe the mesh's triangulation. */
+    triangles: Array<number>;
+    /** The color to tint the mesh. */
+    color: Color;
+    /** The width of the mesh's image. Available only when nonessential data was exported. */
+    width: number;
+    /** The height of the mesh's image. Available only when nonessential data was exported. */
+    height: number;
+    /** The number of entries at the beginning of {@link #vertices} that make up the mesh hull. */
+    hullLength: number;
+    /** Vertex index pairs describing edges for controling triangulation. Mesh triangles will never cross edges. Only available if
+     * nonessential data was exported. Triangulation is not performed at runtime. */
+    edges: Array<number>;
+    private parentMesh;
+    sequence: Sequence | null;
+    tempColor: Color;
+    constructor(name: string, path: string);
+    /** The parent mesh if this is a linked mesh, else null. A linked mesh shares the {@link #bones}, {@link #vertices},
+     * {@link #regionUVs}, {@link #triangles}, {@link #hullLength}, {@link #edges}, {@link #width}, and {@link #height} with the
+     * parent mesh, but may have a different {@link #name} or {@link #path} (and therefore a different texture). */
+    getParentMesh(): MeshAttachment;
+    /** @param parentMesh May be null. */
+    setParentMesh(parentMesh: MeshAttachment): void;
+    copy(): Attachment;
+    computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: NumberArrayLike, offset: number, stride: number): void;
+    /** Returns a new mesh with the {@link #parentMesh} set to this mesh's parent mesh, if any, else to this mesh. **/
+    newLinkedMesh(): MeshAttachment;
+}

package/dist/types/packages/runtime-4.2/src/core/attachments/PathAttachment.d.ts

@@ -0,0 +1,19 @@
+import { Attachment, VertexAttachment } from './Attachment.js';
+import { Color } from '@pixi-spine/base';
+/** An attachment whose vertices make up a composite Bezier curve.
+ * @public
+ * See {@link PathConstraint} and [Paths](http://esotericsoftware.com/spine-paths) in the Spine User Guide. */
+export declare class PathAttachment extends VertexAttachment {
+    /** The lengths along the path in the setup pose from the start of the path to the end of each Bezier curve. */
+    lengths: Array<number>;
+    /** If true, the start and end knots are connected. */
+    closed: boolean;
+    /** If true, additional calculations are performed to make calculating positions along the path more accurate. If false, fewer
+     * calculations are performed but calculating positions along the path is less accurate. */
+    constantSpeed: boolean;
+    /** The color of the path as it was in Spine. Available only when nonessential data was exported. Paths are not usually
+     * rendered at runtime. */
+    color: Color;
+    constructor(name: string);
+    copy(): Attachment;
+}

package/dist/types/packages/runtime-4.2/src/core/attachments/PointAttachment.d.ts

@@ -0,0 +1,20 @@
+import { Bone } from '../Bone.js';
+import { Attachment, VertexAttachment } from './Attachment.js';
+import { Color, Vector2 } from '@pixi-spine/base';
+/** An attachment which is a single point and a rotation. This can be used to spawn projectiles, particles, etc. A bone can be
+ * used in similar ways, but a PointAttachment is slightly less expensive to compute and can be hidden, shown, and placed in a
+ * skin.
+ * @public
+ * See [Point Attachments](http://esotericsoftware.com/spine-point-attachments) in the Spine User Guide. */
+export declare class PointAttachment extends VertexAttachment {
+    x: number;
+    y: number;
+    rotation: number;
+    /** The color of the point attachment as it was in Spine. Available only when nonessential data was exported. Point attachments
+     * are not usually rendered at runtime. */
+    color: Color;
+    constructor(name: string);
+    computeWorldPosition(bone: Bone, point: Vector2): Vector2;
+    computeWorldRotation(bone: Bone): number;
+    copy(): Attachment;
+}

package/dist/types/packages/runtime-4.2/src/core/attachments/RegionAttachment.d.ts

@@ -0,0 +1,80 @@
+import { Slot } from '../Slot.js';
+import { Attachment } from './Attachment.js';
+import { Sequence } from './Sequence.js';
+import { Color, IHasTextureRegion, IRegionAttachment, NumberArrayLike, TextureRegion } from '@pixi-spine/base';
+/** An attachment that displays a textured quadrilateral.
+ * @public
+ * See [Region attachments](http://esotericsoftware.com/spine-regions) in the Spine User Guide. */
+export declare class RegionAttachment extends Attachment implements IRegionAttachment, IHasTextureRegion {
+    /** The local x translation. */
+    x: number;
+    /** The local y translation. */
+    y: number;
+    /** The local scaleX. */
+    scaleX: number;
+    /** The local scaleY. */
+    scaleY: number;
+    /** The local rotation. */
+    rotation: number;
+    /** The width of the region attachment in Spine. */
+    width: number;
+    /** The height of the region attachment in Spine. */
+    height: number;
+    /** The color to tint the region attachment. */
+    color: Color;
+    /** The name of the texture region for this attachment. */
+    path: string;
+    region: TextureRegion | null;
+    sequence: Sequence | null;
+    /** For each of the 4 vertices, a pair of <code>x,y</code> values that is the local position of the vertex.
+     *
+     * See {@link #updateOffset()}. */
+    offset: NumberArrayLike;
+    uvs: NumberArrayLike;
+    tempColor: Color;
+    constructor(name: string, path: string);
+    /** Calculates the {@link #offset} using the region settings. Must be called after changing region settings. */
+    updateRegion(): void;
+    /** Transforms the attachment's four vertices to world coordinates. If the attachment has a {@link #sequence}, the region may
+     * be changed.
+     * <p>
+     * See <a href="http://esotericsoftware.com/spine-runtime-skeletons#World-transforms">World transforms</a> in the Spine
+     * Runtimes Guide.
+     * @param worldVertices The output world vertices. Must have a length >= <code>offset</code> + 8.
+     * @param offset The <code>worldVertices</code> index to begin writing values.
+     * @param stride The number of <code>worldVertices</code> entries between the value pairs written. */
+    computeWorldVertices(slot: Slot, worldVertices: NumberArrayLike, offset: number, stride: number): void;
+    copy(): Attachment;
+    static X1: number;
+    static Y1: number;
+    static C1R: number;
+    static C1G: number;
+    static C1B: number;
+    static C1A: number;
+    static U1: number;
+    static V1: number;
+    static X2: number;
+    static Y2: number;
+    static C2R: number;
+    static C2G: number;
+    static C2B: number;
+    static C2A: number;
+    static U2: number;
+    static V2: number;
+    static X3: number;
+    static Y3: number;
+    static C3R: number;
+    static C3G: number;
+    static C3B: number;
+    static C3A: number;
+    static U3: number;
+    static V3: number;
+    static X4: number;
+    static Y4: number;
+    static C4R: number;
+    static C4G: number;
+    static C4B: number;
+    static C4A: number;
+    static U4: number;
+    static V4: number;
+}