import * as pixi_js from 'pixi.js';
import { Application as Application$1, ColorSource, ApplicationOptions, GpuPowerPreference, UnresolvedAsset as UnresolvedAsset$1, TextureOptions, PointData, Renderer, ContainerChild, ContainerEvents, Texture, Container, Filter, ViewContainerOptions, DOMContainer, DOMContainerOptions, RenderContainer, RenderContainerOptions, Particle, ParticleOptions, PerspectiveMesh, PerspectivePlaneOptions, ParticleContainer, ParticleContainerOptions, FilterOptions, AlphaFilter, AlphaFilterOptions, BlurFilter, BlurFilterOptions, BlurFilterPass, BlurFilterPassOptions, ColorMatrixFilter, DisplacementFilter, DisplacementFilterOptions, MaskFilter, MaskFilterOptions, NoiseFilter, NoiseFilterOptions, BitmapTextGraphics, GraphicsOptions, Graphics, Mesh, MeshOptions, Geometry, Shader, MeshPlane, MeshPlaneOptions, MeshRope, MeshRopeOptions, MeshSimple, SimpleMeshOptions, RenderLayer, Sprite, SpriteOptions, AnimatedSprite, AnimatedSpriteOptions, NineSliceSprite, NineSliceSpriteOptions, TilingSprite, TilingSpriteOptions, Text, TextOptions, SplitText, SplitTextOptions, BitmapText, SplitBitmapText, SplitBitmapTextOptions, HTMLText, HTMLTextOptions, TickerCallback, Rectangle, ContainerOptions } from 'pixi.js';
import * as vue_demi from 'vue-demi';
import { PropType, ExtractPropTypes, DefineComponent, ComponentOptionsMixin, VNodeProps, VNode, Renderer as Renderer$1, RendererOptions as RendererOptions$1, InjectionKey, Ref, ToRef, ElementNamespace } from 'vue-demi';
import { AnyFn, MaybeRefOrGetter } from '@vueuse/core';
import { C as CubicBezierPoints, E as EasingFunction } from './global.js';
export { e as AnimatedTransition, f as AnimatedTransitionGroup, A as Assets, c as AssetsBundle, d as External, P as PixiMatrix, g as PixiVars, T as TransitionProps, h as TransitionTicker, i as TransitionVars, b as assetsBundleProps, a as assetsProps } from './global.js';
export { compilerOptions } from './compiler.js';
import { Awaitable } from '@antfu/utils';

interface Application {
    canvas: HTMLCanvasElement;
    app: Application$1;
}
declare const Application: vue_demi.DefineComponent<vue_demi.ExtractPropTypes<{
    antialias: {
        type: BooleanConstructor;
        default: undefined;
    };
    autoDensity: {
        type: BooleanConstructor;
        default: undefined;
    };
    autoStart: {
        type: BooleanConstructor;
        default: boolean;
    };
    alpha: {
        type: BooleanConstructor;
        default: undefined;
    };
    background: PropType<ColorSource>;
    backgroundColor: PropType<ColorSource>;
    backgroundAlpha: {
        type: NumberConstructor;
        default: number;
    };
    clearBeforeRender: {
        type: BooleanConstructor;
        default: undefined;
    };
    hello: {
        type: BooleanConstructor;
        default: undefined;
    };
    textureGCActive: {
        type: BooleanConstructor;
        default: undefined;
    };
    textureGCAMaxIdle: {
        type: NumberConstructor;
        default: undefined;
    };
    textureGCCheckCountMax: {
        type: NumberConstructor;
        default: undefined;
    };
    bezierSmoothness: {
        type: NumberConstructor;
        default: undefined;
    };
    premultipliedAlpha: {
        type: BooleanConstructor;
        default: undefined;
    };
    preserveDrawingBuffer: {
        type: BooleanConstructor;
        default: undefined;
    };
    forceFallbackAdapter: {
        type: BooleanConstructor;
        default: undefined;
    };
    depth: {
        type: BooleanConstructor;
        default: undefined;
    };
    failIfMajorPerformanceCaveat: {
        type: BooleanConstructor;
        default: undefined;
    };
    preference: {
        type: PropType<ApplicationOptions["preference"]>;
        default: string;
    };
    powerPreference: {
        type: PropType<GpuPowerPreference>;
        default: undefined;
    };
    resizeTo: PropType<HTMLElement | Window | undefined>;
    roundPixels: {
        type: BooleanConstructor;
        default: undefined;
    };
    useBackBuffer: {
        type: BooleanConstructor;
        default: undefined;
    };
    width: {
        type: (StringConstructor | NumberConstructor)[];
        default: undefined;
    };
    height: {
        type: (StringConstructor | NumberConstructor)[];
        default: undefined;
    };
    resolution: {
        type: NumberConstructor;
        default: number;
    };
}>, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{
    antialias: {
        type: BooleanConstructor;
        default: undefined;
    };
    autoDensity: {
        type: BooleanConstructor;
        default: undefined;
    };
    autoStart: {
        type: BooleanConstructor;
        default: boolean;
    };
    alpha: {
        type: BooleanConstructor;
        default: undefined;
    };
    background: PropType<ColorSource>;
    backgroundColor: PropType<ColorSource>;
    backgroundAlpha: {
        type: NumberConstructor;
        default: number;
    };
    clearBeforeRender: {
        type: BooleanConstructor;
        default: undefined;
    };
    hello: {
        type: BooleanConstructor;
        default: undefined;
    };
    textureGCActive: {
        type: BooleanConstructor;
        default: undefined;
    };
    textureGCAMaxIdle: {
        type: NumberConstructor;
        default: undefined;
    };
    textureGCCheckCountMax: {
        type: NumberConstructor;
        default: undefined;
    };
    bezierSmoothness: {
        type: NumberConstructor;
        default: undefined;
    };
    premultipliedAlpha: {
        type: BooleanConstructor;
        default: undefined;
    };
    preserveDrawingBuffer: {
        type: BooleanConstructor;
        default: undefined;
    };
    forceFallbackAdapter: {
        type: BooleanConstructor;
        default: undefined;
    };
    depth: {
        type: BooleanConstructor;
        default: undefined;
    };
    failIfMajorPerformanceCaveat: {
        type: BooleanConstructor;
        default: undefined;
    };
    preference: {
        type: PropType<ApplicationOptions["preference"]>;
        default: string;
    };
    powerPreference: {
        type: PropType<GpuPowerPreference>;
        default: undefined;
    };
    resizeTo: PropType<HTMLElement | Window | undefined>;
    roundPixels: {
        type: BooleanConstructor;
        default: undefined;
    };
    useBackBuffer: {
        type: BooleanConstructor;
        default: undefined;
    };
    width: {
        type: (StringConstructor | NumberConstructor)[];
        default: undefined;
    };
    height: {
        type: (StringConstructor | NumberConstructor)[];
        default: undefined;
    };
    resolution: {
        type: NumberConstructor;
        default: number;
    };
}>> & Readonly<{}>, {
    hello: boolean;
    width: string | number;
    height: string | number;
    alpha: boolean;
    antialias: boolean;
    resolution: number;
    preference: "webgl" | "webgpu" | undefined;
    autoDensity: boolean;
    depth: boolean;
    backgroundAlpha: number;
    clearBeforeRender: boolean;
    textureGCActive: boolean;
    textureGCAMaxIdle: number;
    textureGCCheckCountMax: number;
    useBackBuffer: boolean;
    powerPreference: GpuPowerPreference;
    premultipliedAlpha: boolean;
    preserveDrawingBuffer: boolean;
    forceFallbackAdapter: boolean;
    autoStart: boolean;
    bezierSmoothness: number;
    failIfMajorPerformanceCaveat: boolean;
    roundPixels: boolean;
}, {}, {}, {}, string, vue_demi.ComponentProvideOptions, true, {}, any>;

interface ImportedAsset {
    default: string;
}
type UnresolvedAsset = UnresolvedAsset$1 & {
    data?: any;
};
type UnresolvedAssetAwaitable = Awaitable<string | ImportedAsset | UnresolvedAsset>;
type UnresolvedAssetArray = (UnresolvedAssetAwaitable | [string, UnresolvedAssetAwaitable])[];
type UnresolvedAssetObject = Record<string, UnresolvedAssetAwaitable>;
type UnresolvedAssets = UnresolvedAssetObject | UnresolvedAssetArray;
declare const loaderProps: {
    onResolved: PropType<(textures: any) => void>;
    onProgress: PropType<(progress: number) => void>;
    resources: {
        type: PropType<UnresolvedAssets>;
        required: true;
    };
    options: {
        type: PropType<TextureOptions>;
        default: () => {};
    };
    bundleIds: StringConstructor;
};
type LoaderProps = ExtractPropTypes<typeof loaderProps>;
declare const Loader: vue_demi.DefineComponent<ExtractPropTypes<{
    onResolved: PropType<(textures: any) => void>;
    onProgress: PropType<(progress: number) => void>;
    resources: {
        type: PropType<UnresolvedAssets>;
        required: true;
    };
    options: {
        type: PropType<TextureOptions>;
        default: () => {};
    };
    bundleIds: StringConstructor;
}>, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<ExtractPropTypes<{
    onResolved: PropType<(textures: any) => void>;
    onProgress: PropType<(progress: number) => void>;
    resources: {
        type: PropType<UnresolvedAssets>;
        required: true;
    };
    options: {
        type: PropType<TextureOptions>;
        default: () => {};
    };
    bundleIds: StringConstructor;
}>> & Readonly<{}>, {
    options: TextureOptions<pixi_js.TextureSource<any>>;
}, {}, {}, {}, string, vue_demi.ComponentProvideOptions, true, {}, any>;

declare const _EasePresets: {
    readonly easeInSine: readonly [0.12, 0, 0.39, 0];
    readonly easeOutSine: readonly [0.61, 1, 0.88, 1];
    readonly easeInOutSine: readonly [0.37, 0, 0.63, 1];
    readonly easeInQuad: readonly [0.11, 0, 0.5, 0];
    readonly easeOutQuad: readonly [0.5, 1, 0.89, 1];
    readonly easeInOutQuad: readonly [0.45, 0, 0.55, 1];
    readonly easeInCubic: readonly [0.32, 0, 0.67, 0];
    readonly easeOutCubic: readonly [0.33, 1, 0.68, 1];
    readonly easeInOutCubic: readonly [0.65, 0, 0.35, 1];
    readonly easeInQuart: readonly [0.5, 0, 0.75, 0];
    readonly easeOutQuart: readonly [0.25, 1, 0.5, 1];
    readonly easeInOutQuart: readonly [0.76, 0, 0.24, 1];
    readonly easeInQuint: readonly [0.64, 0, 0.78, 0];
    readonly easeOutQuint: readonly [0.22, 1, 0.36, 1];
    readonly easeInOutQuint: readonly [0.83, 0, 0.17, 1];
    readonly easeInExpo: readonly [0.7, 0, 0.84, 0];
    readonly easeOutExpo: readonly [0.16, 1, 0.3, 1];
    readonly easeInOutExpo: readonly [0.87, 0, 0.13, 1];
    readonly easeInCirc: readonly [0.55, 0, 1, 0.45];
    readonly easeOutCirc: readonly [0, 0.55, 0.45, 1];
    readonly easeInOutCirc: readonly [0.85, 0, 0.15, 1];
    readonly easeInBack: readonly [0.36, 0, 0.66, -0.56];
    readonly easeOutBack: readonly [0.34, 1.56, 0.64, 1];
    readonly easeInOutBack: readonly [0.68, -0.6, 0.32, 1.6];
};
/**
 * Common transitions
 *
 * @see https://easings.net
 */
declare const EasePresets: Record<keyof typeof _EasePresets, CubicBezierPoints> & {
    linear: EasingFunction;
};

type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
type OmitBy<T, U> = {
    [K in keyof T as T[K] extends U ? never : K]: T[K];
};
type Point<Key extends string> = {
    [K in Key]?: Partial<PointData> | number | [number, number];
} & {
    [K in `${Key}X`]?: number;
} & {
    [K in `${Key}Y`]?: number;
};

interface AllowedContainerEvents<C extends ContainerChild = ContainerChild> extends ContainerEvents<C> {
}
type ExtractContainerEvents<T, U = {}> = Overwrite<AllowedContainerEvents, {
    effect: [T];
    render: [T, Renderer];
} & U>;
type ExtractFilterEvents<T, U = {}> = Overwrite<{
    effect: [T];
}, U>;

type NormalizeTexture = Texture | string;

type AllowedPointsAttributes = Point<'position'> & Point<'anchor'> & Point<'scale'> & Point<'skew'> & Point<'pivot'>;
interface OptionsOverrides {
    texture: NormalizeTexture;
    textures: any;
}
type AllowedContainerAttributes = Overwrite<Container, AllowedPointsAttributes>;
type AllowedContainerProps = ExtractProps<AllowedContainerAttributes>;
interface AllowedFilterProps extends Partial<Omit<Filter, 'destroy'>> {
    is?: (props: any) => Filter;
}
type ExtractContainerProps<T, U = {}> = ExtractProps<Overwrite<T, AllowedPointsAttributes>, U>;
type ExtractProps<T, U = {}> = Overwrite<Partial<Omit<OmitBy<Omit<T, `on${string}`>, AnyFn>, `_${string}`>>, U>;
type ExtractFilterProps<T, U = {}> = ExtractProps<Partial<Omit<T, keyof AllowedFilterProps | 'destroy'>> & U, AllowedPointsAttributes>;
type OmitContainerOptions<T> = Omit<T, keyof ViewContainerOptions>;
type ExtractContainerOptions<T> = OmitContainerOptions<{
    [K in keyof T]: K extends keyof OptionsOverrides ? OptionsOverrides[K] : T[K];
}>;

type DefineContainerElement<T, O = {}> = DefineElement<ExtractContainerProps<T, ExtractContainerOptions<O>>, ExtractContainerEvents<T>>;
type DefineFilterElement<T, O = {}> = DefineElement<ExtractFilterProps<T, O>, ExtractFilterEvents<T>>;
type VNodePixiMountHook = (vnode: VNode<any>) => void;
type VNodePixiUpdateHook = (vnode: VNode<any>, oldVNode: VNode<any>) => void;
type VnodePixiProps = Overwrite<VNodeProps, {
    onVnodeBeforeMount?: VNodePixiMountHook | VNodePixiMountHook[];
    onVnodeMounted?: VNodePixiMountHook | VNodePixiMountHook[];
    onVnodeBeforeUpdate?: VNodePixiUpdateHook | VNodePixiUpdateHook[];
    onVnodeUpdated?: VNodePixiUpdateHook | VNodePixiUpdateHook[];
    onVnodeBeforeUnmount?: VNodePixiMountHook | VNodePixiMountHook[];
    onVnodeUnmounted?: VNodePixiMountHook | VNodePixiMountHook[];
}>;
type DefineElement<InstanceProps = {}, Events extends {
    [key: string]: any;
} = {}> = DefineComponent<InstanceProps, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, (Extract<keyof Events, string>)[], Extract<keyof Events, string>, VnodePixiProps & InstanceProps, Readonly<InstanceProps> & {
    [key in Extract<keyof Events, string> as `on${Capitalize<key>}`]?: ((...args: Events[key]) => any) | undefined;
}, {}>;

interface VuePIXIRenderer<T = Container<ContainerChild>> extends Renderer$1<T> {
    use: (options: RendererOptions | RendererOptions[]) => void;
}
interface RendererOptions extends Partial<Omit<RendererOptions$1<any, any>, 'createText' | 'createElement'>> {
    name: string;
    createElement: (props: any) => any;
}

type DOMContainerElement = DefineContainerElement<DOMContainer, DOMContainerOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        DomContainer: DOMContainerElement;
        PixiDomContainer: DOMContainerElement;
    }
}

type RenderContainerElement = DefineContainerElement<RenderContainer, RenderContainerOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        RenderContainer: RenderContainerElement;
        PixiRenderContainer: RenderContainerElement;
    }
}

type ContainerElement = DefineElement<AllowedContainerProps, ExtractContainerEvents<Container>>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        Container: ContainerElement;
        PixiContainer: ContainerElement;
    }
}

type ParticleElement = DefineContainerElement<Particle, ParticleOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        Particle: ParticleElement;
        PixiParticle: ParticleElement;
    }
}

type PerspectiveMeshElement = DefineContainerElement<PerspectiveMesh, PerspectivePlaneOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        PerspectiveMesh: PerspectiveMeshElement;
        PixiPerspectiveMesh: PerspectiveMeshElement;
    }
}

type ParticleContainerElement = DefineContainerElement<ParticleContainer, ParticleContainerOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        ParticleContainer: ParticleContainerElement;
        PixiParticleContainer: ParticleContainerElement;
    }
}

type FilterElement = DefineFilterElement<Filter, FilterOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        Filter: FilterElement;
        PixiFilter: FilterElement;
    }
}

type AlphaFilterElement = DefineFilterElement<AlphaFilter, AlphaFilterOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        AlphaFilter: AlphaFilterElement;
        PixiAlphaFilter: AlphaFilterElement;
    }
}

type BlurFilterElement = DefineFilterElement<BlurFilter, BlurFilterOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        BlurFilter: BlurFilterElement;
        PixiBlurFilter: BlurFilterElement;
    }
}

type BlurFilterPassElement = DefineFilterElement<BlurFilterPass, BlurFilterPassOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        BlurFilterPass: BlurFilterPassElement;
        PixiBlurFilterPass: BlurFilterPassElement;
    }
}

type ColorMatrixFilterElement = DefineFilterElement<ColorMatrixFilter, FilterOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        ColorMatrixFilter: ColorMatrixFilterElement;
        PixiColorMatrixFilter: ColorMatrixFilterElement;
    }
}

type DisplacementFilterElement = DefineFilterElement<DisplacementFilter, DisplacementFilterOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        DisplacementFilter: DisplacementFilterElement;
        PixiDisplacementFilter: DisplacementFilterElement;
    }
}

type MaskFilterElement = DefineFilterElement<MaskFilter, MaskFilterOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        MaskFilter: MaskFilterElement;
        PixiMaskFilter: MaskFilterElement;
    }
}

type NoiseFilterElement = DefineFilterElement<NoiseFilter, NoiseFilterOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        NoiseFilter: NoiseFilterElement;
        PixiNoiseFilter: NoiseFilterElement;
    }
}

type BitmapTextGraphicsElement = DefineContainerElement<BitmapTextGraphics, GraphicsOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        BitmapTextGraphics: BitmapTextGraphicsElement;
        PixiBitmapTextGraphics: BitmapTextGraphicsElement;
    }
}

type GraphicsContextElement = DefineContainerElement<Graphics>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        GraphicsContext: GraphicsContextElement;
        PixiGraphicsContext: GraphicsContextElement;
    }
}

type GraphicsElement = DefineContainerElement<Graphics, GraphicsOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        Graphics: GraphicsElement;
        PixiGraphics: GraphicsElement;
    }
}

type MeshElement = DefineContainerElement<Mesh, MeshOptions<Geometry, Shader>>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        Mesh: MeshElement;
        PixiMesh: MeshElement;
    }
}

type MeshPlaneElement = DefineContainerElement<MeshPlane, MeshPlaneOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        MeshPlane: MeshPlaneElement;
        PixiMeshPlane: MeshPlaneElement;
    }
}

type MeshRopeElement = DefineContainerElement<MeshRope, MeshRopeOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        MeshRope: MeshRopeElement;
        PixiMeshRope: MeshRopeElement;
    }
}

type MeshSimpleElement = DefineContainerElement<MeshSimple, SimpleMeshOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        MeshSimple: MeshSimpleElement;
        PixiMeshSimple: MeshSimpleElement;
    }
}

type RenderLayerElement = DefineContainerElement<RenderLayer>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        RenderLayer: RenderLayerElement;
        PixiRenderLayer: RenderLayerElement;
    }
}

type SpriteElement = DefineContainerElement<Sprite, SpriteOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        Sprite: SpriteElement;
        PixiSprite: SpriteElement;
    }
}

type AnimatedSpriteElement = DefineContainerElement<AnimatedSprite, AnimatedSpriteOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        AnimatedSprite: AnimatedSpriteElement;
        PixiAnimatedSprite: AnimatedSpriteElement;
    }
}

type NineSliceSpriteElement = DefineContainerElement<NineSliceSprite, NineSliceSpriteOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        NineSliceSprite: NineSliceSpriteElement;
        PixiNineSliceSprite: NineSliceSpriteElement;
    }
}

type TilingSpriteElement = DefineContainerElement<TilingSprite, TilingSpriteOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        TilingSprite: TilingSpriteElement;
        PixiTilingSprite: TilingSpriteElement;
    }
}

type TextElement = DefineContainerElement<Text, TextOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        Text: TextElement;
        PixiText: TextElement;
    }
}

type SplitTextElement = DefineContainerElement<SplitText, SplitTextOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        SplitText: SplitTextElement;
        PixiSplitText: SplitTextElement;
    }
}

type BitmapTextElement = DefineContainerElement<BitmapText, TextOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        BitmapText: BitmapTextElement;
        PixiBitmapText: BitmapTextElement;
    }
}

type SplitBitmapTextElement = DefineContainerElement<SplitBitmapText, SplitBitmapTextOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        SplitBitmapText: SplitBitmapTextElement;
        PixiSplitBitmapText: SplitBitmapTextElement;
    }
}

type HTMLTextElement = DefineContainerElement<HTMLText, HTMLTextOptions>;
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        HTMLText: HTMLTextElement;
        PixiHTMLText: HTMLTextElement;
    }
}

declare const appInjectKey: InjectionKey<Application$1 | Ref<Application$1>>;

declare function onReady(callback: (app: Application$1) => void): void;

declare function onTick(fn: TickerCallback<any>): () => void;

declare function useApplication<T = Application$1>(): Ref<T>;

declare function useRenderer(app?: Ref<Application$1>): Ref<Renderer>;

declare function useScreen(app?: Ref<Application$1>): Ref<Rectangle>;

type Stage = Container & EventTarget;
declare function useStage(app?: Ref<Application$1<Renderer>>): Ref<Stage>;

type OmitUndef<T> = Exclude<T, undefined>;
type TrackRef<T, K extends keyof OmitUndef<T>> = T extends undefined ? ToRef<OmitUndef<T>[K] | undefined> : ToRef<OmitUndef<T>[K]>;
declare function useTrack<T, K extends keyof OmitUndef<T>>(target: MaybeRefOrGetter<T>, key: K): TrackRef<T, K>;
declare function useTrack<T, K extends keyof OmitUndef<T>>(target: MaybeRefOrGetter<T>, key: K, defaultValue: OmitUndef<T>[K]): ToRef<OmitUndef<T>[K]>;

declare class Empty extends Container {
    constructor(options?: ContainerOptions);
    _vp_empty: boolean;
}

declare function createElement(prefix: string, name: string, _?: ElementNamespace, _1?: string, props?: (VNodeProps & {
    [key: string]: any;
}) | null): any;
declare function parentNode(node: any): any;
declare function createText(text: string): any;
declare function createComment(): Empty;
declare function remove(node: Container): void;
declare function insert(child: Container, parent: Container, anchor?: Container | null): void;
declare function nextSibling(node: Container): any;
declare function setText(prefix: string, node: Container, text: string): void;
declare function patchProp(el: any, key: string, prevValue: any, nextValue: any): void;
declare const nodeOps: {
    createElement: typeof createElement;
    parentNode: typeof parentNode;
    createText: typeof createText;
    createComment: typeof createComment;
    remove: typeof remove;
    insert: typeof insert;
    nextSibling: typeof nextSibling;
    setText: typeof setText;
    patchProp: typeof patchProp;
};

declare function createRenderer(options?: {
    prefix?: string;
}): vue_demi.Renderer<Container<pixi_js.ContainerChild>>;
declare const renderer: VuePIXIRenderer;
declare const createApp: vue_demi.CreateAppFunction<Container<pixi_js.ContainerChild>>;
declare const render: vue_demi.RootRenderFunction<Container<pixi_js.ContainerChild>>;

declare const patchs: {
    skip(key: string): boolean;
    texture(el: any, key: string, _: any, nextValue: any): boolean;
    point(el: Container, key: string, prevValue: any, nextValue: any): boolean | undefined;
    boolean(el: any, key: string, prevValue: any, nextValue: any): boolean;
    default(el: any, key: string, _prevValue: any, nextValue: any): void;
    events: {
        general(el: any, key: string, prevValue: any, nextValue: any): boolean;
        effect(el: any, key: string, prevValue: any, nextValue: any): true | undefined;
    };
};

declare const setters: {
    object(el: any, key: string, prevValue: any, nextValue: any): boolean;
    unfirst(inst: any, key: string, setters: () => void): boolean;
    point(inst: any, name: string, key: string, prevValue: any, nextValue: any): boolean;
    boolean(_el: any, _key: string, _prevValue: any, nextValue: any): boolean;
    call(inst: any, key: string, setter: () => void): boolean;
    texture: {
        options(texture: any, options: any): void;
    };
};

declare function setTextureOptions(texture: Texture, options?: TextureOptions): void;
declare function normalizeTexture(value: Texture | string): Texture;
declare function isOn(props?: any): boolean;
declare function withThisRender(props: any): void;

export { Application, CubicBezierPoints, EasePresets, EasingFunction, ImportedAsset, Loader, LoaderProps, OmitUndef, Stage, TrackRef, UnresolvedAsset, UnresolvedAssetArray, UnresolvedAssetAwaitable, UnresolvedAssetObject, UnresolvedAssets, appInjectKey, createApp, createRenderer, isOn, loaderProps, nodeOps, normalizeTexture, onReady, onTick, patchProp, patchs, render, renderer, setTextureOptions, setters, useApplication, useRenderer, useScreen, useStage, useTrack, withThisRender };