simple-pixi-spine 0.1.0

package/dist/types/packages/loader-base/src/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="packages/loader-base/global" />
+import './atlasLoader';
+export * from './atlasLoader';
+export * from './SpineLoaderAbstract';

package/dist/types/packages/loader-uni/src/Spine.d.ts

@@ -0,0 +1,15 @@
+import * as spine42 from '@esotericsoftware/spine-pixi-v8';
+import { IAnimationState, IAnimationStateData, ISkeleton, ISkeletonData, SpineBase } from '@pixi-spine/base';
+import * as spine38 from '@pixi-spine/runtime-3.8';
+import * as spine40 from '@pixi-spine/runtime-4.0';
+import * as spine41 from '@pixi-spine/runtime-4.1';
+export { spine38 };
+export { spine40 };
+export { spine41 };
+export { spine42 };
+/**
+ * @public
+ */
+export declare class Spine extends SpineBase<ISkeleton, ISkeletonData, IAnimationState, IAnimationStateData> {
+    createSkeleton(spineData: ISkeletonData): void;
+}

package/dist/types/packages/loader-uni/src/SpineLoader.d.ts

@@ -0,0 +1,10 @@
+import { ISkeletonData, ISkeletonParser, TextureAtlas } from '@pixi-spine/base';
+import { ISpineResource, SpineLoaderAbstract } from '@pixi-spine/loader-base';
+/**
+ * @public
+ */
+export declare class SpineLoader extends SpineLoaderAbstract<ISkeletonData> {
+    createBinaryParser(): ISkeletonParser;
+    createJsonParser(): ISkeletonParser;
+    parseData(parser: ISkeletonParser, atlas: TextureAtlas, dataToParse: any): ISpineResource<ISkeletonData>;
+}

package/dist/types/packages/loader-uni/src/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="packages/loader-uni/global" />
+import '@pixi-spine/loader-base';
+export * from './Spine';

package/dist/types/packages/runtime-3.7/src/Spine.d.ts

@@ -0,0 +1,11 @@
+import { SpineBase } from '@pixi-spine/base';
+import { Skeleton } from './core/Skeleton';
+import type { SkeletonData } from './core/SkeletonData';
+import { AnimationState } from './core/AnimationState';
+import { AnimationStateData } from './core/AnimationStateData';
+/**
+ * @public
+ */
+export declare class Spine extends SpineBase<Skeleton, SkeletonData, AnimationState, AnimationStateData> {
+    createSkeleton(spineData: SkeletonData): void;
+}

package/dist/types/packages/runtime-3.7/src/core/Animation.d.ts

@@ -0,0 +1,307 @@
+import type { Event } from './Event';
+import type { Skeleton } from './Skeleton';
+import { VertexAttachment } from './attachments';
+import { ArrayLike, MixBlend, MixDirection, IAnimation, ITimeline } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class Animation implements IAnimation<Timeline> {
+    name: string;
+    timelines: Array<Timeline>;
+    duration: number;
+    constructor(name: string, timelines: Array<Timeline>, duration: number);
+    apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    static binarySearch(values: ArrayLike<number>, target: number, step?: number): number;
+    static linearSearch(values: ArrayLike<number>, target: number, step: number): number;
+}
+/**
+ * @public
+ */
+export interface Timeline extends ITimeline {
+    apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    getPropertyId(): number;
+}
+/**
+ * @public
+ */
+export declare enum TimelineType {
+    rotate = 0,
+    translate = 1,
+    scale = 2,
+    shear = 3,
+    attachment = 4,
+    color = 5,
+    deform = 6,
+    event = 7,
+    drawOrder = 8,
+    ikConstraint = 9,
+    transformConstraint = 10,
+    pathConstraintPosition = 11,
+    pathConstraintSpacing = 12,
+    pathConstraintMix = 13,
+    twoColor = 14
+}
+/**
+ * @public
+ */
+export declare abstract class CurveTimeline implements Timeline {
+    static LINEAR: number;
+    static STEPPED: number;
+    static BEZIER: number;
+    static BEZIER_SIZE: number;
+    private curves;
+    abstract getPropertyId(): number;
+    constructor(frameCount: number);
+    getFrameCount(): number;
+    setLinear(frameIndex: number): void;
+    setStepped(frameIndex: number): void;
+    getCurveType(frameIndex: number): number;
+    /** Sets the control handle positions for an interpolation bezier curve used to transition from this keyframe to the next.
+     * cx1 and cx2 are from 0 to 1, representing the percent of time between the two keyframes. cy1 and cy2 are the percent of
+     * the difference between the keyframe's values. */
+    setCurve(frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void;
+    getCurvePercent(frameIndex: number, percent: number): number;
+    abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class RotateTimeline extends CurveTimeline {
+    static ENTRIES: number;
+    static PREV_TIME: number;
+    static PREV_ROTATION: number;
+    static ROTATION: number;
+    boneIndex: number;
+    frames: ArrayLike<number>;
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    /** Sets the time and angle of the specified keyframe. */
+    setFrame(frameIndex: number, time: number, degrees: number): void;
+    apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class TranslateTimeline extends CurveTimeline {
+    static ENTRIES: number;
+    static PREV_TIME: number;
+    static PREV_X: number;
+    static PREV_Y: number;
+    static X: number;
+    static Y: number;
+    boneIndex: number;
+    frames: ArrayLike<number>;
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    /** Sets the time and value of the specified keyframe. */
+    setFrame(frameIndex: number, time: number, x: number, y: number): void;
+    apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class ScaleTimeline extends TranslateTimeline {
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class ShearTimeline extends TranslateTimeline {
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class ColorTimeline extends CurveTimeline {
+    static ENTRIES: number;
+    static PREV_TIME: number;
+    static PREV_R: number;
+    static PREV_G: number;
+    static PREV_B: number;
+    static PREV_A: number;
+    static R: number;
+    static G: number;
+    static B: number;
+    static A: number;
+    slotIndex: number;
+    frames: ArrayLike<number>;
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    /** Sets the time and value of the specified keyframe. */
+    setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number): void;
+    apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class TwoColorTimeline extends CurveTimeline {
+    static ENTRIES: number;
+    static PREV_TIME: number;
+    static PREV_R: number;
+    static PREV_G: number;
+    static PREV_B: number;
+    static PREV_A: number;
+    static PREV_R2: number;
+    static PREV_G2: number;
+    static PREV_B2: number;
+    static R: number;
+    static G: number;
+    static B: number;
+    static A: number;
+    static R2: number;
+    static G2: number;
+    static B2: number;
+    slotIndex: number;
+    frames: ArrayLike<number>;
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    /** Sets the time and value of the specified keyframe. */
+    setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number, r2: number, g2: number, b2: number): void;
+    apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class AttachmentTimeline implements Timeline {
+    slotIndex: number;
+    frames: ArrayLike<number>;
+    attachmentNames: Array<string>;
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    getFrameCount(): number;
+    /** Sets the time and value of the specified keyframe. */
+    setFrame(frameIndex: number, time: number, attachmentName: string): void;
+    apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class DeformTimeline extends CurveTimeline {
+    slotIndex: number;
+    attachment: VertexAttachment;
+    frames: ArrayLike<number>;
+    frameVertices: Array<ArrayLike<number>>;
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    /** Sets the time of the specified keyframe. */
+    setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
+    apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class EventTimeline implements Timeline {
+    frames: ArrayLike<number>;
+    events: Array<Event>;
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    getFrameCount(): number;
+    /** Sets the time of the specified keyframe. */
+    setFrame(frameIndex: number, event: Event): void;
+    /** Fires events for frames > lastTime and <= time. */
+    apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class DrawOrderTimeline implements Timeline {
+    frames: ArrayLike<number>;
+    drawOrders: Array<Array<number>>;
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    getFrameCount(): number;
+    /** Sets the time of the specified keyframe.
+     * @param drawOrder May be null to use bind pose draw order. */
+    setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void;
+    apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class IkConstraintTimeline extends CurveTimeline {
+    static ENTRIES: number;
+    static PREV_TIME: number;
+    static PREV_MIX: number;
+    static PREV_BEND_DIRECTION: number;
+    static PREV_COMPRESS: number;
+    static PREV_STRETCH: number;
+    static MIX: number;
+    static BEND_DIRECTION: number;
+    static COMPRESS: number;
+    static STRETCH: number;
+    ikConstraintIndex: number;
+    frames: ArrayLike<number>;
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    /** Sets the time, mix and bend direction of the specified keyframe. */
+    setFrame(frameIndex: number, time: number, mix: number, bendDirection: number, compress: boolean, stretch: boolean): void;
+    apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class TransformConstraintTimeline extends CurveTimeline {
+    static ENTRIES: number;
+    static PREV_TIME: number;
+    static PREV_ROTATE: number;
+    static PREV_TRANSLATE: number;
+    static PREV_SCALE: number;
+    static PREV_SHEAR: number;
+    static ROTATE: number;
+    static TRANSLATE: number;
+    static SCALE: number;
+    static SHEAR: number;
+    transformConstraintIndex: number;
+    frames: ArrayLike<number>;
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    /** Sets the time and mixes of the specified keyframe. */
+    setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number, scaleMix: number, shearMix: number): void;
+    apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class PathConstraintPositionTimeline extends CurveTimeline {
+    static ENTRIES: number;
+    static PREV_TIME: number;
+    static PREV_VALUE: number;
+    static VALUE: number;
+    pathConstraintIndex: number;
+    frames: ArrayLike<number>;
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    /** Sets the time and value of the specified keyframe. */
+    setFrame(frameIndex: number, time: number, value: number): void;
+    apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class PathConstraintSpacingTimeline extends PathConstraintPositionTimeline {
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}
+/**
+ * @public
+ */
+export declare class PathConstraintMixTimeline extends CurveTimeline {
+    static ENTRIES: number;
+    static PREV_TIME: number;
+    static PREV_ROTATE: number;
+    static PREV_TRANSLATE: number;
+    static ROTATE: number;
+    static TRANSLATE: number;
+    pathConstraintIndex: number;
+    frames: ArrayLike<number>;
+    constructor(frameCount: number);
+    getPropertyId(): number;
+    /** Sets the time and mixes of the specified keyframe. */
+    setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number): void;
+    apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+}

package/dist/types/packages/runtime-3.7/src/core/AnimationState.d.ts

@@ -0,0 +1,175 @@
+import { IAnimationState, IAnimationStateListener, ITrackEntry, MixBlend, Pool, IntSet } from '@pixi-spine/base';
+import { Animation, Timeline } from './Animation';
+import type { AnimationStateData } from './AnimationStateData';
+import type { Event } from './Event';
+import type { Skeleton } from './Skeleton';
+/**
+ * @public
+ */
+export declare class AnimationState implements IAnimationState<AnimationStateData> {
+    static emptyAnimation: Animation;
+    static SUBSEQUENT: number;
+    static FIRST: number;
+    static HOLD: number;
+    static HOLD_MIX: number;
+    data: AnimationStateData;
+    tracks: TrackEntry[];
+    events: Event[];
+    listeners: AnimationStateListener[];
+    queue: EventQueue;
+    propertyIDs: IntSet;
+    animationsChanged: boolean;
+    timeScale: number;
+    trackEntryPool: Pool<TrackEntry>;
+    constructor(data: AnimationStateData);
+    update(delta: number): void;
+    updateMixingFrom(to: TrackEntry, delta: number): boolean;
+    apply(skeleton: Skeleton): boolean;
+    applyMixingFrom(to: TrackEntry, skeleton: Skeleton, blend: MixBlend): number;
+    applyRotateTimeline(timeline: Timeline, skeleton: Skeleton, time: number, alpha: number, blend: MixBlend, timelinesRotation: Array<number>, i: number, firstFrame: boolean): void;
+    queueEvents(entry: TrackEntry, animationTime: number): void;
+    clearTracks(): void;
+    clearTrack(trackIndex: number): void;
+    setCurrent(index: number, current: TrackEntry, interrupt: boolean): void;
+    setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
+    setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
+    addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
+    addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
+    setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
+    addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
+    setEmptyAnimations(mixDuration: number): void;
+    expandToIndex(index: number): TrackEntry;
+    trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry): TrackEntry;
+    disposeNext(entry: TrackEntry): void;
+    _animationsChanged(): void;
+    setTimelineModes(entry: TrackEntry): void;
+    hasTimeline(entry: TrackEntry, id: number): boolean;
+    getCurrent(trackIndex: number): TrackEntry;
+    addListener(listener: AnimationStateListener): void;
+    /** Removes the listener added with {@link #addListener(AnimationStateListener)}. */
+    removeListener(listener: AnimationStateListener): void;
+    clearListeners(): void;
+    clearListenerNotifications(): void;
+    onComplete: (trackIndex: number, loopCount: number) => any;
+    onEvent: (trackIndex: number, event: Event) => any;
+    onStart: (trackIndex: number) => any;
+    onEnd: (trackIndex: number) => any;
+    private static deprecatedWarning1;
+    setAnimationByName(trackIndex: number, animationName: string, loop: boolean): void;
+    private static deprecatedWarning2;
+    addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): void;
+    private static deprecatedWarning3;
+    hasAnimation(animationName: string): boolean;
+    hasAnimationByName(animationName: string): boolean;
+}
+/**
+ * @public
+ */
+export declare class TrackEntry implements ITrackEntry {
+    animation: Animation;
+    next: TrackEntry;
+    mixingFrom: TrackEntry;
+    mixingTo: TrackEntry;
+    listener: AnimationStateListener;
+    trackIndex: number;
+    loop: boolean;
+    holdPrevious: boolean;
+    eventThreshold: number;
+    attachmentThreshold: number;
+    drawOrderThreshold: number;
+    animationStart: number;
+    animationEnd: number;
+    animationLast: number;
+    nextAnimationLast: number;
+    delay: number;
+    trackTime: number;
+    trackLast: number;
+    nextTrackLast: number;
+    trackEnd: number;
+    timeScale: number;
+    alpha: number;
+    mixTime: number;
+    mixDuration: number;
+    interruptAlpha: number;
+    totalAlpha: number;
+    mixBlend: MixBlend;
+    timelineMode: number[];
+    timelineHoldMix: TrackEntry[];
+    timelinesRotation: number[];
+    reset(): void;
+    getAnimationTime(): number;
+    setAnimationLast(animationLast: number): void;
+    isComplete(): boolean;
+    resetRotationDirections(): void;
+    onComplete: (trackIndex: number, loopCount: number) => any;
+    onEvent: (trackIndex: number, event: Event) => any;
+    onStart: (trackIndex: number) => any;
+    onEnd: (trackIndex: number) => any;
+    private static deprecatedWarning1;
+    private static deprecatedWarning2;
+    get time(): number;
+    set time(value: number);
+    get endTime(): number;
+    set endTime(value: number);
+    loopsCount(): number;
+}
+/**
+ * @public
+ */
+export declare class EventQueue {
+    objects: Array<any>;
+    drainDisabled: boolean;
+    animState: AnimationState;
+    constructor(animState: AnimationState);
+    start(entry: TrackEntry): void;
+    interrupt(entry: TrackEntry): void;
+    end(entry: TrackEntry): void;
+    dispose(entry: TrackEntry): void;
+    complete(entry: TrackEntry): void;
+    event(entry: TrackEntry, event: Event): void;
+    private static deprecatedWarning1;
+    deprecateStuff(): boolean;
+    drain(): void;
+    clear(): void;
+}
+/**
+ * @public
+ */
+export declare enum EventType {
+    start = 0,
+    interrupt = 1,
+    end = 2,
+    dispose = 3,
+    complete = 4,
+    event = 5
+}
+/**
+ * @public
+ */
+export interface AnimationStateListener extends IAnimationStateListener {
+    /** Invoked when this entry has been set as the current entry. */
+    start?(entry: TrackEntry): void;
+    /** Invoked when another entry has replaced this entry as the current entry. This entry may continue being applied for
+     * mixing. */
+    interrupt?(entry: TrackEntry): void;
+    /** Invoked when this entry is no longer the current entry and will never be applied again. */
+    end?(entry: TrackEntry): void;
+    /** Invoked when this entry will be disposed. This may occur without the entry ever being set as the current entry.
+     * References to the entry should not be kept after dispose is called, as it may be destroyed or reused. */
+    dispose?(entry: TrackEntry): void;
+    /** Invoked every time this entry's animation completes a loop. */
+    complete?(entry: TrackEntry): void;
+    /** Invoked when this entry's animation triggers an event. */
+    event?(entry: TrackEntry, event: Event): void;
+}
+/**
+ * @public
+ */
+export declare abstract class AnimationStateAdapter2 implements AnimationStateListener {
+    start(entry: TrackEntry): void;
+    interrupt(entry: TrackEntry): void;
+    end(entry: TrackEntry): void;
+    dispose(entry: TrackEntry): void;
+    complete(entry: TrackEntry): void;
+    event(entry: TrackEntry, event: Event): void;
+}

package/dist/types/packages/runtime-3.7/src/core/AnimationStateData.d.ts

@@ -0,0 +1,17 @@
+import type { SkeletonData } from './SkeletonData';
+import type { IAnimationStateData, StringMap } from '@pixi-spine/base';
+import type { Animation } from './Animation';
+/**
+ * @public
+ */
+export declare class AnimationStateData implements IAnimationStateData<SkeletonData, Animation> {
+    skeletonData: SkeletonData;
+    animationToMixTime: StringMap<number>;
+    defaultMix: number;
+    constructor(skeletonData: SkeletonData);
+    setMix(fromName: string, toName: string, duration: number): void;
+    private static deprecatedWarning1;
+    setMixByName(fromName: string, toName: string, duration: number): void;
+    setMixWith(from: Animation, to: Animation, duration: number): void;
+    getMix(from: Animation, to: Animation): number;
+}

package/dist/types/packages/runtime-3.7/src/core/AtlasAttachmentLoader.d.ts

@@ -0,0 +1,20 @@
+import { AttachmentLoader, RegionAttachment, MeshAttachment, BoundingBoxAttachment, PathAttachment, PointAttachment, ClippingAttachment } from './attachments';
+import type { TextureAtlas } from '@pixi-spine/base';
+import type { Skin } from './Skin';
+/**
+ * @public
+ */
+export declare class AtlasAttachmentLoader implements AttachmentLoader {
+    atlas: TextureAtlas;
+    constructor(atlas: TextureAtlas);
+    /** @return May be null to not load an attachment. */
+    newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
+    /** @return May be null to not load an attachment. */
+    newMeshAttachment(skin: Skin, name: string, path: string): 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;
+    newPointAttachment(skin: Skin, name: string): PointAttachment;
+    newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
+}

package/dist/types/packages/runtime-3.7/src/core/Bone.d.ts

@@ -0,0 +1,58 @@
+import { Matrix } from 'pixi.js';
+import type { Updatable } from './Updatable';
+import type { BoneData } from './BoneData';
+import type { Skeleton } from './Skeleton';
+import { IBone, Vector2 } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class Bone implements Updatable, IBone {
+    matrix: Matrix;
+    get worldX(): number;
+    get worldY(): number;
+    data: BoneData;
+    skeleton: Skeleton;
+    parent: Bone;
+    children: Bone[];
+    x: number;
+    y: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    shearX: number;
+    shearY: number;
+    ax: number;
+    ay: number;
+    arotation: number;
+    ascaleX: number;
+    ascaleY: number;
+    ashearX: number;
+    ashearY: number;
+    appliedValid: boolean;
+    sorted: boolean;
+    /** @param parent May be null. */
+    constructor(data: BoneData, skeleton: Skeleton, parent: Bone);
+    /** NOT USED IN 3.7. Needed for the debug graph code */
+    active: boolean;
+    /** Same as {@link #updateWorldTransform()}. This method exists for Bone to implement {@link Updatable}. */
+    update(): void;
+    /** Computes the world transform using the parent bone and this bone's local transform. */
+    updateWorldTransform(): void;
+    /** Computes the world transform using the parent bone and the specified local transform. */
+    updateWorldTransformWith(x: number, y: number, rotation: number, scaleX: number, scaleY: number, shearX: number, shearY: number): void;
+    setToSetupPose(): void;
+    getWorldRotationX(): number;
+    getWorldRotationY(): number;
+    getWorldScaleX(): number;
+    getWorldScaleY(): number;
+    /** Computes the individual applied transform values from the world transform. This can be useful to perform processing using
+     * the applied transform after the world transform has been modified directly (eg, by a constraint).
+     * <p>
+     * Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. */
+    updateAppliedTransform(): void;
+    worldToLocal(world: Vector2): Vector2;
+    localToWorld(local: Vector2): Vector2;
+    worldToLocalRotation(worldRotation: number): number;
+    localToWorldRotation(localRotation: number): number;
+    rotateWorld(degrees: number): void;
+}

package/dist/types/packages/runtime-3.7/src/core/BoneData.d.ts

@@ -0,0 +1,19 @@
+import { TransformMode } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class BoneData {
+    index: number;
+    name: string;
+    parent: BoneData;
+    length: number;
+    x: number;
+    y: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    shearX: number;
+    shearY: number;
+    transformMode: TransformMode;
+    constructor(index: number, name: string, parent: BoneData);
+}

package/dist/types/packages/runtime-3.7/src/core/Constraint.d.ts

@@ -0,0 +1,7 @@
+import type { Updatable } from './Updatable';
+/**
+ * @public
+ */
+export interface Constraint extends Updatable {
+    getOrder(): number;
+}

package/dist/types/packages/runtime-3.7/src/core/Event.d.ts

@@ -0,0 +1,15 @@
+import type { EventData } from './EventData';
+import type { IEvent } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class Event implements IEvent {
+    data: EventData;
+    intValue: number;
+    floatValue: number;
+    stringValue: string;
+    time: number;
+    volume: number;
+    balance: number;
+    constructor(time: number, data: EventData);
+}