import * as vue_demi from 'vue-demi';
import { PropType, SlotsType, ExtractPropTypes, VNode } from 'vue-demi';
import { ResolvedAsset, ArrayOr, AssetsManifest, AssetsBundle as AssetsBundle$1 } from 'pixi.js';

/**
 * A fully resolved src, Glob patterns will not work here, and the src will be resolved to a single file.
 * @memberof assets
 * @property {string} src - The URL or relative path to the asset
 * @property {string} format - Format, usually the file extension
 * @property {string} loadParser - An override that will ensure that the asset is loaded with a specific parser
 * @property {any} data - Optional data
 */
interface ResolvedSrc {
    src: string;
    format: string;
    loadParser: string;
    data: any;
}
/**
 * A valid asset src. This can be a string, or a [ResolvedSrc]{@link assets.ResolvedSrc},
 * or an array of either.
 * @memberof assets
 */
type AssetSrc = ArrayOr<string> | (ArrayOr<ResolvedSrc>);
interface UnresolvedAsset<T = any> extends Pick<ResolvedAsset<T>, 'data' | 'format' | 'loadParser'> {
    /** Aliases associated with asset */
    alias?: ArrayOr<string>;
    /** The URL or relative path to the asset */
    src?: AssetSrc;
}

declare const assetsProps: {
    readonly basePath: StringConstructor;
    readonly alias: PropType<string | string[]>;
    /**
     * Entry for loading resources, supports multiple formats
     *
     * @type {string | string[] | ResolvedSrc | ResolvedSrc[]} Used to specify the path of the resource (URL or file path)
     * @example
     * ```vue
     * <assets alias="myAsset" :entry="'path/to/asset'" />
     * <assets alias="myAsset" :entry="{{ src: 'path/to/asset', type: 'image' }}" />
     * ```
     *
     * @type {UnresolvedAsset | UnresolvedAsset[]} Used to specify the metadata of the resource
     * @example
     * ```vue
     * <assets :entry="{ alias: 'myAsset', src: 'path/to/asset' }" />
     * <assets
     *  :entry="[
     *   { alias: 'myAsset', src: 'path/to/asset' },
     *   { alias: 'myAsset2', src: 'path/to/asset2' }
     *  ]"
     * />
     * ```
     */
    readonly entry: PropType<string | string[] | ResolvedSrc | ResolvedSrc[] | UnresolvedAsset | UnresolvedAsset[]>;
    /**
     * Whether to automatically load via `Assets.load`
     *
     * @default true
     */
    readonly autoload: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    /**
     * Destruction during component logout
     */
    readonly autounload: BooleanConstructor;
    /**
     * Callback when resources are loaded, only called when `autoload` is true
     */
    readonly onLoaded: PropType<(value: any) => void>;
    /**
     * Callback for resource loading progress update, only called when `autoload` is true
     */
    readonly onProgress: PropType<(progress: number) => void>;
    /**
     * Callback when resource loading fails
     */
    readonly onError: PropType<(error: unknown) => void>;
    /**
     * PixiJS provides a background loader that allows you to load assets in the background while your application is running.
     */
    readonly background: BooleanConstructor;
};
declare const Assets: vue_demi.DefineComponent<vue_demi.ExtractPropTypes<{
    readonly basePath: StringConstructor;
    readonly alias: PropType<string | string[]>;
    /**
     * Entry for loading resources, supports multiple formats
     *
     * @type {string | string[] | ResolvedSrc | ResolvedSrc[]} Used to specify the path of the resource (URL or file path)
     * @example
     * ```vue
     * <assets alias="myAsset" :entry="'path/to/asset'" />
     * <assets alias="myAsset" :entry="{{ src: 'path/to/asset', type: 'image' }}" />
     * ```
     *
     * @type {UnresolvedAsset | UnresolvedAsset[]} Used to specify the metadata of the resource
     * @example
     * ```vue
     * <assets :entry="{ alias: 'myAsset', src: 'path/to/asset' }" />
     * <assets
     *  :entry="[
     *   { alias: 'myAsset', src: 'path/to/asset' },
     *   { alias: 'myAsset2', src: 'path/to/asset2' }
     *  ]"
     * />
     * ```
     */
    readonly entry: PropType<string | string[] | ResolvedSrc | ResolvedSrc[] | UnresolvedAsset | UnresolvedAsset[]>;
    /**
     * Whether to automatically load via `Assets.load`
     *
     * @default true
     */
    readonly autoload: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    /**
     * Destruction during component logout
     */
    readonly autounload: BooleanConstructor;
    /**
     * Callback when resources are loaded, only called when `autoload` is true
     */
    readonly onLoaded: PropType<(value: any) => void>;
    /**
     * Callback for resource loading progress update, only called when `autoload` is true
     */
    readonly onProgress: PropType<(progress: number) => void>;
    /**
     * Callback when resource loading fails
     */
    readonly onError: PropType<(error: unknown) => void>;
    /**
     * PixiJS provides a background loader that allows you to load assets in the background while your application is running.
     */
    readonly background: BooleanConstructor;
}>, () => 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<{
    readonly basePath: StringConstructor;
    readonly alias: PropType<string | string[]>;
    /**
     * Entry for loading resources, supports multiple formats
     *
     * @type {string | string[] | ResolvedSrc | ResolvedSrc[]} Used to specify the path of the resource (URL or file path)
     * @example
     * ```vue
     * <assets alias="myAsset" :entry="'path/to/asset'" />
     * <assets alias="myAsset" :entry="{{ src: 'path/to/asset', type: 'image' }}" />
     * ```
     *
     * @type {UnresolvedAsset | UnresolvedAsset[]} Used to specify the metadata of the resource
     * @example
     * ```vue
     * <assets :entry="{ alias: 'myAsset', src: 'path/to/asset' }" />
     * <assets
     *  :entry="[
     *   { alias: 'myAsset', src: 'path/to/asset' },
     *   { alias: 'myAsset2', src: 'path/to/asset2' }
     *  ]"
     * />
     * ```
     */
    readonly entry: PropType<string | string[] | ResolvedSrc | ResolvedSrc[] | UnresolvedAsset | UnresolvedAsset[]>;
    /**
     * Whether to automatically load via `Assets.load`
     *
     * @default true
     */
    readonly autoload: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    /**
     * Destruction during component logout
     */
    readonly autounload: BooleanConstructor;
    /**
     * Callback when resources are loaded, only called when `autoload` is true
     */
    readonly onLoaded: PropType<(value: any) => void>;
    /**
     * Callback for resource loading progress update, only called when `autoload` is true
     */
    readonly onProgress: PropType<(progress: number) => void>;
    /**
     * Callback when resource loading fails
     */
    readonly onError: PropType<(error: unknown) => void>;
    /**
     * PixiJS provides a background loader that allows you to load assets in the background while your application is running.
     */
    readonly background: BooleanConstructor;
}>> & Readonly<{}>, {
    readonly background: boolean;
    readonly autoload: boolean;
    readonly autounload: boolean;
}, SlotsType<{
    default: {
        data: any;
    };
    fallback: {
        progress: number;
    };
    error: {
        error: Error;
    };
}>, {}, {}, string, vue_demi.ComponentProvideOptions, true, {}, any>;
declare const assetsBundleProps: {
    /**
     * Assets manifest containing bundle definitions
     */
    readonly manifest: PropType<AssetsManifest | string>;
    /**
     * Bundle name(s) to load. Can be a string or array of strings.
     * When used with manifest, specifies which bundles to load.
     * When used without manifest, loads the specified bundle(s) directly.
     */
    readonly entry: PropType<string | string[] | AssetsBundle$1["assets"]>;
    /**
     * Bundle ID to load.
     */
    readonly id: StringConstructor;
    /**
     * Whether to automatically load via `Assets.loadBundle`
     * @default true
     */
    readonly autoload: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly autounload: BooleanConstructor;
    /**
     * PixiJS provides a background loader that allows you to load assets in the background while your application is running.
     */
    readonly background: BooleanConstructor;
    /**
     * Callback when resources are loaded, only called when `autoload` is true
     */
    readonly onLoaded: PropType<(value: any) => void>;
    /**
     * Callback for resource loading progress update, only called when `autoload` is true
     */
    readonly onProgress: PropType<(progress: number) => void>;
};
/**
 * Loads a bundle of assets.
 * @example
 * ```vue
 * <assets-bundle manifest="assets/manifest.json" entry="bundle1" />
 * <assets-bundle :manifest="{...}" :entry="['bundle1', 'bundle2']" />
 *
 * <assets-bundle id="bundle1" :entry="[{ alias: 'flowerTop', src: 'assets/flowerTop.png' }]" />
 * <assets-bundle id="bundle2" :entry="{ flowerTop: 'assets/flowerTop.png' }" />
 * ```
 */
declare const AssetsBundle: vue_demi.DefineComponent<vue_demi.ExtractPropTypes<{
    /**
     * Assets manifest containing bundle definitions
     */
    readonly manifest: PropType<AssetsManifest | string>;
    /**
     * Bundle name(s) to load. Can be a string or array of strings.
     * When used with manifest, specifies which bundles to load.
     * When used without manifest, loads the specified bundle(s) directly.
     */
    readonly entry: PropType<string | string[] | AssetsBundle$1["assets"]>;
    /**
     * Bundle ID to load.
     */
    readonly id: StringConstructor;
    /**
     * Whether to automatically load via `Assets.loadBundle`
     * @default true
     */
    readonly autoload: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly autounload: BooleanConstructor;
    /**
     * PixiJS provides a background loader that allows you to load assets in the background while your application is running.
     */
    readonly background: BooleanConstructor;
    /**
     * Callback when resources are loaded, only called when `autoload` is true
     */
    readonly onLoaded: PropType<(value: any) => void>;
    /**
     * Callback for resource loading progress update, only called when `autoload` is true
     */
    readonly onProgress: PropType<(progress: number) => void>;
}>, () => 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<{
    /**
     * Assets manifest containing bundle definitions
     */
    readonly manifest: PropType<AssetsManifest | string>;
    /**
     * Bundle name(s) to load. Can be a string or array of strings.
     * When used with manifest, specifies which bundles to load.
     * When used without manifest, loads the specified bundle(s) directly.
     */
    readonly entry: PropType<string | string[] | AssetsBundle$1["assets"]>;
    /**
     * Bundle ID to load.
     */
    readonly id: StringConstructor;
    /**
     * Whether to automatically load via `Assets.loadBundle`
     * @default true
     */
    readonly autoload: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly autounload: BooleanConstructor;
    /**
     * PixiJS provides a background loader that allows you to load assets in the background while your application is running.
     */
    readonly background: BooleanConstructor;
    /**
     * Callback when resources are loaded, only called when `autoload` is true
     */
    readonly onLoaded: PropType<(value: any) => void>;
    /**
     * Callback for resource loading progress update, only called when `autoload` is true
     */
    readonly onProgress: PropType<(progress: number) => void>;
}>> & Readonly<{}>, {
    readonly background: boolean;
    readonly autoload: boolean;
    readonly autounload: boolean;
}, SlotsType<{
    default: {
        data: any;
    };
    fallback: {
        progress: number;
    };
}>, {}, {}, string, vue_demi.ComponentProvideOptions, true, {}, any>;

declare const External: vue_demi.DefineComponent<vue_demi.ExtractPropTypes<{
    tag: PropType<keyof HTMLElementTagNameMap>;
    root: PropType<HTMLElement>;
}>, () => null, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{
    tag: PropType<keyof HTMLElementTagNameMap>;
    root: PropType<HTMLElement>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue_demi.ComponentProvideOptions, true, {}, any>;

type CubicBezierPoints = [number, number, number, number];
type Hook<T = () => void> = T | TransitionVars | TransitionVars[];
interface EasingFunction {
    (p: number): number;
}
interface PixiMatrix {
    a: number;
    b: number;
    c: number;
    d: number;
    tx: number;
    ty: number;
    array?: number[];
}
interface PixiVars {
    [key: string]: any;
    alpha?: number | string;
    anchor?: number;
    anchorX?: number | string;
    anchorY?: number | string;
    angle?: number | string;
    autoAlpha?: number;
    blur?: number;
    blurX?: number;
    blurY?: number;
    blurPadding?: number;
    brightness?: number;
    colorize?: string | number;
    colorizeAmount?: number;
    colorMatrixFilter?: object;
    combineCMF?: boolean;
    contrast?: number;
    fillColor?: string | number;
    height?: number | string;
    hue?: number;
    lineColor?: string | number;
    matrix?: PixiMatrix;
    pivot?: number;
    pivotX?: number | string;
    pivotY?: number | string;
    position?: number | string;
    positionX?: number | string;
    positionY?: number | string;
    resolution?: number;
    rotation?: number | string;
    saturation?: number;
    scale?: number | string;
    scaleX?: number | string;
    scaleY?: number | string;
    skew?: number | string;
    skewX?: number | string;
    skewY?: number | string;
    tilePosition?: number;
    tilePositionX?: number | string;
    tilePositionY?: number | string;
    tileScale?: number;
    tileScaleX?: number | string;
    tileScaleY?: number | string;
    tileX?: number | string;
    tileY?: number | string;
    tint?: string | number;
    width?: number | string;
    x?: number | string;
    y?: number | string;
    zIndex?: number | string;
}
interface TransitionVars extends PixiVars {
    delay?: number;
    duration?: number;
    ease?: CubicBezierPoints | EasingFunction;
}
interface TransitionTicker {
    duration: number;
    tick: (time: number) => void;
}
type Fn = () => any;

declare const transitionProps: {
    duration: PropType<number | {
        enter: number;
        leave: number;
    }>;
    beforeEnter: PropType<Hook<(el: any) => void>>;
    enter: PropType<Hook<(el: any, done: Fn) => TransitionTicker | void>>;
    afterEnter: PropType<Hook<(el: any) => void>>;
    enterCancelled: PropType<Hook<(el: any) => void>>;
    beforeLeave: PropType<Hook<(el: any) => void>>;
    leave: PropType<Hook<(el: any, done: Fn) => TransitionTicker | void>>;
    afterLeave: PropType<Hook<(el: any) => void>>;
    onBeforeEnter: PropType<(el: any) => void>;
    onEnter: PropType<(el: any, done: Fn) => void>;
    onAfterEnter: PropType<(el: any) => void>;
    onEnterCancelled: PropType<(el: any) => void>;
    onBeforeLeave: PropType<(el: any) => void>;
    onLeave: PropType<(el: any, done: Fn) => void>;
    onAfterLeave: PropType<(el: any) => void>;
    appear: BooleanConstructor;
};
type TransitionProps = ExtractPropTypes<typeof transitionProps>;
declare const AnimatedTransition: vue_demi.DefineComponent<ExtractPropTypes<{
    duration: PropType<number | {
        enter: number;
        leave: number;
    }>;
    beforeEnter: PropType<Hook<(el: any) => void>>;
    enter: PropType<Hook<(el: any, done: Fn) => TransitionTicker | void>>;
    afterEnter: PropType<Hook<(el: any) => void>>;
    enterCancelled: PropType<Hook<(el: any) => void>>;
    beforeLeave: PropType<Hook<(el: any) => void>>;
    leave: PropType<Hook<(el: any, done: Fn) => TransitionTicker | void>>;
    afterLeave: PropType<Hook<(el: any) => void>>;
    onBeforeEnter: PropType<(el: any) => void>;
    onEnter: PropType<(el: any, done: Fn) => void>;
    onAfterEnter: PropType<(el: any) => void>;
    onEnterCancelled: PropType<(el: any) => void>;
    onBeforeLeave: PropType<(el: any) => void>;
    onLeave: PropType<(el: any, done: Fn) => void>;
    onAfterLeave: PropType<(el: any) => void>;
    appear: BooleanConstructor;
}>, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<ExtractPropTypes<{
    duration: PropType<number | {
        enter: number;
        leave: number;
    }>;
    beforeEnter: PropType<Hook<(el: any) => void>>;
    enter: PropType<Hook<(el: any, done: Fn) => TransitionTicker | void>>;
    afterEnter: PropType<Hook<(el: any) => void>>;
    enterCancelled: PropType<Hook<(el: any) => void>>;
    beforeLeave: PropType<Hook<(el: any) => void>>;
    leave: PropType<Hook<(el: any, done: Fn) => TransitionTicker | void>>;
    afterLeave: PropType<Hook<(el: any) => void>>;
    onBeforeEnter: PropType<(el: any) => void>;
    onEnter: PropType<(el: any, done: Fn) => void>;
    onAfterEnter: PropType<(el: any) => void>;
    onEnterCancelled: PropType<(el: any) => void>;
    onBeforeLeave: PropType<(el: any) => void>;
    onLeave: PropType<(el: any, done: Fn) => void>;
    onAfterLeave: PropType<(el: any) => void>;
    appear: BooleanConstructor;
}>> & Readonly<{}>, {
    appear: boolean;
}, {}, {}, {}, string, vue_demi.ComponentProvideOptions, true, {}, any>;

declare const AnimatedTransitionGroup: vue_demi.DefineComponent<vue_demi.ExtractPropTypes<{
    duration: vue_demi.PropType<number | {
        enter: number;
        leave: number;
    }>;
    beforeEnter: vue_demi.PropType<Hook<(el: any) => void>>;
    enter: vue_demi.PropType<Hook<(el: any, done: Fn) => TransitionTicker | void>>;
    afterEnter: vue_demi.PropType<Hook<(el: any) => void>>;
    enterCancelled: vue_demi.PropType<Hook<(el: any) => void>>;
    beforeLeave: vue_demi.PropType<Hook<(el: any) => void>>;
    leave: vue_demi.PropType<Hook<(el: any, done: Fn) => TransitionTicker | void>>;
    afterLeave: vue_demi.PropType<Hook<(el: any) => void>>;
    onBeforeEnter: vue_demi.PropType<(el: any) => void>;
    onEnter: vue_demi.PropType<(el: any, done: Fn) => void>;
    onAfterEnter: vue_demi.PropType<(el: any) => void>;
    onEnterCancelled: vue_demi.PropType<(el: any) => void>;
    onBeforeLeave: vue_demi.PropType<(el: any) => void>;
    onLeave: vue_demi.PropType<(el: any, done: Fn) => void>;
    onAfterLeave: vue_demi.PropType<(el: any) => void>;
    appear: BooleanConstructor;
}>, () => VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.PublicProps, Readonly<vue_demi.ExtractPropTypes<{
    duration: vue_demi.PropType<number | {
        enter: number;
        leave: number;
    }>;
    beforeEnter: vue_demi.PropType<Hook<(el: any) => void>>;
    enter: vue_demi.PropType<Hook<(el: any, done: Fn) => TransitionTicker | void>>;
    afterEnter: vue_demi.PropType<Hook<(el: any) => void>>;
    enterCancelled: vue_demi.PropType<Hook<(el: any) => void>>;
    beforeLeave: vue_demi.PropType<Hook<(el: any) => void>>;
    leave: vue_demi.PropType<Hook<(el: any, done: Fn) => TransitionTicker | void>>;
    afterLeave: vue_demi.PropType<Hook<(el: any) => void>>;
    onBeforeEnter: vue_demi.PropType<(el: any) => void>;
    onEnter: vue_demi.PropType<(el: any, done: Fn) => void>;
    onAfterEnter: vue_demi.PropType<(el: any) => void>;
    onEnterCancelled: vue_demi.PropType<(el: any) => void>;
    onBeforeLeave: vue_demi.PropType<(el: any) => void>;
    onLeave: vue_demi.PropType<(el: any, done: Fn) => void>;
    onAfterLeave: vue_demi.PropType<(el: any) => void>;
    appear: BooleanConstructor;
}>> & Readonly<{}>, {
    appear: boolean;
}, {}, {}, {}, string, vue_demi.ComponentProvideOptions, true, {}, any>;

declare module 'pixi.js' {
    interface Filter {
        parent: Container;
        _vp_name: string;
        _vp_filter: boolean;
    }
    interface Container {
        _vp_name: string;
    }
}
declare module '@vue/runtime-core' {
    interface GlobalComponents {
        Assets: typeof Assets;
        AssetsBundle: typeof AssetsBundle;
        AnimatedTransition: typeof AnimatedTransition;
        AnimatedTransitionGroup: typeof AnimatedTransitionGroup;
        External: typeof External;
    }
}

export { Assets as A, CubicBezierPoints as C, EasingFunction as E, PixiMatrix as P, TransitionProps as T, assetsProps as a, assetsBundleProps as b, AssetsBundle as c, External as d, AnimatedTransition as e, AnimatedTransitionGroup as f, PixiVars as g, TransitionTicker as h, TransitionVars as i };