vue-phaserjs 1.19.0

package/dist/models/emit/global/TweenEventEmitsOptions.d.ts

@@ -0,0 +1,6 @@
+import { TweenConfiguration } from '../../configuration/global/TweenConfiguration';
+import { ExtractUpdateEvent } from '../../../utils/types/ExtractUpdateEvent';
+import { UpdateEvent } from '../../../utils/types/UpdateEvent';
+export type TweenEventEmitsOptions = {
+    [P in UpdateEvent<keyof TweenConfiguration>]: [TweenConfiguration[ExtractUpdateEvent<P>]?];
+};

package/dist/models/emit/shared/GameObjectEventMapEmitsOptions.d.ts

@@ -0,0 +1,5 @@
+import { GameObjectEventMap } from '../../../utils/emit/GameObjectEventMap';
+import { Types } from 'phaser';
+export type GameObjectEventMapEmitsOptions = {
+    [P in keyof typeof GameObjectEventMap]: Types.Input.EventData[];
+};

package/dist/models/emit/shared/ShapeEventEmitsOptions.d.ts

@@ -0,0 +1,6 @@
+import { ShapeConfiguration } from '../../configuration/shared/ShapeConfiguration';
+import { ExtractUpdateEvent } from '../../../utils/types/ExtractUpdateEvent';
+import { UpdateEvent } from '../../../utils/types/UpdateEvent';
+export type ShapeEventEmitsOptions = {
+    [P in UpdateEvent<keyof ShapeConfiguration>]: [ShapeConfiguration[ExtractUpdateEvent<P>]?];
+};

package/dist/models/keys/AnimationKey.d.ts

@@ -0,0 +1,3 @@
+export interface AnimationKeyMap {
+}
+export type AnimationKey = AnimationKeyMap[keyof AnimationKeyMap];

package/dist/models/lifecycle/HookArgs.d.ts

@@ -0,0 +1,2 @@
+import { SceneWithPlugins } from '../scene/SceneWithPlugins';
+export type HookArgs = [listener: (scene: SceneWithPlugins) => void, sceneKey?: SceneWithPlugins["scene"]["key"]];

package/dist/models/lifecycle/Lifecycle.d.ts

@@ -0,0 +1,8 @@
+export declare enum Lifecycle {
+    Create = "Create",
+    Init = "Init",
+    NextTick = "NextTick",
+    Preload = "Preload",
+    Shutdown = "Shutdown",
+    Update = "Update"
+}

package/dist/models/lifecycle/ListenersMap.d.ts

@@ -0,0 +1,2 @@
+import { SceneWithPlugins } from '../scene/SceneWithPlugins';
+export type ListenersMap = Map<string, ((scene: SceneWithPlugins) => void)[]>;

package/dist/models/plugins/TiledJSONExternalFile.d.ts

@@ -0,0 +1,11 @@
+import { TilemapFile } from './TilemapFile';
+import { Types, Loader } from 'phaser';
+import { TilesetFile } from './TilesetFile';
+declare const MultiFile: typeof Loader.MultiFile;
+export declare class TiledJSONExternalFile extends MultiFile {
+    files: [TilemapFile, ...TilesetFile[]];
+    constructor(loader: Loader.LoaderPlugin, key: object | string, tilemapURL?: object | string, path?: object | string, baseURL?: object | string, tilemapXhrSettings?: Types.Loader.XHRSettingsObject, tilesetXhrSettings?: Types.Loader.XHRSettingsObject);
+    addToCache(): Promise<void>;
+    onFileComplete(file: TilemapFile): void;
+}
+export {};

package/dist/models/plugins/TilemapFile.d.ts

@@ -0,0 +1,5 @@
+import { Loader } from 'phaser';
+declare const JSONFile: typeof Loader.FileTypes.JSONFile;
+export declare class TilemapFile extends JSONFile {
+}
+export {};

package/dist/models/plugins/TilesetFile.d.ts

@@ -0,0 +1,7 @@
+import { Loader } from 'phaser';
+declare const XMLFile: typeof Loader.FileTypes.XMLFile;
+export declare class TilesetFile extends XMLFile {
+    tilesetIndex: number;
+    constructor(tilesetIndex: number, ...args: ConstructorParameters<typeof XMLFile>);
+}
+export {};

package/dist/models/scene/ScenePlugins.d.ts

@@ -0,0 +1,2 @@
+export interface ScenePlugins {
+}

package/dist/models/scene/SceneProps.d.ts

@@ -0,0 +1,5 @@
+import { SceneWithPlugins } from './SceneWithPlugins';
+export interface SceneProps {
+    autoStart?: true;
+    sceneKey: SceneWithPlugins["scene"]["key"];
+}

package/dist/models/scene/SceneWithPlugins.d.ts

@@ -0,0 +1,4 @@
+import { ScenePlugins } from './ScenePlugins';
+import { Scene } from 'phaser';
+export interface SceneWithPlugins extends Scene, ScenePlugins {
+}

package/dist/models/setterMap/SetterMap.d.ts

@@ -0,0 +1,4 @@
+import { SetupContext } from 'vue';
+export type SetterMap<TConfiguration extends object, TGameObject extends object, TEmitsOptions extends Record<string, unknown[]>> = {
+    [P in keyof TConfiguration]?: (gameObject: TGameObject, emit: SetupContext<TEmitsOptions>["emit"]) => (value?: TConfiguration[P]) => void;
+};

package/dist/models/text/TextProps.d.ts

@@ -0,0 +1,6 @@
+import { TextConfiguration } from '../configuration/TextConfiguration';
+import { SetRequired } from 'type-fest';
+export interface TextProps {
+    configuration: SetRequired<Partial<TextConfiguration>, "text">;
+    immediate?: true;
+}

package/dist/plugins/registerTiledJSONExternalLoader.d.ts

@@ -0,0 +1 @@
+export declare const registerTiledJSONExternalLoader: () => void;

package/dist/store/camera.d.ts

@@ -0,0 +1,14 @@
+import { SceneWithPlugins } from '../models/scene/SceneWithPlugins';
+export declare const useCameraStore: import('pinia').StoreDefinition<"phaser/camera", import('pinia')._UnwrapAll<Pick<{
+    fadeIn: (scene: SceneWithPlugins, duration?: number | undefined, red?: number | undefined, green?: number | undefined, blue?: number | undefined, callback?: Function | undefined, context?: any) => void;
+    fadeOut: (scene: SceneWithPlugins, duration?: number | undefined, red?: number | undefined, green?: number | undefined, blue?: number | undefined, callback?: Function | undefined, context?: any) => void;
+    isFading: globalThis.Ref<boolean, boolean>;
+}, "isFading">>, Pick<{
+    fadeIn: (scene: SceneWithPlugins, duration?: number | undefined, red?: number | undefined, green?: number | undefined, blue?: number | undefined, callback?: Function | undefined, context?: any) => void;
+    fadeOut: (scene: SceneWithPlugins, duration?: number | undefined, red?: number | undefined, green?: number | undefined, blue?: number | undefined, callback?: Function | undefined, context?: any) => void;
+    isFading: globalThis.Ref<boolean, boolean>;
+}, never>, Pick<{
+    fadeIn: (scene: SceneWithPlugins, duration?: number | undefined, red?: number | undefined, green?: number | undefined, blue?: number | undefined, callback?: Function | undefined, context?: any) => void;
+    fadeOut: (scene: SceneWithPlugins, duration?: number | undefined, red?: number | undefined, green?: number | undefined, blue?: number | undefined, callback?: Function | undefined, context?: any) => void;
+    isFading: globalThis.Ref<boolean, boolean>;
+}, "fadeIn" | "fadeOut">>;

package/dist/store/index.d.ts

@@ -0,0 +1,30 @@
+import { SceneWithPlugins } from '../models/scene/SceneWithPlugins';
+import { Game } from 'phaser';
+export declare const usePhaserStore: import('pinia').StoreDefinition<"phaser", import('pinia')._UnwrapAll<Pick<{
+    game: globalThis.WritableComputedRef<Game | null, Game | null>;
+    isSameScene: (newSceneKey: SceneWithPlugins["scene"]["key"]) => boolean;
+    launchParallelScene: (scene: SceneWithPlugins, sceneKey: SceneWithPlugins["scene"]["key"]) => void;
+    parallelSceneKeys: globalThis.Ref<string[], string[]>;
+    prioritizedParallelSceneKeys: globalThis.Ref<string[], string[]>;
+    removeParallelScene: (scene: SceneWithPlugins, sceneKey: SceneWithPlugins["scene"]["key"]) => void;
+    rootSceneKey: globalThis.Ref<string, string>;
+    switchToScene: (newSceneKey: SceneWithPlugins["scene"]["key"]) => Promise<void>;
+}, "game" | "parallelSceneKeys" | "prioritizedParallelSceneKeys" | "rootSceneKey">>, Pick<{
+    game: globalThis.WritableComputedRef<Game | null, Game | null>;
+    isSameScene: (newSceneKey: SceneWithPlugins["scene"]["key"]) => boolean;
+    launchParallelScene: (scene: SceneWithPlugins, sceneKey: SceneWithPlugins["scene"]["key"]) => void;
+    parallelSceneKeys: globalThis.Ref<string[], string[]>;
+    prioritizedParallelSceneKeys: globalThis.Ref<string[], string[]>;
+    removeParallelScene: (scene: SceneWithPlugins, sceneKey: SceneWithPlugins["scene"]["key"]) => void;
+    rootSceneKey: globalThis.Ref<string, string>;
+    switchToScene: (newSceneKey: SceneWithPlugins["scene"]["key"]) => Promise<void>;
+}, never>, Pick<{
+    game: globalThis.WritableComputedRef<Game | null, Game | null>;
+    isSameScene: (newSceneKey: SceneWithPlugins["scene"]["key"]) => boolean;
+    launchParallelScene: (scene: SceneWithPlugins, sceneKey: SceneWithPlugins["scene"]["key"]) => void;
+    parallelSceneKeys: globalThis.Ref<string[], string[]>;
+    prioritizedParallelSceneKeys: globalThis.Ref<string[], string[]>;
+    removeParallelScene: (scene: SceneWithPlugins, sceneKey: SceneWithPlugins["scene"]["key"]) => void;
+    rootSceneKey: globalThis.Ref<string, string>;
+    switchToScene: (newSceneKey: SceneWithPlugins["scene"]["key"]) => Promise<void>;
+}, "isSameScene" | "launchParallelScene" | "removeParallelScene" | "switchToScene">>;

package/dist/store/input.d.ts

@@ -0,0 +1,7 @@
+export declare const useInputStore: import('pinia').StoreDefinition<"phaser/input", import('pinia')._UnwrapAll<Pick<{
+    isInputActive: globalThis.Ref<boolean, boolean>;
+}, "isInputActive">>, Pick<{
+    isInputActive: globalThis.Ref<boolean, boolean>;
+}, never>, Pick<{
+    isInputActive: globalThis.Ref<boolean, boolean>;
+}, never>>;

package/dist/store/parentContainer.d.ts

@@ -0,0 +1,8 @@
+import { GameObjects } from 'phaser';
+export declare const useParentContainerStore: import('pinia').StoreDefinition<"phaser/parentContainer", import('pinia')._UnwrapAll<Pick<{
+    pushGameObject: (parentContainer: GameObjects.Container, configuration: object, gameObject: GameObjects.GameObject) => void;
+}, never>>, Pick<{
+    pushGameObject: (parentContainer: GameObjects.Container, configuration: object, gameObject: GameObjects.GameObject) => void;
+}, never>, Pick<{
+    pushGameObject: (parentContainer: GameObjects.Container, configuration: object, gameObject: GameObjects.GameObject) => void;
+}, "pushGameObject">>;

package/dist/store/scene.d.ts

@@ -0,0 +1,6 @@
+import { Lifecycle } from '../models/lifecycle/Lifecycle';
+import { ListenersMap } from '../models/lifecycle/ListenersMap';
+export declare const ExternalSceneStore: {
+    lifecycleListenersMap: Map<Lifecycle, ListenersMap>;
+    sceneReadyMap: Map<string, boolean>;
+};

package/dist/store/text.d.ts

@@ -0,0 +1,8 @@
+import { Types } from 'phaser';
+export declare const useTextStore: import('pinia').StoreDefinition<"phaser/text", import('pinia')._UnwrapAll<Pick<{
+    defaultTextStyle: globalThis.Ref<Types.GameObjects.Text.TextStyle | undefined, Types.GameObjects.Text.TextStyle | undefined>;
+}, "defaultTextStyle">>, Pick<{
+    defaultTextStyle: globalThis.Ref<Types.GameObjects.Text.TextStyle | undefined, Types.GameObjects.Text.TextStyle | undefined>;
+}, never>, Pick<{
+    defaultTextStyle: globalThis.Ref<Types.GameObjects.Text.TextStyle | undefined, Types.GameObjects.Text.TextStyle | undefined>;
+}, never>>;

package/dist/utils/InjectionKeyMap.d.ts

@@ -0,0 +1,4 @@
+export declare const InjectionKeyMap: {
+    readonly ParentContainer: symbol;
+    readonly SceneKey: symbol;
+};

package/dist/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const TILEMAP_TILED_JSON_EXTERNAL_KEY = "tilemapTiledJSONExternal";

package/dist/utils/emit/GameObjectEventMap.d.ts

@@ -0,0 +1,42 @@
+export declare const GameObjectEventMap: {
+    readonly clickoutside: {};
+    readonly drag: {
+        readonly drag: true;
+    };
+    readonly dragend: {
+        readonly drag: true;
+    };
+    readonly dragenter: {
+        readonly drag: true;
+    };
+    readonly dragleave: {
+        readonly drag: true;
+    };
+    readonly dragover: {
+        readonly drag: true;
+    };
+    readonly dragstart: {
+        readonly drag: true;
+    };
+    readonly drop: {
+        readonly drag: true;
+    };
+    readonly pointerdown: {
+        readonly eventIndex: 3;
+    };
+    readonly pointermove: {
+        readonly eventIndex: 3;
+    };
+    readonly pointerout: {
+        readonly eventIndex: 1;
+    };
+    readonly pointerover: {
+        readonly eventIndex: 3;
+    };
+    readonly pointerup: {
+        readonly eventIndex: 3;
+    };
+    readonly wheel: {
+        readonly eventIndex: 4;
+    };
+};

package/dist/utils/emit/getEventName.d.ts

@@ -0,0 +1 @@
+export declare const getEventName: (event: string) => string;

package/dist/utils/emit/getUpdateEvent.d.ts

@@ -0,0 +1,3 @@
+import { UpdateEvent } from '../types/UpdateEvent';
+import { CamelToKebab } from '@esposter/shared';
+export declare const getUpdateEvent: <T extends string>(property: T) => UpdateEvent<CamelToKebab<T>>;

package/dist/utils/emit/isEvent.d.ts

@@ -0,0 +1 @@
+export declare const isEvent: (property: string) => boolean;

package/dist/utils/getScene.d.ts

@@ -0,0 +1,2 @@
+import { SceneWithPlugins } from '../models/scene/SceneWithPlugins';
+export declare const getScene: (sceneKey: SceneWithPlugins["scene"]["key"]) => SceneWithPlugins;

package/dist/utils/hooks/getInitializeGameObjectLifecycleHook.d.ts

@@ -0,0 +1 @@
+export declare const getInitializeGameObjectLifecycleHook: (sceneKey: string) => (listener: (scene: import('../..').SceneWithPlugins) => void, sceneKey?: string | undefined) => void;

package/dist/utils/hooks/pushListener.d.ts

@@ -0,0 +1,3 @@
+import { Lifecycle } from '../../models/lifecycle/Lifecycle';
+import { SceneWithPlugins } from '../../models/scene/SceneWithPlugins';
+export declare const pushListener: (lifecycle: Lifecycle, listener: (scene: SceneWithPlugins) => void, key?: string) => void;

package/dist/utils/hooks/resetLifecycleListeners.d.ts

@@ -0,0 +1,3 @@
+import { Lifecycle } from '../../models/lifecycle/Lifecycle';
+import { SceneWithPlugins } from '../../models/scene/SceneWithPlugins';
+export declare const resetLifecycleListeners: (scene: SceneWithPlugins, lifecycle: Lifecycle) => void;

package/dist/utils/hooks/runLifecycleListeners.d.ts

@@ -0,0 +1,3 @@
+import { Lifecycle } from '../../models/lifecycle/Lifecycle';
+import { SceneWithPlugins } from '../../models/scene/SceneWithPlugins';
+export declare const runLifecycleListeners: (scene: SceneWithPlugins, lifecycle: Lifecycle, isReset?: boolean) => void;

package/dist/utils/setterMap/ArcSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { ArcConfiguration } from '../../models/configuration/ArcConfiguration';
+import { ArcEventEmitsOptions } from '../../models/emit/ArcEventEmitsOptions';
+import { SetterMap } from '../../models/setterMap/SetterMap';
+import { GameObjects } from 'phaser';
+export declare const ArcSetterMap: SetterMap<ArcConfiguration, GameObjects.Arc, ArcEventEmitsOptions>;

package/dist/utils/setterMap/ContainerSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { ContainerConfiguration } from '../../models/configuration/ContainerConfiguration';
+import { ContainerEventEmitsOptions } from '../../models/emit/ContainerEventEmitsOptions';
+import { SetterMap } from '../../models/setterMap/SetterMap';
+import { GameObjects } from 'phaser';
+export declare const ContainerSetterMap: SetterMap<ContainerConfiguration, GameObjects.Container, ContainerEventEmitsOptions>;

package/dist/utils/setterMap/ImageSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { ImageConfiguration } from '../../models/configuration/ImageConfiguration';
+import { ImageEventEmitsOptions } from '../../models/emit/ImageEventEmitsOptions';
+import { SetterMap } from '../../models/setterMap/SetterMap';
+import { GameObjects } from 'phaser';
+export declare const ImageSetterMap: SetterMap<ImageConfiguration, GameObjects.Image, ImageEventEmitsOptions>;

package/dist/utils/setterMap/NineSliceSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { NineSliceConfiguration } from '../../models/configuration/NineSliceConfiguration';
+import { NineSliceEventEmitsOptions } from '../../models/emit/NineSliceEventEmitsOptions';
+import { SetterMap } from '../../models/setterMap/SetterMap';
+import { GameObjects } from 'phaser';
+export declare const NineSliceSetterMap: SetterMap<NineSliceConfiguration, GameObjects.NineSlice, NineSliceEventEmitsOptions>;

package/dist/utils/setterMap/PathFollowerSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { PathFollowerConfiguration } from '../../models/configuration/PathFollowerConfiguration';
+import { PathFollowerEventEmitsOptions } from '../../models/emit/PathFollowerEventEmitsOptions';
+import { SetterMap } from '../../models/setterMap/SetterMap';
+import { GameObjects } from 'phaser';
+export declare const PathFollowerSetterMap: SetterMap<PathFollowerConfiguration, GameObjects.PathFollower, PathFollowerEventEmitsOptions>;

package/dist/utils/setterMap/RectangleSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { RectangleConfiguration } from '../../models/configuration/RectangleConfiguration';
+import { RectangleEventEmitsOptions } from '../../models/emit/RectangleEventEmitsOptions';
+import { SetterMap } from '../../models/setterMap/SetterMap';
+import { GameObjects } from 'phaser';
+export declare const RectangleSetterMap: SetterMap<RectangleConfiguration, GameObjects.Rectangle, RectangleEventEmitsOptions>;

package/dist/utils/setterMap/SpriteSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { SpriteConfiguration } from '../../models/configuration/SpriteConfiguration';
+import { SpriteEventEmitsOptions } from '../../models/emit/SpriteEventEmitsOptions';
+import { SetterMap } from '../../models/setterMap/SetterMap';
+import { GameObjects } from 'phaser';
+export declare const SpriteSetterMap: SetterMap<SpriteConfiguration, GameObjects.Sprite, SpriteEventEmitsOptions>;

package/dist/utils/setterMap/TextSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { TextConfiguration } from '../../models/configuration/TextConfiguration';
+import { TextEventEmitsOptions } from '../../models/emit/TextEventEmitsOptions';
+import { SetterMap } from '../../models/setterMap/SetterMap';
+import { GameObjects } from 'phaser';
+export declare const TextSetterMap: SetterMap<TextConfiguration, GameObjects.Text, TextEventEmitsOptions>;

package/dist/utils/setterMap/TileSpriteSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { TileSpriteConfiguration } from '../../models/configuration/TileSpriteConfiguration';
+import { TileSpriteEventEmitsOptions } from '../../models/emit/TileSpriteEventEmitsOptions';
+import { SetterMap } from '../../models/setterMap/SetterMap';
+import { GameObjects } from 'phaser';
+export declare const TileSpriteSetterMap: SetterMap<TileSpriteConfiguration, GameObjects.TileSprite, TileSpriteEventEmitsOptions>;

package/dist/utils/setterMap/ZoneSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { ZoneConfiguration } from '../../models/configuration/ZoneConfiguration';
+import { ZoneEventEmitsOptions } from '../../models/emit/ZoneEventEmitsOptions';
+import { SetterMap } from '../../models/setterMap/SetterMap';
+import { GameObjects } from 'phaser';
+export declare const ZoneSetterMap: SetterMap<ZoneConfiguration, GameObjects.Zone, ZoneEventEmitsOptions>;

package/dist/utils/setterMap/components/AlphaSetterMap.d.ts

@@ -0,0 +1,8 @@
+import { GameObjects } from 'phaser';
+export declare const AlphaSetterMap: {
+    readonly alpha: (gameObject: GameObjects.Components.Alpha) => (value: number | undefined) => GameObjects.Components.Alpha;
+    readonly alphaBottomLeft: (gameObject: GameObjects.Components.Alpha) => (value: number | undefined) => GameObjects.Components.Alpha;
+    readonly alphaBottomRight: (gameObject: GameObjects.Components.Alpha) => (value: number | undefined) => GameObjects.Components.Alpha;
+    readonly alphaTopLeft: (gameObject: GameObjects.Components.Alpha) => (value: number | undefined) => GameObjects.Components.Alpha;
+    readonly alphaTopRight: (gameObject: GameObjects.Components.Alpha) => (value: number | undefined) => GameObjects.Components.Alpha;
+};

package/dist/utils/setterMap/components/AlphaSingleSetterMap.d.ts

@@ -0,0 +1,4 @@
+import { GameObjects } from 'phaser';
+export declare const AlphaSingleSetterMap: {
+    readonly alpha: (gameObject: GameObjects.Components.AlphaSingle) => (value: number | undefined) => GameObjects.Components.AlphaSingle;
+};

package/dist/utils/setterMap/components/BaseTextureSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { GameObjects } from 'phaser';
+export declare const BaseTextureSetterMap: {
+    readonly frame: (gameObject: GameObjects.Components.Texture) => (value: string | number | undefined) => void;
+    readonly texture: (gameObject: GameObjects.Components.Texture) => (value: string | undefined) => void;
+};

package/dist/utils/setterMap/components/BlendModeSetterMap.d.ts

@@ -0,0 +1,4 @@
+import { GameObjects } from 'phaser';
+export declare const BlendModeSetterMap: {
+    readonly blendMode: (gameObject: GameObjects.Components.BlendMode) => (value: string | number | Phaser.BlendModes | undefined) => void;
+};

package/dist/utils/setterMap/components/ComputedSizeSetterMap.d.ts

@@ -0,0 +1,7 @@
+import { GameObjects } from 'phaser';
+export declare const ComputedSizeSetterMap: {
+    readonly displayHeight: (gameObject: GameObjects.Components.ComputedSize) => (value: number | undefined) => void;
+    readonly displayWidth: (gameObject: GameObjects.Components.ComputedSize) => (value: number | undefined) => void;
+    readonly height: (gameObject: GameObjects.Components.ComputedSize) => (value: number | undefined) => void;
+    readonly width: (gameObject: GameObjects.Components.ComputedSize) => (value: number | undefined) => void;
+};

package/dist/utils/setterMap/components/DepthSetterMap.d.ts

@@ -0,0 +1,4 @@
+import { GameObjects } from 'phaser';
+export declare const DepthSetterMap: {
+    readonly depth: (gameObject: GameObjects.Components.Depth & GameObjects.GameObject) => (value: number | undefined) => void;
+};

package/dist/utils/setterMap/components/FXSetterMap.d.ts

@@ -0,0 +1,4 @@
+import { GameObjects } from 'phaser';
+export declare const FXSetterMap: {
+    readonly padding: (gameObject: GameObjects.Components.FX) => (value: number | undefined) => GameObjects.Components.FX;
+};

package/dist/utils/setterMap/components/FlipSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { GameObjects } from 'phaser';
+export declare const FlipSetterMap: {
+    readonly flipX: (gameObject: GameObjects.Components.Flip) => (value: boolean | undefined) => void;
+    readonly flipY: (gameObject: GameObjects.Components.Flip) => (value: boolean | undefined) => void;
+};

package/dist/utils/setterMap/components/MaskSetterMap.d.ts

@@ -0,0 +1,4 @@
+import { GameObjects } from 'phaser';
+export declare const MaskSetterMap: {
+    readonly mask: (gameObject: GameObjects.Components.Mask) => (value: Phaser.Display.Masks.BitmapMask | Phaser.Display.Masks.GeometryMask | undefined) => void;
+};

package/dist/utils/setterMap/components/OriginSetterMap.d.ts

@@ -0,0 +1,8 @@
+import { GameObjects } from 'phaser';
+export declare const OriginSetterMap: {
+    readonly displayOriginX: (gameObject: GameObjects.Components.Origin) => (value: number | undefined) => GameObjects.Components.Origin;
+    readonly displayOriginY: (gameObject: GameObjects.Components.Origin) => (value: number | undefined) => GameObjects.Components.Origin;
+    readonly origin: (gameObject: GameObjects.Components.Origin) => (value: number | undefined) => GameObjects.Components.Origin;
+    readonly originX: (gameObject: GameObjects.Components.Origin) => (value: number | undefined) => GameObjects.Components.Origin;
+    readonly originY: (gameObject: GameObjects.Components.Origin) => (value: number | undefined) => GameObjects.Components.Origin;
+};

package/dist/utils/setterMap/components/PathFollowerComponentSetterMap.d.ts

@@ -0,0 +1,4 @@
+import { GameObjects } from 'phaser';
+export declare const PathFollowerComponentSetterMap: {
+    readonly path: (gameObject: GameObjects.Components.PathFollower) => (value: Phaser.Curves.Path | undefined) => void;
+};

package/dist/utils/setterMap/components/PipelineSetterMap.d.ts

@@ -0,0 +1,4 @@
+import { GameObjects } from 'phaser';
+export declare const PipelineSetterMap: {
+    readonly pipeline: (gameObject: GameObjects.Components.Pipeline) => (value: Phaser.Renderer.WebGL.WebGLPipeline | undefined) => void;
+};

package/dist/utils/setterMap/components/ScrollFactorSetterMap.d.ts

@@ -0,0 +1,6 @@
+import { GameObjects } from 'phaser';
+export declare const ScrollFactorSetterMap: {
+    readonly scrollFactor: (gameObject: GameObjects.Components.ScrollFactor) => (value: number | undefined) => void;
+    readonly scrollFactorX: (gameObject: GameObjects.Components.ScrollFactor) => (value: number | undefined) => void;
+    readonly scrollFactorY: (gameObject: GameObjects.Components.ScrollFactor) => (value: number | undefined) => void;
+};

package/dist/utils/setterMap/components/SizeSetterMap.d.ts

@@ -0,0 +1,7 @@
+import { GameObjects } from 'phaser';
+export declare const SizeSetterMap: {
+    readonly displayHeight: (gameObject: GameObjects.Components.Size) => (value: number | undefined) => void;
+    readonly displayWidth: (gameObject: GameObjects.Components.Size) => (value: number | undefined) => void;
+    readonly height: (gameObject: GameObjects.Components.Size) => (value: number | undefined) => void;
+    readonly width: (gameObject: GameObjects.Components.Size) => (value: number | undefined) => void;
+};

package/dist/utils/setterMap/components/TextureCropSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { GameObjects } from 'phaser';
+export declare const TextureCropSetterMap: {
+    readonly frame: (gameObject: GameObjects.Components.Texture) => (value: string | number | undefined) => void;
+    readonly texture: (gameObject: GameObjects.Components.Texture) => (value: string | undefined) => void;
+};

package/dist/utils/setterMap/components/TextureSetterMap.d.ts

@@ -0,0 +1,5 @@
+import { GameObjects } from 'phaser';
+export declare const TextureSetterMap: {
+    readonly frame: (gameObject: GameObjects.Components.Texture) => (value: string | number | undefined) => void;
+    readonly texture: (gameObject: GameObjects.Components.Texture) => (value: string | undefined) => void;
+};

package/dist/utils/setterMap/components/TintSetterMap.d.ts

@@ -0,0 +1,8 @@
+import { GameObjects } from 'phaser';
+export declare const TintSetterMap: {
+    readonly tint: (gameObject: GameObjects.Components.Tint) => (value: number | undefined) => GameObjects.Components.Tint;
+    readonly tintBottomLeft: (gameObject: GameObjects.Components.Tint) => (value: number | undefined) => GameObjects.Components.Tint;
+    readonly tintBottomRight: (gameObject: GameObjects.Components.Tint) => (value: number | undefined) => GameObjects.Components.Tint;
+    readonly tintTopLeft: (gameObject: GameObjects.Components.Tint) => (value: number | undefined) => GameObjects.Components.Tint;
+    readonly tintTopRight: (gameObject: GameObjects.Components.Tint) => (value: number | undefined) => GameObjects.Components.Tint;
+};

package/dist/utils/setterMap/components/TransformSetterMap.d.ts

@@ -0,0 +1,12 @@
+import { GameObjects } from 'phaser';
+export declare const TransformSetterMap: {
+    readonly angle: (gameObject: GameObjects.Components.Transform) => (value: number | undefined) => GameObjects.Components.Transform;
+    readonly rotation: (gameObject: GameObjects.Components.Transform) => (value: number | undefined) => GameObjects.Components.Transform;
+    readonly scale: (gameObject: GameObjects.Components.Transform) => (value: number | undefined) => GameObjects.Components.Transform;
+    readonly scaleX: (gameObject: GameObjects.Components.Transform) => (value: number | undefined) => GameObjects.Components.Transform;
+    readonly scaleY: (gameObject: GameObjects.Components.Transform) => (value: number | undefined) => GameObjects.Components.Transform;
+    readonly w: (gameObject: GameObjects.Components.Transform) => (value: number | undefined) => GameObjects.Components.Transform;
+    readonly x: (gameObject: GameObjects.Components.Transform) => (value: number | undefined) => GameObjects.Components.Transform;
+    readonly y: (gameObject: GameObjects.Components.Transform) => (value: number | undefined) => GameObjects.Components.Transform;
+    readonly z: (gameObject: GameObjects.Components.Transform) => (value: number | undefined) => GameObjects.Components.Transform;
+};

package/dist/utils/setterMap/components/VisibleSetterMap.d.ts

@@ -0,0 +1,4 @@
+import { GameObjects } from 'phaser';
+export declare const VisibleSetterMap: {
+    readonly visible: (gameObject: GameObjects.Components.Visible) => (value: boolean | undefined) => void;
+};

package/dist/utils/setterMap/global/GameObjectSetterMap.d.ts

@@ -0,0 +1,4 @@
+import { GameObjects } from 'phaser';
+export declare const GameObjectSetterMap: {
+    readonly active: (gameObject: GameObjects.GameObject) => (value: boolean | undefined) => void;
+};