/// declare module PIXI.spine.core { class Animation { name: string; timelines: Array; duration: number; constructor(name: string, timelines: Array, duration: number); apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; static binarySearch(values: ArrayLike, target: number, step?: number): number; static linearSearch(values: ArrayLike, target: number, step: number): number; } interface Timeline { apply(skeleton: Skeleton, lastTime: number, time: number, events: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; getPropertyId(): number; } enum MixBlend { setup = 0, first = 1, replace = 2, add = 3 } enum MixDirection { in = 0, out = 1 } 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 } 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; 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, alpha: number, blend: MixBlend, direction: MixDirection): void; } class RotateTimeline extends CurveTimeline { static ENTRIES: number; static PREV_TIME: number; static PREV_ROTATION: number; static ROTATION: number; boneIndex: number; frames: ArrayLike; constructor(frameCount: number); getPropertyId(): number; setFrame(frameIndex: number, time: number, degrees: number): void; apply(skeleton: Skeleton, lastTime: number, time: number, events: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } 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; constructor(frameCount: number); getPropertyId(): number; setFrame(frameIndex: number, time: number, x: number, y: number): void; apply(skeleton: Skeleton, lastTime: number, time: number, events: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } class ScaleTimeline extends TranslateTimeline { constructor(frameCount: number); getPropertyId(): number; apply(skeleton: Skeleton, lastTime: number, time: number, events: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } class ShearTimeline extends TranslateTimeline { constructor(frameCount: number); getPropertyId(): number; apply(skeleton: Skeleton, lastTime: number, time: number, events: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } 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; constructor(frameCount: number); getPropertyId(): number; setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number): void; apply(skeleton: Skeleton, lastTime: number, time: number, events: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } 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; constructor(frameCount: number); getPropertyId(): number; 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, alpha: number, blend: MixBlend, direction: MixDirection): void; } class AttachmentTimeline implements Timeline { slotIndex: number; frames: ArrayLike; attachmentNames: Array; constructor(frameCount: number); getPropertyId(): number; getFrameCount(): number; setFrame(frameIndex: number, time: number, attachmentName: string): void; apply(skeleton: Skeleton, lastTime: number, time: number, events: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } class DeformTimeline extends CurveTimeline { slotIndex: number; attachment: VertexAttachment; frames: ArrayLike; frameVertices: Array>; constructor(frameCount: number); getPropertyId(): number; setFrame(frameIndex: number, time: number, vertices: ArrayLike): void; apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } class EventTimeline implements Timeline { frames: ArrayLike; events: Array; constructor(frameCount: number); getPropertyId(): number; getFrameCount(): number; setFrame(frameIndex: number, event: Event): void; apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } class DrawOrderTimeline implements Timeline { frames: ArrayLike; drawOrders: Array>; constructor(frameCount: number); getPropertyId(): number; getFrameCount(): number; setFrame(frameIndex: number, time: number, drawOrder: Array): void; apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } 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; constructor(frameCount: number); getPropertyId(): number; setFrame(frameIndex: number, time: number, mix: number, bendDirection: number, compress: boolean, stretch: boolean): void; apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } 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; constructor(frameCount: number); getPropertyId(): number; setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number, scaleMix: number, shearMix: number): void; apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } class PathConstraintPositionTimeline extends CurveTimeline { static ENTRIES: number; static PREV_TIME: number; static PREV_VALUE: number; static VALUE: number; pathConstraintIndex: number; frames: ArrayLike; constructor(frameCount: number); getPropertyId(): number; setFrame(frameIndex: number, time: number, value: number): void; apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } class PathConstraintSpacingTimeline extends PathConstraintPositionTimeline { constructor(frameCount: number); getPropertyId(): number; apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } 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; constructor(frameCount: number); getPropertyId(): number; setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number): void; apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array, alpha: number, blend: MixBlend, direction: MixDirection): void; } } declare module PIXI.spine.core { class AnimationState { static emptyAnimation: Animation; static SUBSEQUENT: number; static FIRST: number; static HOLD: number; static HOLD_MIX: number; data: AnimationStateData; tracks: TrackEntry[]; events: Event[]; listeners: AnimationStateListener2[]; queue: EventQueue; propertyIDs: IntSet; animationsChanged: boolean; timeScale: number; trackEntryPool: Pool; 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, 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: AnimationStateListener2): void; removeListener(listener: AnimationStateListener2): 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; } class TrackEntry { animation: Animation; next: TrackEntry; mixingFrom: TrackEntry; mixingTo: TrackEntry; listener: AnimationStateListener2; 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; time: number; endTime: number; loopsCount(): number; } class EventQueue { objects: Array; 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; } enum EventType { start = 0, interrupt = 1, end = 2, dispose = 3, complete = 4, event = 5 } interface AnimationStateListener2 { 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; } abstract class AnimationStateAdapter2 implements AnimationStateListener2 { 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; } } declare module PIXI.spine.core { class AnimationStateData { skeletonData: SkeletonData; animationToMixTime: Map; 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; } } declare module PIXI.spine.core { class AtlasAttachmentLoader implements AttachmentLoader { atlas: TextureAtlas; constructor(atlas: TextureAtlas); newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment; newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment; newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment; newPathAttachment(skin: Skin, name: string): PathAttachment; newPointAttachment(skin: Skin, name: string): PointAttachment; newClippingAttachment(skin: Skin, name: string): ClippingAttachment; } } declare module PIXI.spine.core { abstract class Attachment { name: string; constructor(name: string); } abstract class VertexAttachment extends Attachment { private static nextID; id: number; bones: Array; vertices: ArrayLike; worldVerticesLength: number; constructor(name: string); computeWorldVerticesOld(slot: Slot, worldVertices: ArrayLike): void; computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike, offset: number, stride: number): void; applyDeform(sourceAttachment: VertexAttachment): boolean; } } declare module PIXI.spine.core { interface AttachmentLoader { newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment; newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment; newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment; newPathAttachment(skin: Skin, name: string): PathAttachment; newPointAttachment(skin: Skin, name: string): PointAttachment; newClippingAttachment(skin: Skin, name: string): ClippingAttachment; } } declare module PIXI.spine.core { enum AttachmentType { Region = 0, BoundingBox = 1, Mesh = 2, LinkedMesh = 3, Path = 4, Point = 5 } } declare module PIXI.spine.core { class BoundingBoxAttachment extends VertexAttachment { color: Color; constructor(name: string); } } declare module PIXI.spine.core { class ClippingAttachment extends VertexAttachment { endSlot: SlotData; color: Color; constructor(name: string); } } declare module PIXI.spine.core { class MeshAttachment extends VertexAttachment { region: TextureRegion; path: string; regionUVs: ArrayLike; uvs: ArrayLike; triangles: Array; color: Color; hullLength: number; private parentMesh; inheritDeform: boolean; tempColor: Color; constructor(name: string); updateUVs(region: TextureRegion, uvs: ArrayLike): ArrayLike; applyDeform(sourceAttachment: VertexAttachment): boolean; getParentMesh(): MeshAttachment; setParentMesh(parentMesh: MeshAttachment): void; } } declare module PIXI.spine.core { class PathAttachment extends VertexAttachment { lengths: Array; closed: boolean; constantSpeed: boolean; color: Color; constructor(name: string); } } declare module PIXI.spine.core { class PointAttachment extends VertexAttachment { x: number; y: number; rotation: number; color: Color; constructor(name: string); computeWorldPosition(bone: Bone, point: Vector2): Vector2; computeWorldRotation(bone: Bone): number; } } declare module PIXI.spine.core { class RegionAttachment extends Attachment { 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: ArrayLike; uvs: ArrayLike; tempColor: Color; constructor(name: string); updateOffset(): void; setRegion(region: TextureRegion): void; computeWorldVertices(bone: Bone, worldVertices: ArrayLike, offset: number, stride: number): void; } } declare module PIXI.spine.core { enum BlendMode { Normal = 0, Additive = 1, Multiply = 2, Screen = 3 } } declare module PIXI.spine.core { class Bone implements Updatable { static yDown: boolean; matrix: PIXI.Matrix; readonly worldX: number; readonly 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; constructor(data: BoneData, skeleton: Skeleton, parent: Bone); update(): void; updateWorldTransform(): void; 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; updateAppliedTransform(): void; worldToLocal(world: Vector2): Vector2; localToWorld(local: Vector2): Vector2; worldToLocalRotation(worldRotation: number): number; localToWorldRotation(localRotation: number): number; rotateWorld(degrees: number): void; } } declare module PIXI.spine.core { 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); } enum TransformMode { Normal = 0, OnlyTranslation = 1, NoRotationOrReflection = 2, NoScale = 3, NoScaleOrReflection = 4 } } declare module PIXI.spine.core { interface Constraint extends Updatable { getOrder(): number; } } declare module PIXI.spine.core { class Event { data: EventData; intValue: number; floatValue: number; stringValue: string; time: number; volume: number; balance: number; constructor(time: number, data: EventData); } } declare module PIXI.spine.core { class EventData { name: string; intValue: number; floatValue: number; stringValue: string; audioPath: string; volume: number; balance: number; constructor(name: string); } } declare module PIXI.spine.core { class IkConstraint implements Constraint { data: IkConstraintData; bones: Array; target: Bone; bendDirection: number; compress: boolean; stretch: boolean; mix: number; constructor(data: IkConstraintData, skeleton: Skeleton); getOrder(): number; apply(): void; update(): void; apply1(bone: Bone, targetX: number, targetY: number, compress: boolean, stretch: boolean, uniform: boolean, alpha: number): void; apply2(parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, stretch: boolean, alpha: number): void; } } declare module PIXI.spine.core { class IkConstraintData { name: string; order: number; bones: BoneData[]; target: BoneData; bendDirection: number; compress: boolean; stretch: boolean; uniform: boolean; mix: number; constructor(name: string); } } declare module PIXI.spine.core { class PathConstraint implements Constraint { static NONE: number; static BEFORE: number; static AFTER: number; static epsilon: number; data: PathConstraintData; bones: Array; target: Slot; position: number; spacing: number; rotateMix: number; translateMix: number; spaces: number[]; positions: number[]; world: number[]; curves: number[]; lengths: number[]; segments: number[]; constructor(data: PathConstraintData, skeleton: Skeleton); apply(): void; update(): void; computeWorldPositions(path: PathAttachment, spacesCount: number, tangents: boolean, percentPosition: boolean, percentSpacing: boolean): number[]; addBeforePosition(p: number, temp: Array, i: number, out: Array, o: number): void; addAfterPosition(p: number, temp: Array, i: number, out: Array, o: number): void; addCurvePosition(p: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, out: Array, o: number, tangents: boolean): void; getOrder(): number; } } declare module PIXI.spine.core { class PathConstraintData { name: string; order: number; bones: BoneData[]; target: SlotData; positionMode: PositionMode; spacingMode: SpacingMode; rotateMode: RotateMode; offsetRotation: number; position: number; spacing: number; rotateMix: number; translateMix: number; constructor(name: string); } enum PositionMode { Fixed = 0, Percent = 1 } enum SpacingMode { Length = 0, Fixed = 1, Percent = 2 } enum RotateMode { Tangent = 0, Chain = 1, ChainScale = 2 } } declare module PIXI.spine.core { class Skeleton { data: SkeletonData; bones: Array; slots: Array; drawOrder: Array; ikConstraints: Array; transformConstraints: Array; pathConstraints: Array; _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): void; updateWorldTransform(): void; setToSetupPose(): void; setBonesToSetupPose(): void; setSlotsToSetupPose(): void; getRootBone(): Bone; findBone(boneName: string): Bone; findBoneIndex(boneName: string): number; findSlot(slotName: string): Slot; findSlotIndex(slotName: string): number; setSkinByName(skinName: string): void; setSkin(newSkin: Skin | null): void; getAttachmentByName(slotName: string, attachmentName: string): Attachment; getAttachment(slotIndex: number, attachmentName: string): Attachment; setAttachment(slotName: string, attachmentName: string): void; findIkConstraint(constraintName: string): IkConstraint; findTransformConstraint(constraintName: string): TransformConstraint; findPathConstraint(constraintName: string): PathConstraint; getBounds(offset: Vector2, size: Vector2, temp: Array): void; update(delta: number): void; flipX: boolean; flipY: boolean; private static deprecatedWarning1; } } declare module PIXI.spine.core { class SkeletonBounds { minX: number; minY: number; maxX: number; maxY: number; boundingBoxes: BoundingBoxAttachment[]; polygons: ArrayLike[]; private polygonPool; update(skeleton: Skeleton, updateAabb: boolean): void; aabbCompute(): void; aabbContainsPoint(x: number, y: number): boolean; aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean; aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean; containsPoint(x: number, y: number): BoundingBoxAttachment; containsPointPolygon(polygon: ArrayLike, x: number, y: number): boolean; intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment; intersectsSegmentPolygon(polygon: ArrayLike, x1: number, y1: number, x2: number, y2: number): boolean; getPolygon(boundingBox: BoundingBoxAttachment): ArrayLike; getWidth(): number; getHeight(): number; } } declare module PIXI.spine.core { 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, verticesLength: number, triangles: ArrayLike, trianglesLength: number, uvs: ArrayLike, light: Color, dark: Color, twoColor: boolean): void; clip(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, clippingArea: Array, output: Array): boolean; static makeClockwise(polygon: ArrayLike): void; } } declare module PIXI.spine.core { class SkeletonData { name: string; bones: BoneData[]; slots: SlotData[]; skins: Skin[]; defaultSkin: Skin; events: EventData[]; animations: Animation[]; ikConstraints: IkConstraintData[]; transformConstraints: TransformConstraintData[]; pathConstraints: PathConstraintData[]; width: number; height: number; version: string; hash: string; fps: number; imagesPath: 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; } } declare module PIXI.spine.core { 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): BlendMode; static positionModeFromString(str: string): PositionMode; static spacingModeFromString(str: string): SpacingMode; static rotateModeFromString(str: string): RotateMode; static transformModeFromString(str: string): TransformMode; } } declare module PIXI.spine.core { class Skin { name: string; attachments: Map[]; constructor(name: string); addAttachment(slotIndex: number, name: string, attachment: Attachment): void; getAttachment(slotIndex: number, name: string): Attachment; attachAll(skeleton: Skeleton, oldSkin: Skin): void; } } declare module PIXI.spine.core { class Slot { currentMesh: any; currentSprite: any; currentGraphics: any; clippingContainer: any; meshes: any; currentMeshName: string; sprites: any; currentSpriteName: string; blendMode: number; tempRegion: TextureRegion; tempAttachment: Attachment; data: SlotData; bone: Bone; color: Color; darkColor: Color; attachment: Attachment; private attachmentTime; attachmentVertices: number[]; constructor(data: SlotData, bone: Bone); getAttachment(): Attachment; setAttachment(attachment: Attachment): void; setAttachmentTime(time: number): void; getAttachmentTime(): number; setToSetupPose(): void; } } declare module PIXI.spine.core { class SlotData { index: number; name: string; boneData: BoneData; color: Color; darkColor: Color; attachmentName: string; blendMode: BlendMode; constructor(index: number, name: string, boneData: BoneData); } } declare module PIXI.spine.core { abstract class Texture { protected _image: HTMLImageElement; constructor(image: HTMLImageElement); getImage(): HTMLImageElement; abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void; abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void; abstract dispose(): void; static filterFromString(text: string): TextureFilter; static wrapFromString(text: string): TextureWrap; } enum TextureFilter { Nearest = 9728, Linear = 9729, MipMap = 9987, MipMapNearestNearest = 9984, MipMapLinearNearest = 9985, MipMapNearestLinear = 9986, MipMapLinearLinear = 9987 } enum TextureWrap { MirroredRepeat = 33648, ClampToEdge = 33071, Repeat = 10497 } class TextureRegion { texture: PIXI.Texture; size: PIXI.Rectangle; readonly width: number; readonly height: number; readonly u: number; readonly v: number; readonly u2: number; readonly v2: number; readonly offsetX: number; readonly offsetY: number; readonly pixiOffsetY: number; readonly spineOffsetY: number; readonly originalWidth: number; readonly originalHeight: number; readonly x: number; readonly y: number; readonly rotate: boolean; } } declare module PIXI.spine.core { class TextureAtlas implements Disposable { pages: TextureAtlasPage[]; regions: TextureAtlasRegion[]; constructor(atlasText?: string, textureLoader?: (path: string, loaderFunction: (tex: PIXI.BaseTexture) => any) => any, callback?: (obj: TextureAtlas) => any); addTexture(name: string, texture: PIXI.Texture): TextureAtlasRegion; addTextureHash(textures: Map, stripExtension: boolean): void; addSpineAtlas(atlasText: string, textureLoader: (path: string, loaderFunction: (tex: PIXI.BaseTexture) => any) => any, callback: (obj: TextureAtlas) => any): void; private load; findRegion(name: string): TextureAtlasRegion; dispose(): void; } class TextureAtlasPage { name: string; minFilter: TextureFilter; magFilter: TextureFilter; uWrap: TextureWrap; vWrap: TextureWrap; baseTexture: PIXI.BaseTexture; width: number; height: number; setFilters(): void; } class TextureAtlasRegion extends TextureRegion { page: TextureAtlasPage; name: string; index: number; } } declare module PIXI.spine.core { class TransformConstraint implements Constraint { data: TransformConstraintData; bones: Array; target: Bone; rotateMix: number; translateMix: number; scaleMix: number; shearMix: number; temp: Vector2; constructor(data: TransformConstraintData, skeleton: Skeleton); apply(): void; update(): void; applyAbsoluteWorld(): void; applyRelativeWorld(): void; applyAbsoluteLocal(): void; applyRelativeLocal(): void; getOrder(): number; } } declare module PIXI.spine.core { class TransformConstraintData { name: string; order: number; 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); } } declare module PIXI.spine.core { class Triangulator { private convexPolygons; private convexPolygonsIndices; private indicesArray; private isConcaveArray; private triangles; private polygonPool; private polygonIndicesPool; triangulate(verticesArray: ArrayLike): Array; decompose(verticesArray: Array, triangles: Array): Array>; private static isConcave; private static positiveArea; private static winding; } } declare module PIXI.spine.core { interface Updatable { update(): void; } } declare module PIXI.spine.core { interface Map { [key: string]: T; } class IntSet { array: number[]; add(value: number): boolean; contains(value: number): boolean; remove(value: number): void; clear(): void; } interface Disposable { dispose(): void; } interface Restorable { restore(): void; } class Color { r: number; g: number; b: number; a: number; static WHITE: Color; static RED: Color; static GREEN: Color; static BLUE: Color; static MAGENTA: Color; constructor(r?: number, g?: number, b?: number, a?: number); set(r: number, g: number, b: number, a: number): this; setFromColor(c: Color): this; setFromString(hex: string): this; add(r: number, g: number, b: number, a: number): this; clamp(): this; } class MathUtils { static PI: number; static PI2: number; static radiansToDegrees: number; static radDeg: number; static degreesToRadians: number; static degRad: number; static clamp(value: number, min: number, max: number): number; static cosDeg(degrees: number): number; static sinDeg(degrees: number): number; static signum(value: number): number; static toInt(x: number): number; static cbrt(x: number): number; static randomTriangular(min: number, max: number): number; static randomTriangularWith(min: number, max: number, mode: number): number; } abstract class Interpolation { protected abstract applyInternal(a: number): number; apply(start: number, end: number, a: number): number; } class Pow extends Interpolation { protected power: number; constructor(power: number); applyInternal(a: number): number; } class PowOut extends Pow { constructor(power: number); applyInternal(a: number): number; } class Utils { static SUPPORTS_TYPED_ARRAYS: boolean; static arrayCopy(source: ArrayLike, sourceStart: number, dest: ArrayLike, destStart: number, numElements: number): void; static setArraySize(array: Array, size: number, value?: any): Array; static ensureArrayCapacity(array: Array, size: number, value?: any): Array; static newArray(size: number, defaultValue: T): Array; static newFloatArray(size: number): ArrayLike; static newShortArray(size: number): ArrayLike; static toFloatArray(array: Array): number[] | Float32Array; static toSinglePrecision(value: number): number; static webkit602BugfixHelper(alpha: number, blend: MixBlend): void; } class DebugUtils { static logBones(skeleton: Skeleton): void; } class Pool { private items; private instantiator; constructor(instantiator: () => T); obtain(): T; free(item: T): void; freeAll(items: ArrayLike): void; clear(): void; } class Vector2 { x: number; y: number; constructor(x?: number, y?: number); set(x: number, y: number): Vector2; length(): number; normalize(): this; } class TimeKeeper { maxDelta: number; framesPerSecond: number; delta: number; totalTime: number; private lastTime; private frameCount; private frameTime; update(): void; } interface ArrayLike { length: number; [n: number]: T; } class WindowedMean { values: Array; addedValues: number; lastValue: number; mean: number; dirty: boolean; constructor(windowSize?: number); hasEnoughData(): boolean; addValue(value: number): void; getMean(): number; } } declare module PIXI.spine.core { interface VertexEffect { begin(skeleton: Skeleton): void; transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void; end(): void; } } declare module PIXI.spine.core { 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; } } declare module PIXI.spine.core { 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; } } declare module PIXI.spine { } declare module PIXI.spine { function atlasParser(): (resource: PIXI.loaders.Resource, next: () => any) => any; function imageLoaderAdapter(loader: any, namePrefix: any, baseUrl: any, imageOptions: any): (line: string, callback: (baseTexture: PIXI.BaseTexture) => any) => void; function syncImageLoaderAdapter(baseUrl: any, crossOrigin: any): (line: any, callback: any) => void; function staticImageLoader(pages: { [key: string]: (PIXI.BaseTexture | PIXI.Texture); }): (line: any, callback: any) => void; } interface Math { fround(n: number): number; } declare module PIXI.spine { class SpineSprite extends PIXI.Sprite { region: core.TextureRegion; } class SpineMesh extends PIXI.mesh.Mesh { region: core.TextureRegion; constructor(texture: PIXI.Texture, vertices?: Float32Array, uvs?: Float32Array, indices?: Uint16Array, drawMode?: number); } class Spine extends PIXI.Container { static globalAutoUpdate: boolean; static globalDelayLimit: number; tintRgb: ArrayLike; spineData: core.SkeletonData; skeleton: core.Skeleton; stateData: core.AnimationStateData; state: core.AnimationState; slotContainers: Array; tempClipContainers: Array; localDelayLimit: number; constructor(spineData: core.SkeletonData); autoUpdate: boolean; tint: number; readonly delayLimit: number; update(dt: number): void; private setSpriteRegion; private setMeshRegion; protected lastTime: number; autoUpdateTransform(): void; createSprite(slot: core.Slot, attachment: core.RegionAttachment, defName: string): SpineSprite; createMesh(slot: core.Slot, attachment: core.MeshAttachment): SpineMesh; static clippingPolygon: Array; createGraphics(slot: core.Slot, clip: core.ClippingAttachment): PIXI.Graphics; updateGraphics(slot: core.Slot, clip: core.ClippingAttachment): void; hackTextureBySlotIndex(slotIndex: number, texture?: PIXI.Texture, size?: PIXI.Rectangle): boolean; hackTextureBySlotName(slotName: string, texture?: PIXI.Texture, size?: PIXI.Rectangle): boolean; newContainer(): PIXI.Container; newSprite(tex: PIXI.Texture): SpineSprite; newGraphics(): PIXI.Graphics; newMesh(texture: PIXI.Texture, vertices?: Float32Array, uvs?: Float32Array, indices?: Uint16Array, drawMode?: number): SpineMesh; transformHack(): number; hackAttachmentGroups(nameSuffix: string, group: any, outGroup: any): any[][]; destroy(options?: PIXI.DestroyOptions | boolean): void; } }