simple-pixi-spine 0.1.0

package/dist/types/packages/runtime-3.8/src/core/PathConstraintData.d.ts

@@ -0,0 +1,28 @@
+import { ConstraintData } from './Constraint';
+import type { SlotData } from './SlotData';
+import type { BoneData } from './BoneData';
+import type { RotateMode, PositionMode } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class PathConstraintData extends ConstraintData {
+    bones: BoneData[];
+    target: SlotData;
+    positionMode: PositionMode;
+    spacingMode: SpacingMode;
+    rotateMode: RotateMode;
+    offsetRotation: number;
+    position: number;
+    spacing: number;
+    rotateMix: number;
+    translateMix: number;
+    constructor(name: string);
+}
+/**
+ * @public
+ */
+export declare enum SpacingMode {
+    Length = 0,
+    Fixed = 1,
+    Percent = 2
+}

package/dist/types/packages/runtime-3.8/src/core/Skeleton.d.ts

@@ -0,0 +1,88 @@
+import { Attachment } from './attachments';
+import { Bone } from './Bone';
+import { Slot } from './Slot';
+import type { Updatable } from './Updatable';
+import type { SkeletonData } from './SkeletonData';
+import { IkConstraint } from './IkConstraint';
+import { TransformConstraint } from './TransformConstraint';
+import { PathConstraint } from './PathConstraint';
+import type { Skin } from './Skin';
+import { Color, Vector2, ISkeleton } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class Skeleton implements ISkeleton<SkeletonData, Bone, Slot, Skin> {
+    data: SkeletonData;
+    bones: Array<Bone>;
+    slots: Array<Slot>;
+    drawOrder: Array<Slot>;
+    ikConstraints: Array<IkConstraint>;
+    transformConstraints: Array<TransformConstraint>;
+    pathConstraints: Array<PathConstraint>;
+    _updateCache: Updatable[];
+    updateCacheReset: Updatable[];
+    skin: Skin;
+    color: Color;
+    time: number;
+    scaleX: number;
+    scaleY: number;
+    x: number;
+    y: number;
+    constructor(data: SkeletonData);
+    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 constraints. */
+    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;
+    setSlotsToSetupPose(): void;
+    /** @return May return null. */
+    getRootBone(): Bone;
+    /** @return May be null. */
+    findBone(boneName: string): Bone;
+    /** @return -1 if the bone was not found. */
+    findBoneIndex(boneName: string): number;
+    /** @return May be null. */
+    findSlot(slotName: string): Slot;
+    /** @return -1 if the bone was not found. */
+    findSlotIndex(slotName: string): number;
+    /** Sets a skin by name.
+     * @see #setSkin(Skin) */
+    setSkinByName(skinName: string): void;
+    /** Sets the skin used to look up attachments before looking in the {@link SkeletonData#getDefaultSkin() default skin}.
+     * 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.
+     * @param newSkin May be null. */
+    setSkin(newSkin: Skin): void;
+    /** @return May be null. */
+    getAttachmentByName(slotName: string, attachmentName: string): Attachment;
+    /** @return May be null. */
+    getAttachment(slotIndex: number, attachmentName: string): Attachment;
+    /** @param attachmentName May be null. */
+    setAttachment(slotName: string, attachmentName?: string): void;
+    /** @return May be null. */
+    findIkConstraint(constraintName: string): IkConstraint;
+    /** @return May be null. */
+    findTransformConstraint(constraintName: string): TransformConstraint;
+    /** @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 The distance from the skeleton origin to the bottom left corner of the AABB.
+     * @param size The width and height of the AABB.
+     * @param temp Working memory */
+    getBounds(offset: Vector2, size: Vector2, temp?: Array<number>): void;
+    update(delta: number): void;
+    get flipX(): boolean;
+    set flipX(value: boolean);
+    get flipY(): boolean;
+    set flipY(value: boolean);
+    private static deprecatedWarning1;
+}

package/dist/types/packages/runtime-3.8/src/core/SkeletonBinary.d.ts

@@ -0,0 +1,43 @@
+import type { AttachmentLoader } from './attachments';
+import { SkeletonData } from './SkeletonData';
+import { SpacingMode } from './PathConstraintData';
+import { CurveTimeline } from './Animation';
+import { PositionMode, RotateMode, TransformMode } from '@pixi-spine/base';
+import { BLEND_MODES } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class SkeletonBinary {
+    static AttachmentTypeValues: number[];
+    static TransformModeValues: TransformMode[];
+    static PositionModeValues: PositionMode[];
+    static SpacingModeValues: SpacingMode[];
+    static RotateModeValues: RotateMode[];
+    static BlendModeValues: BLEND_MODES[];
+    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;
+    attachmentLoader: AttachmentLoader;
+    scale: number;
+    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/dist/types/packages/runtime-3.8/src/core/SkeletonBounds.d.ts

@@ -0,0 +1,8 @@
+import type { BoundingBoxAttachment } from './attachments';
+import { SkeletonBoundsBase } from '@pixi-spine/base';
+/** 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.
+ * @public
+ * */
+export declare class SkeletonBounds extends SkeletonBoundsBase<BoundingBoxAttachment> {
+}

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

@@ -0,0 +1,44 @@
+import type { ISkeletonData } from '@pixi-spine/base';
+import type { Animation } from './Animation';
+import type { BoneData } from './BoneData';
+import type { SlotData } from './SlotData';
+import type { Skin } from './Skin';
+import type { EventData } from './EventData';
+import type { IkConstraintData } from './IkConstraintData';
+import type { TransformConstraintData } from './TransformConstraintData';
+import type { PathConstraintData } from './PathConstraintData';
+/**
+ * @public
+ */
+export declare class SkeletonData implements ISkeletonData<BoneData, SlotData, Skin, Animation, EventData, IkConstraintData, TransformConstraintData, PathConstraintData> {
+    name: string;
+    bones: BoneData[];
+    slots: SlotData[];
+    skins: Skin[];
+    defaultSkin: Skin;
+    events: EventData[];
+    animations: Animation[];
+    ikConstraints: IkConstraintData[];
+    transformConstraints: TransformConstraintData[];
+    pathConstraints: PathConstraintData[];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    version: string;
+    hash: string;
+    fps: number;
+    imagesPath: string;
+    audioPath: string;
+    findBone(boneName: string): BoneData;
+    findBoneIndex(boneName: string): number;
+    findSlot(slotName: string): SlotData;
+    findSlotIndex(slotName: string): number;
+    findSkin(skinName: string): Skin;
+    findEvent(eventDataName: string): EventData;
+    findAnimation(animationName: string): Animation;
+    findIkConstraint(constraintName: string): IkConstraintData;
+    findTransformConstraint(constraintName: string): TransformConstraintData;
+    findPathConstraint(constraintName: string): PathConstraintData;
+    findPathConstraintIndex(pathConstraintName: string): number;
+}

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

@@ -0,0 +1,27 @@
+import type { Attachment, AttachmentLoader, VertexAttachment } from './attachments';
+import { SkeletonData } from './SkeletonData';
+import { SpacingMode } from './PathConstraintData';
+import { Skin } from './Skin';
+import { CurveTimeline } from './Animation';
+import { PositionMode, RotateMode, TransformMode } from '@pixi-spine/base';
+import { BLEND_MODES } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class SkeletonJson {
+    attachmentLoader: AttachmentLoader;
+    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): BLEND_MODES;
+    static positionModeFromString(str: string): PositionMode;
+    static spacingModeFromString(str: string): SpacingMode;
+    static rotateModeFromString(str: string): RotateMode;
+    static transformModeFromString(str: string): TransformMode;
+}

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

@@ -0,0 +1,35 @@
+import { Attachment } from './attachments';
+import type { BoneData } from './BoneData';
+import type { ConstraintData } from './Constraint';
+import type { Skeleton } from './Skeleton';
+import type { StringMap, ISkin } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class SkinEntry {
+    slotIndex: number;
+    name: string;
+    attachment: Attachment;
+    constructor(slotIndex: number, name: string, attachment: Attachment);
+}
+/**
+ * @public
+ */
+export declare class Skin implements ISkin {
+    name: string;
+    attachments: StringMap<Attachment>[];
+    bones: BoneData[];
+    constraints: ConstraintData[];
+    constructor(name: string);
+    setAttachment(slotIndex: number, name: string, attachment: Attachment): void;
+    addSkin(skin: Skin): void;
+    copySkin(skin: Skin): void;
+    /** @return May be null. */
+    getAttachment(slotIndex: number, name: string): Attachment;
+    removeAttachment(slotIndex: number, name: string): void;
+    getAttachments(): Array<SkinEntry>;
+    getAttachmentsForSlot(slotIndex: number, attachments: Array<SkinEntry>): void;
+    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-3.8/src/core/Slot.d.ts

@@ -0,0 +1,28 @@
+import { Color, ISlot } from '@pixi-spine/base';
+import type { Attachment } from './attachments/Attachment';
+import type { Bone } from './Bone';
+import type { SlotData } from './SlotData';
+/**
+ * @public
+ */
+export declare class Slot implements ISlot {
+    blendMode: number;
+    data: SlotData;
+    bone: Bone;
+    color: Color;
+    darkColor: Color;
+    attachment: Attachment;
+    private attachmentTime;
+    attachmentState: number;
+    deform: number[];
+    constructor(data: SlotData, bone: Bone);
+    /** @return May be null. */
+    getAttachment(): Attachment;
+    /** Sets the attachment and if it changed, resets {@link #getAttachmentTime()} and clears {@link #getAttachmentVertices()}.
+     * @param attachment May be null. */
+    setAttachment(attachment: Attachment): void;
+    setAttachmentTime(time: number): void;
+    /** Returns the time since the attachment was set. */
+    getAttachmentTime(): number;
+    setToSetupPose(): void;
+}

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

@@ -0,0 +1,17 @@
+import { Color } from '@pixi-spine/base';
+import type { ISlotData } from '@pixi-spine/base';
+import { BLEND_MODES } from '@pixi-spine/base';
+import type { BoneData } from './BoneData';
+/**
+ * @public
+ */
+export declare class SlotData implements ISlotData {
+    index: number;
+    name: string;
+    boneData: BoneData;
+    color: Color;
+    darkColor: Color;
+    attachmentName: string;
+    blendMode: BLEND_MODES;
+    constructor(index: number, name: string, boneData: BoneData);
+}

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

@@ -0,0 +1,27 @@
+import type { Updatable } from './Updatable';
+import type { TransformConstraintData } from './TransformConstraintData';
+import type { Bone } from './Bone';
+import { Vector2 } from '@pixi-spine/base';
+import type { Skeleton } from './Skeleton';
+/**
+ * @public
+ */
+export declare class TransformConstraint implements Updatable {
+    data: TransformConstraintData;
+    bones: Array<Bone>;
+    target: Bone;
+    rotateMix: number;
+    translateMix: number;
+    scaleMix: number;
+    shearMix: number;
+    temp: Vector2;
+    active: boolean;
+    constructor(data: TransformConstraintData, skeleton: Skeleton);
+    isActive(): boolean;
+    apply(): void;
+    update(): void;
+    applyAbsoluteWorld(): void;
+    applyRelativeWorld(): void;
+    applyAbsoluteLocal(): void;
+    applyRelativeLocal(): void;
+}

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

@@ -0,0 +1,22 @@
+import type { BoneData } from './BoneData';
+import { ConstraintData } from './Constraint';
+/**
+ * @public
+ */
+export declare class TransformConstraintData extends ConstraintData {
+    bones: BoneData[];
+    target: BoneData;
+    rotateMix: number;
+    translateMix: number;
+    scaleMix: number;
+    shearMix: number;
+    offsetRotation: number;
+    offsetX: number;
+    offsetY: number;
+    offsetScaleX: number;
+    offsetScaleY: number;
+    offsetShearY: number;
+    relative: boolean;
+    local: boolean;
+    constructor(name: string);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * @public
+ */
+export interface Updatable {
+    update(): void;
+    isActive(): boolean;
+}

package/dist/types/packages/runtime-3.8/src/core/VertexEffect.d.ts

@@ -0,0 +1,10 @@
+import type { Skeleton } from './Skeleton';
+import type { Color, Vector2 } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export interface VertexEffect {
+    begin(skeleton: Skeleton): void;
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
+    end(): void;
+}

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

@@ -0,0 +1,32 @@
+import { AttachmentType } from '@pixi-spine/base';
+import type { IAttachment, ArrayLike } from '@pixi-spine/base';
+import type { Slot } from '../Slot';
+/**
+ * @public
+ */
+export declare abstract class Attachment implements IAttachment {
+    name: string;
+    type: AttachmentType;
+    constructor(name: string);
+    abstract copy(): Attachment;
+}
+/**
+ * @public
+ */
+export declare abstract class VertexAttachment extends Attachment {
+    private static nextID;
+    id: number;
+    bones: Array<number>;
+    vertices: ArrayLike<number>;
+    worldVerticesLength: number;
+    deformAttachment: VertexAttachment;
+    constructor(name: string);
+    computeWorldVerticesOld(slot: Slot, worldVertices: ArrayLike<number>): void;
+    /** Transforms local vertices to world coordinates.
+     * @param start The index of the first local vertex value to transform. Each vertex has 2 values, x and y.
+     * @param count The number of world vertex values to output. Must be <= {@link #getWorldVerticesLength()} - start.
+     * @param worldVertices The output world vertices. Must have a length >= offset + count.
+     * @param offset The worldVertices index to begin writing values. */
+    computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
+    copyTo(attachment: VertexAttachment): void;
+}

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

@@ -0,0 +1,24 @@
+import type { Skin } from '../Skin';
+import type { RegionAttachment } from './RegionAttachment';
+import type { MeshAttachment } from './MeshAttachment';
+import type { BoundingBoxAttachment } from './BoundingBoxAttachment';
+import type { PathAttachment } from './PathAttachment';
+import type { PointAttachment } from './PointAttachment';
+import type { ClippingAttachment } from './ClippingAttachment';
+/**
+ * @public
+ */
+export interface AttachmentLoader {
+    /** @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;
+    /** @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-3.8/src/core/attachments/BoundingBoxAttachment.d.ts

@@ -0,0 +1,11 @@
+import { Attachment, VertexAttachment } from './Attachment';
+import { AttachmentType, Color } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class BoundingBoxAttachment extends VertexAttachment {
+    type: AttachmentType;
+    color: Color;
+    constructor(name: string);
+    copy(): Attachment;
+}

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

@@ -0,0 +1,13 @@
+import { Attachment, VertexAttachment } from './Attachment';
+import { AttachmentType, Color, IClippingAttachment } from '@pixi-spine/base';
+import type { SlotData } from '../SlotData';
+/**
+ * @public
+ */
+export declare class ClippingAttachment extends VertexAttachment implements IClippingAttachment {
+    type: AttachmentType;
+    endSlot: SlotData;
+    color: Color;
+    constructor(name: string);
+    copy(): Attachment;
+}

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

@@ -0,0 +1,25 @@
+import { Attachment, VertexAttachment } from './Attachment';
+import { AttachmentType, Color, IMeshAttachment, TextureRegion } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class MeshAttachment extends VertexAttachment implements IMeshAttachment {
+    type: AttachmentType;
+    region: TextureRegion;
+    path: string;
+    regionUVs: Float32Array;
+    triangles: Array<number>;
+    color: Color;
+    width: number;
+    height: number;
+    hullLength: number;
+    edges: Array<number>;
+    private parentMesh;
+    tempColor: Color;
+    constructor(name: string);
+    getParentMesh(): MeshAttachment;
+    /** @param parentMesh May be null. */
+    setParentMesh(parentMesh: MeshAttachment): void;
+    copy(): Attachment;
+    newLinkedMesh(): MeshAttachment;
+}

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

@@ -0,0 +1,14 @@
+import { Attachment, VertexAttachment } from './Attachment';
+import { AttachmentType, Color } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class PathAttachment extends VertexAttachment {
+    type: AttachmentType;
+    lengths: Array<number>;
+    closed: boolean;
+    constantSpeed: boolean;
+    color: Color;
+    constructor(name: string);
+    copy(): Attachment;
+}

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

@@ -0,0 +1,17 @@
+import { Attachment, VertexAttachment } from './Attachment';
+import { AttachmentType, Color, Vector2 } from '@pixi-spine/base';
+import type { Bone } from '../Bone';
+/**
+ * @public
+ */
+export declare class PointAttachment extends VertexAttachment {
+    type: AttachmentType;
+    x: number;
+    y: number;
+    rotation: number;
+    color: Color;
+    constructor(name: string);
+    computeWorldPosition(bone: Bone, point: Vector2): Vector2;
+    computeWorldRotation(bone: Bone): number;
+    copy(): Attachment;
+}

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

@@ -0,0 +1,69 @@
+import { Attachment } from './Attachment';
+import { AttachmentType, ArrayLike, Color, TextureRegion, IRegionAttachment } from '@pixi-spine/base';
+import type { Bone } from '../Bone';
+import { Slot } from '../Slot';
+/**
+ * @public
+ */
+export declare class RegionAttachment extends Attachment implements IRegionAttachment {
+    type: AttachmentType;
+    static OX1: number;
+    static OY1: number;
+    static OX2: number;
+    static OY2: number;
+    static OX3: number;
+    static OY3: number;
+    static OX4: number;
+    static OY4: number;
+    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;
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+    rotation: number;
+    width: number;
+    height: number;
+    color: Color;
+    path: string;
+    rendererObject: any;
+    region: TextureRegion;
+    offset: import("@pixi-spine/base").NumberArrayLike;
+    uvs: import("@pixi-spine/base").NumberArrayLike;
+    tempColor: Color;
+    constructor(name: string);
+    updateOffset(): void;
+    setRegion(region: TextureRegion): void;
+    computeWorldVertices(bone: Bone | Slot, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
+    copy(): Attachment;
+}

package/dist/types/packages/runtime-3.8/src/core/attachments/index.d.ts

@@ -0,0 +1,8 @@
+export * from './Attachment';
+export * from './AttachmentLoader';
+export * from './BoundingBoxAttachment';
+export * from './ClippingAttachment';
+export * from './MeshAttachment';
+export * from './PathAttachment';
+export * from './PointAttachment';
+export * from './RegionAttachment';

package/dist/types/packages/runtime-3.8/src/core/vertexeffects/JitterEffect.d.ts

@@ -0,0 +1,14 @@
+import type { VertexEffect } from '../VertexEffect';
+import type { Skeleton } from '../Skeleton';
+import { Color, Vector2 } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class JitterEffect implements VertexEffect {
+    jitterX: number;
+    jitterY: number;
+    constructor(jitterX: number, jitterY: number);
+    begin(skeleton: Skeleton): void;
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
+    end(): void;
+}

package/dist/types/packages/runtime-3.8/src/core/vertexeffects/SwirlEffect.d.ts

@@ -0,0 +1,19 @@
+import type { VertexEffect } from '../VertexEffect';
+import type { Skeleton } from '../Skeleton';
+import { Color, PowOut, Vector2 } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class SwirlEffect implements VertexEffect {
+    static interpolation: PowOut;
+    centerX: number;
+    centerY: number;
+    radius: number;
+    angle: number;
+    private worldX;
+    private worldY;
+    constructor(radius: number);
+    begin(skeleton: Skeleton): void;
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
+    end(): void;
+}