react-qml/dist/components/QtQuick/types.d.ts

React QML

import * as QtQml from '../QtQml/types';
declare type Signal<T> = {
    connect: (handler: T) => void;
    disconnect: (handler: T) => void;
};
export declare enum QAbstractItemModel_LayoutChangeHint {
    NoLayoutChangeHint = 0,
    VerticalSortHint = 1,
    HorizontalSortHint = 2
}
export declare type QAbstractItemModel = {
    submit(): boolean | undefined;
    revert(): void;
    hasIndex(row: number | undefined, column: number | undefined, parent: any): boolean | undefined;
    hasIndex(row: number | undefined, column: number | undefined): boolean | undefined;
    index(row: number | undefined, column: number | undefined, parent: any): any;
    index(row: number | undefined, column: number | undefined): any;
    parent(child: any): any;
    sibling(row: number | undefined, column: number | undefined, idx: any): any;
    rowCount(parent: any): number | undefined;
    rowCount(): number | undefined;
    columnCount(parent: any): number | undefined;
    columnCount(): number | undefined;
    hasChildren(parent: any): boolean | undefined;
    hasChildren(): boolean | undefined;
    data(index: any, role: number | undefined): any;
    data(index: any): any;
    setData(index: any, value: any, role: number | undefined): boolean | undefined;
    setData(index: any, value: any): boolean | undefined;
    headerData(section: number | undefined, orientation: any, role: number | undefined): any;
    headerData(section: number | undefined, orientation: any): any;
    fetchMore(parent: any): void;
    canFetchMore(parent: any): boolean | undefined;
    flags(index: any): any;
    match(start: any, role: number | undefined, value: any, hits: number | undefined, flags: any): any;
    match(start: any, role: number | undefined, value: any, hits: number | undefined): any;
    match(start: any, role: number | undefined, value: any): any;
    dataChanged: Signal<Function>;
    headerDataChanged: Signal<Function>;
    layoutChanged: Signal<Function>;
    layoutAboutToBeChanged: Signal<Function>;
    rowsAboutToBeInserted: Signal<Function>;
    rowsInserted: Signal<Function>;
    rowsAboutToBeRemoved: Signal<Function>;
    rowsRemoved: Signal<Function>;
    columnsAboutToBeInserted: Signal<Function>;
    columnsInserted: Signal<Function>;
    columnsAboutToBeRemoved: Signal<Function>;
    columnsRemoved: Signal<Function>;
    modelAboutToBeReset: Signal<Function>;
    modelReset: Signal<Function>;
    rowsAboutToBeMoved: Signal<Function>;
    rowsMoved: Signal<Function>;
    columnsAboutToBeMoved: Signal<Function>;
    columnsMoved: Signal<Function>;
} & QtQml.QObject;
export declare type QAbstractListModel = {} & QAbstractItemModel;
export declare enum QDoubleValidator_Notation {
    StandardNotation = 0,
    ScientificNotation = 1
}
export declare type QDoubleValidator = {
    bottom: number | undefined;
    top: number | undefined;
    decimals: number | undefined;
    notation: QDoubleValidator_Notation | string;
    bottomChanged: Signal<Function>;
    topChanged: Signal<Function>;
    decimalsChanged: Signal<Function>;
    notationChanged: Signal<Function>;
} & QValidator;
export declare enum QInputMethod_Action {
    Click = 0,
    ContextMenu = 1
}
export declare type QInputMethod = {
    readonly cursorRectangle: any;
    readonly anchorRectangle: any;
    readonly keyboardRectangle: any;
    readonly inputItemClipRectangle: any;
    readonly visible: boolean;
    readonly animating: boolean;
    readonly locale: any;
    readonly inputDirection: any;
    show(): void;
    hide(): void;
    update(queries: any): void;
    reset(): void;
    commit(): void;
    invokeAction(a: QInputMethod_Action | string, cursorPosition: number | undefined): void;
    inputDirectionChanged: Signal<Function>;
} & QtQml.QObject;
export declare type QIntValidator = {
    bottom: number | undefined;
    top: number | undefined;
    bottomChanged: Signal<Function>;
    topChanged: Signal<Function>;
} & QValidator;
export declare enum QKeySequence_StandardKey {
    UnknownKey = 0,
    HelpContents = 1,
    WhatsThis = 2,
    Open = 3,
    Close = 4,
    Save = 5,
    New = 6,
    Delete = 7,
    Cut = 8,
    Copy = 9,
    Paste = 10,
    Undo = 11,
    Redo = 12,
    Back = 13,
    Forward = 14,
    Refresh = 15,
    ZoomIn = 16,
    ZoomOut = 17,
    Print = 18,
    AddTab = 19,
    NextChild = 20,
    PreviousChild = 21,
    Find = 22,
    FindNext = 23,
    FindPrevious = 24,
    Replace = 25,
    SelectAll = 26,
    Bold = 27,
    Italic = 28,
    Underline = 29,
    MoveToNextChar = 30,
    MoveToPreviousChar = 31,
    MoveToNextWord = 32,
    MoveToPreviousWord = 33,
    MoveToNextLine = 34,
    MoveToPreviousLine = 35,
    MoveToNextPage = 36,
    MoveToPreviousPage = 37,
    MoveToStartOfLine = 38,
    MoveToEndOfLine = 39,
    MoveToStartOfBlock = 40,
    MoveToEndOfBlock = 41,
    MoveToStartOfDocument = 42,
    MoveToEndOfDocument = 43,
    SelectNextChar = 44,
    SelectPreviousChar = 45,
    SelectNextWord = 46,
    SelectPreviousWord = 47,
    SelectNextLine = 48,
    SelectPreviousLine = 49,
    SelectNextPage = 50,
    SelectPreviousPage = 51,
    SelectStartOfLine = 52,
    SelectEndOfLine = 53,
    SelectStartOfBlock = 54,
    SelectEndOfBlock = 55,
    SelectStartOfDocument = 56,
    SelectEndOfDocument = 57,
    DeleteStartOfWord = 58,
    DeleteEndOfWord = 59,
    DeleteEndOfLine = 60,
    InsertParagraphSeparator = 61,
    InsertLineSeparator = 62,
    SaveAs = 63,
    Preferences = 64,
    Quit = 65,
    FullScreen = 66,
    Deselect = 67,
    DeleteCompleteLine = 68,
    Backspace = 69,
    Cancel = 70
}
export declare type QKeySequence = {};
export declare type QPointingDeviceUniqueId = {
    readonly numericId: any;
};
export declare type QQmlApplication = {
    readonly arguments: any;
    name: string | undefined;
    version: string | undefined;
    organization: string | undefined;
    domain: string | undefined;
    setName(arg: string | undefined): void;
    setVersion(arg: string | undefined): void;
    setOrganization(arg: string | undefined): void;
    setDomain(arg: string | undefined): void;
    aboutToQuit: Signal<Function>;
} & QtQml.QObject;
export declare type QQmlDelegateModel = {
    model: any;
    delegate: QtQml.QQmlComponent | null;
    filterOnGroup: string | undefined;
    readonly items: QQmlDelegateModelGroup;
    readonly persistedItems: QQmlDelegateModelGroup;
    readonly groups: QQmlDelegateModelGroup;
    readonly parts: QtQml.QObject;
    rootIndex: any;
    modelIndex(idx: number | undefined): any;
    parentModelIndex(): any;
    filterGroupChanged: Signal<Function>;
    defaultGroupsChanged: Signal<Function>;
} & QtQml.QQmlInstanceModel;
export declare type QQmlDelegateModelAttached = {
    readonly model: QQmlDelegateModel;
    groups: any;
    readonly isUnresolved: boolean;
    unresolvedChanged: Signal<Function>;
} & QtQml.QObject;
export declare type QQmlDelegateModelGroup = {
    readonly count: number;
    name: string | undefined;
    includeByDefault: boolean | undefined;
    insert(param0: any): void;
    create(param0: any): void;
    resolve(param0: any): void;
    remove(param0: any): void;
    addGroups(param0: any): void;
    removeGroups(param0: any): void;
    setGroups(param0: any): void;
    move(param0: any): void;
    get(index: number | undefined): any;
    defaultIncludeChanged: Signal<Function>;
    changed: Signal<Function>;
} & QtQml.QObject;
export declare type QQmlDelegateModelParts = {} & QtQml.QObject;
export declare enum QQmlEasingValueType_Type {
    Linear = 0,
    InQuad = 1,
    OutQuad = 2,
    InOutQuad = 3,
    OutInQuad = 4,
    InCubic = 5,
    OutCubic = 6,
    InOutCubic = 7,
    OutInCubic = 8,
    InQuart = 9,
    OutQuart = 10,
    InOutQuart = 11,
    OutInQuart = 12,
    InQuint = 13,
    OutQuint = 14,
    InOutQuint = 15,
    OutInQuint = 16,
    InSine = 17,
    OutSine = 18,
    InOutSine = 19,
    OutInSine = 20,
    InExpo = 21,
    OutExpo = 22,
    InOutExpo = 23,
    OutInExpo = 24,
    InCirc = 25,
    OutCirc = 26,
    InOutCirc = 27,
    OutInCirc = 28,
    InElastic = 29,
    OutElastic = 30,
    InOutElastic = 31,
    OutInElastic = 32,
    InBack = 33,
    OutBack = 34,
    InOutBack = 35,
    OutInBack = 36,
    InBounce = 37,
    OutBounce = 38,
    InOutBounce = 39,
    OutInBounce = 40,
    InCurve = 41,
    OutCurve = 42,
    SineCurve = 43,
    CosineCurve = 44,
    Bezier = 45
}
export declare type QQmlEasingValueType = {
    type: QQmlEasingValueType_Type | string;
    amplitude: number | undefined;
    overshoot: number | undefined;
    period: number | undefined;
    bezierCurve: any;
};
export declare type QQmlListElement = {} & QtQml.QObject;
export declare type QQmlListModel = {
    readonly count: number;
    dynamicRoles: boolean | undefined;
    clear(): void;
    remove(args: any): void;
    append(args: any): void;
    insert(args: any): void;
    get(index: number | undefined): any;
    set(index: number | undefined, param1: any): void;
    setProperty(index: number | undefined, property: string | undefined, value: any): void;
    move(from: number | undefined, to: number | undefined, count: number | undefined): void;
    sync(): void;
} & QAbstractListModel;
export declare type QQmlObjectModel = {
    readonly children: QtQml.QObject;
    clear(): void;
    get(index: number | undefined): any;
    append(object: QtQml.QObject | null): void;
    insert(index: number | undefined, object: QtQml.QObject | null): void;
    move(from: number | undefined, to: number | undefined, n: number | undefined): void;
    move(from: number | undefined, to: number | undefined): void;
    remove(index: number | undefined, n: number | undefined): void;
    remove(index: number | undefined): void;
} & QtQml.QQmlInstanceModel;
export declare type QQmlObjectModelAttached = {
    readonly index: number;
} & QtQml.QObject;
export declare enum QQuickAbstractAnimation_Loops {
    Infinite = -2
}
export declare type QQuickAbstractAnimation = {
    running: boolean | undefined;
    paused: boolean | undefined;
    alwaysRunToEnd: boolean | undefined;
    loops: number | undefined;
    restart(): void;
    start(): void;
    pause(): void;
    resume(): void;
    stop(): void;
    complete(): void;
    started: Signal<Function>;
    stopped: Signal<Function>;
    runningChanged: Signal<Function>;
    pausedChanged: Signal<Function>;
    alwaysRunToEndChanged: Signal<Function>;
    loopCountChanged: Signal<Function>;
} & QtQml.QObject;
export declare type QQuickAccessibleAttached = {
    role: any;
    name: string | undefined;
    description: string | undefined;
    ignored: boolean | undefined;
    checkable: boolean | undefined;
    checked: boolean | undefined;
    editable: boolean | undefined;
    focusable: boolean | undefined;
    focused: boolean | undefined;
    multiLine: boolean | undefined;
    readOnly: boolean | undefined;
    selected: boolean | undefined;
    selectable: boolean | undefined;
    pressed: boolean | undefined;
    checkStateMixed: boolean | undefined;
    defaultButton: boolean | undefined;
    passwordEdit: boolean | undefined;
    selectableText: boolean | undefined;
    searchEdit: boolean | undefined;
    valueChanged(): void;
    cursorPositionChanged(): void;
    setIgnored(ignored: boolean | undefined): void;
    checkableChanged: Signal<Function>;
    checkedChanged: Signal<Function>;
    editableChanged: Signal<Function>;
    focusableChanged: Signal<Function>;
    focusedChanged: Signal<Function>;
    multiLineChanged: Signal<Function>;
    readOnlyChanged: Signal<Function>;
    selectedChanged: Signal<Function>;
    selectableChanged: Signal<Function>;
    pressedChanged: Signal<Function>;
    checkStateMixedChanged: Signal<Function>;
    defaultButtonChanged: Signal<Function>;
    passwordEditChanged: Signal<Function>;
    selectableTextChanged: Signal<Function>;
    searchEditChanged: Signal<Function>;
    pressAction: Signal<Function>;
    toggleAction: Signal<Function>;
    increaseAction: Signal<Function>;
    decreaseAction: Signal<Function>;
    scrollUpAction: Signal<Function>;
    scrollDownAction: Signal<Function>;
    scrollLeftAction: Signal<Function>;
    scrollRightAction: Signal<Function>;
    previousPageAction: Signal<Function>;
    nextPageAction: Signal<Function>;
} & QtQml.QObject;
export declare type QQuickAnchorAnimation = {
    readonly targets: QQuickItem;
    duration: number | undefined;
    easing: any;
    durationChanged: Signal<Function>;
    easingChanged: Signal<Function>;
} & QQuickAbstractAnimation;
export declare type QQuickAnchorChanges = {
    target: QQuickItem | null;
    readonly anchors: QQuickAnchorSet;
} & QQuickStateOperation;
export declare type QQuickAnchorSet = {
    left: any;
    right: any;
    horizontalCenter: any;
    top: any;
    bottom: any;
    verticalCenter: any;
    baseline: any;
} & QtQml.QObject;
export declare type QQuickAnchors = {
    left: any;
    right: any;
    horizontalCenter: any;
    top: any;
    bottom: any;
    verticalCenter: any;
    baseline: any;
    margins: number | undefined;
    leftMargin: number | undefined;
    rightMargin: number | undefined;
    horizontalCenterOffset: number | undefined;
    topMargin: number | undefined;
    bottomMargin: number | undefined;
    verticalCenterOffset: number | undefined;
    baselineOffset: number | undefined;
    fill: QQuickItem | null;
    centerIn: QQuickItem | null;
    alignWhenCentered: boolean | undefined;
    centerAlignedChanged: Signal<Function>;
} & QtQml.QObject;
export declare type QQuickAnimatedImage = {
    playing: boolean | undefined;
    paused: boolean | undefined;
    currentFrame: number | undefined;
    readonly frameCount: number;
    readonly sourceSize: any;
    frameChanged: Signal<Function>;
} & QQuickImage;
export declare enum QQuickAnimatedSprite_LoopParameters {
    Infinite = -1
}
export declare type QQuickAnimatedSprite = {
    running: boolean | undefined;
    interpolate: boolean | undefined;
    source: string | undefined;
    reverse: boolean | undefined;
    frameSync: boolean | undefined;
    frameCount: number | undefined;
    frameHeight: number | undefined;
    frameWidth: number | undefined;
    frameX: number | undefined;
    frameY: number | undefined;
    frameRate: number | undefined;
    frameDuration: number | undefined;
    loops: number | undefined;
    paused: boolean | undefined;
    currentFrame: number | undefined;
    start(): void;
    stop(): void;
    restart(): void;
    advance(frames: number | undefined): void;
    advance(): void;
    pause(): void;
    resume(): void;
    setRunning(arg: boolean | undefined): void;
    setPaused(arg: boolean | undefined): void;
    setInterpolate(arg: boolean | undefined): void;
    setSource(arg: string | undefined): void;
    setReverse(arg: boolean | undefined): void;
    setFrameSync(arg: boolean | undefined): void;
    setFrameCount(arg: number | undefined): void;
    setFrameHeight(arg: number | undefined): void;
    setFrameWidth(arg: number | undefined): void;
    setFrameX(arg: number | undefined): void;
    setFrameY(arg: number | undefined): void;
    setFrameRate(arg: number | undefined): void;
    setFrameDuration(arg: number | undefined): void;
    resetFrameRate(): void;
    resetFrameDuration(): void;
    setLoops(arg: number | undefined): void;
    setCurrentFrame(arg: number | undefined): void;
    pausedChanged: Signal<Function>;
    runningChanged: Signal<Function>;
    interpolateChanged: Signal<Function>;
    sourceChanged: Signal<Function>;
    reverseChanged: Signal<Function>;
    frameSyncChanged: Signal<Function>;
    frameCountChanged: Signal<Function>;
    frameHeightChanged: Signal<Function>;
    frameWidthChanged: Signal<Function>;
    frameXChanged: Signal<Function>;
    frameYChanged: Signal<Function>;
    frameRateChanged: Signal<Function>;
    frameDurationChanged: Signal<Function>;
    loopsChanged: Signal<Function>;
    currentFrameChanged: Signal<Function>;
} & QQuickItem;
export declare type QQuickAnimationController = {
    progress: number | undefined;
    animation: QQuickAbstractAnimation | null;
    reload(): void;
    completeToBeginning(): void;
    completeToEnd(): void;
} & QtQml.QObject;
export declare type QQuickAnimationGroup = {
    readonly animations: QQuickAbstractAnimation;
} & QQuickAbstractAnimation;
export declare type QQuickAnimator = {
    target: QQuickItem | null;
    easing: any;
    duration: number | undefined;
    to: number | undefined;
    from: number | undefined;
    targetItemChanged: Signal<Function>;
    durationChanged: Signal<Function>;
    easingChanged: Signal<Function>;
    toChanged: Signal<Function>;
    fromChanged: Signal<Function>;
} & QQuickAbstractAnimation;
export declare type QQuickApplication = {
    readonly active: boolean;
    readonly layoutDirection: any;
    readonly supportsMultipleWindows: boolean;
    readonly state: any;
    readonly font: any;
    displayName: string | undefined;
    readonly screens: any;
    stateChanged: Signal<Function>;
} & QQmlApplication;
export declare type QQuickBasePositioner = {
    spacing: number | undefined;
    populate: QQuickTransition | null;
    move: QQuickTransition | null;
    add: QQuickTransition | null;
    padding: number | undefined;
    topPadding: number | undefined;
    leftPadding: number | undefined;
    rightPadding: number | undefined;
    bottomPadding: number | undefined;
    forceLayout(): void;
    paddingChanged: Signal<Function>;
    topPaddingChanged: Signal<Function>;
    leftPaddingChanged: Signal<Function>;
    rightPaddingChanged: Signal<Function>;
    bottomPaddingChanged: Signal<Function>;
    positioningComplete: Signal<Function>;
} & QQuickImplicitSizeItem;
export declare type QQuickBehavior = {
    animation: QQuickAbstractAnimation | null;
    enabled: boolean | undefined;
} & QtQml.QObject;
export declare enum QQuickBorderImage_TileMode {
    Stretch = 0,
    Repeat = 1,
    Round = 2
}
export declare type QQuickBorderImage = {
    readonly border: QQuickScaleGrid;
    horizontalTileMode: QQuickBorderImage_TileMode | string;
    verticalTileMode: QQuickBorderImage_TileMode | string;
    readonly sourceSize: any;
} & QQuickImageBase;
export declare enum QQuickBorderImageMesh_TileMode {
    Stretch = 0,
    Repeat = 1,
    Round = 2
}
export declare type QQuickBorderImageMesh = {
    readonly border: QQuickScaleGrid;
    size: any;
    horizontalTileMode: QQuickBorderImageMesh_TileMode | string;
    verticalTileMode: QQuickBorderImageMesh_TileMode | string;
} & QQuickShaderEffectMesh;
export declare enum QQuickCanvasItem_RenderTarget {
    Image = 0,
    FramebufferObject = 1
}
export declare enum QQuickCanvasItem_RenderStrategy {
    Immediate = 0,
    Threaded = 1,
    Cooperative = 2
}
export declare type QQuickCanvasItem = {
    readonly available: boolean;
    contextType: string | undefined;
    readonly context: any;
    canvasSize: any;
    tileSize: any;
    canvasWindow: any;
    renderTarget: QQuickCanvasItem_RenderTarget | string;
    renderStrategy: QQuickCanvasItem_RenderStrategy | string;
    loadImage(url: string | undefined): void;
    unloadImage(url: string | undefined): void;
    isImageLoaded(url: string | undefined): boolean | undefined;
    isImageLoading(url: string | undefined): boolean | undefined;
    isImageError(url: string | undefined): boolean | undefined;
    getContext(args: any): void;
    requestAnimationFrame(args: any): void;
    cancelRequestAnimationFrame(args: any): void;
    requestPaint(): void;
    markDirty(dirtyRect: any): void;
    markDirty(): void;
    save(filename: string | undefined): boolean | undefined;
    toDataURL(type: string | undefined): string | undefined;
    toDataURL(): string | undefined;
    paint: Signal<Function>;
    painted: Signal<Function>;
    imageLoaded: Signal<Function>;
} & QQuickItem;
export declare type QQuickCloseEvent = {
    accepted: boolean | undefined;
} & QtQml.QObject;
export declare type QQuickColorAnimation = {
    from: any;
    to: any;
} & QQuickPropertyAnimation;
export declare type QQuickColumn = {} & QQuickBasePositioner;
export declare type QQuickCurve = {
    x: number | undefined;
    y: number | undefined;
    relativeX: number | undefined;
    relativeY: number | undefined;
} & QQuickPathElement;
export declare type QQuickDoubleValidator = {
    locale: string | undefined;
    localeNameChanged: Signal<Function>;
} & QDoubleValidator;
export declare enum QQuickDrag_DragType {
    None = 0,
    Automatic = 1,
    Internal = 2
}
export declare enum QQuickDrag_Axis {
    XAxis = 1,
    YAxis = 2,
    XAndYAxis = 3,
    XandYAxis = 3
}
export declare type QQuickDrag = {
    target: QQuickItem | null;
    axis: QQuickDrag_Axis | string;
    minimumX: number | undefined;
    maximumX: number | undefined;
    minimumY: number | undefined;
    maximumY: number | undefined;
    readonly active: boolean;
    filterChildren: boolean | undefined;
    smoothed: boolean | undefined;
    threshold: number | undefined;
} & QtQml.QObject;
export declare type QQuickDragAttached = {
    active: boolean | undefined;
    source: QtQml.QObject | null;
    readonly target: QtQml.QObject;
    hotSpot: any;
    imageSource: string | undefined;
    keys: any;
    mimeData: any;
    supportedActions: any;
    proposedAction: any;
    dragType: any;
    start(param0: any): void;
    startDrag(param0: any): void;
    cancel(): void;
    drop(): number | undefined;
    dragStarted: Signal<Function>;
    dragFinished: Signal<Function>;
} & QtQml.QObject;
export declare type QQuickDropArea = {
    readonly containsDrag: boolean;
    keys: any;
    readonly drag: QQuickDropAreaDrag;
    sourceChanged: Signal<Function>;
    entered: Signal<Function>;
    exited: Signal<Function>;
    positionChanged: Signal<Function>;
    dropped: Signal<Function>;
} & QQuickItem;
export declare type QQuickDropAreaDrag = {
    readonly x: number;
    readonly y: number;
    readonly source: QtQml.QObject;
    positionChanged: Signal<Function>;
} & QtQml.QObject;
export declare type QQuickDropEvent = {
    readonly x: number;
    readonly y: number;
    readonly source: QtQml.QObject;
    readonly keys: any;
    readonly supportedActions: any;
    readonly proposedAction: any;
    action: any;
    accepted: boolean | undefined;
    readonly hasColor: boolean;
    readonly hasHtml: boolean;
    readonly hasText: boolean;
    readonly hasUrls: boolean;
    readonly colorData: any;
    readonly html: string;
    readonly text: string;
    readonly urls: any;
    readonly formats: any;
    getDataAsString(param0: any): void;
    getDataAsArrayBuffer(param0: any): void;
    acceptProposedAction(param0: any): void;
    accept(param0: any): void;
} & QtQml.QObject;
export declare type QQuickEnterKeyAttached = {
    type: any;
} & QtQml.QObject;
export declare enum QQuickFlickable_BoundsBehavior {
    StopAtBounds = 0,
    DragOverBounds = 1,
    OvershootBounds = 2,
    DragAndOvershootBounds = 3
}
export declare enum QQuickFlickable_BoundsMovement {
    FollowBoundsBehavior = 1
}
export declare enum QQuickFlickable_FlickableDirection {
    AutoFlickDirection = 0,
    HorizontalFlick = 1,
    VerticalFlick = 2,
    HorizontalAndVerticalFlick = 3,
    AutoFlickIfNeeded = 12
}
export declare type QQuickFlickable = {
    contentWidth: number | undefined;
    contentHeight: number | undefined;
    contentX: number | undefined;
    contentY: number | undefined;
    readonly contentItem: QQuickItem;
    topMargin: number | undefined;
    bottomMargin: number | undefined;
    readonly originY: number;
    leftMargin: number | undefined;
    rightMargin: number | undefined;
    readonly originX: number;
    readonly horizontalVelocity: number;
    readonly verticalVelocity: number;
    boundsBehavior: QQuickFlickable_BoundsBehavior | string;
    boundsMovement: QQuickFlickable_BoundsMovement | string;
    rebound: QQuickTransition | null;
    maximumFlickVelocity: number | undefined;
    flickDeceleration: number | undefined;
    readonly moving: boolean;
    readonly movingHorizontally: boolean;
    readonly movingVertically: boolean;
    readonly flicking: boolean;
    readonly flickingHorizontally: boolean;
    readonly flickingVertically: boolean;
    readonly dragging: boolean;
    readonly draggingHorizontally: boolean;
    readonly draggingVertically: boolean;
    flickableDirection: QQuickFlickable_FlickableDirection | string;
    interactive: boolean | undefined;
    pressDelay: number | undefined;
    readonly atXEnd: boolean;
    readonly atYEnd: boolean;
    readonly atXBeginning: boolean;
    readonly atYBeginning: boolean;
    readonly visibleArea: QQuickFlickableVisibleArea;
    pixelAligned: boolean | undefined;
    readonly horizontalOvershoot: number;
    readonly verticalOvershoot: number;
    readonly flickableData: QtQml.QObject;
    readonly flickableChildren: QQuickItem;
    resizeContent(w: number | undefined, h: number | undefined, center: any): void;
    returnToBounds(): void;
    flick(xVelocity: number | undefined, yVelocity: number | undefined): void;
    cancelFlick(): void;
    isAtBoundaryChanged: Signal<Function>;
    boundsMovementChanged: Signal<Function>;
    movementStarted: Signal<Function>;
    movementEnded: Signal<Function>;
    flickStarted: Signal<Function>;
    flickEnded: Signal<Function>;
    dragStarted: Signal<Function>;
    dragEnded: Signal<Function>;
    horizontalOvershootChanged: Signal<Function>;
    verticalOvershootChanged: Signal<Function>;
} & QQuickItem;
export declare type QQuickFlickableVisibleArea = {
    readonly xPosition: number;
    readonly yPosition: number;
    readonly widthRatio: number;
    readonly heightRatio: number;
    xPositionChanged: Signal<Function>;
    yPositionChanged: Signal<Function>;
    widthRatioChanged: Signal<Function>;
    heightRatioChanged: Signal<Function>;
} & QtQml.QObject;
export declare enum QQuickFlipable_Side {
    Front = 0,
    Back = 1
}
export declare type QQuickFlipable = {
    front: QQuickItem | null;
    back: QQuickItem | null;
    readonly side: QQuickFlipable_Side | string;
} & QQuickItem;
export declare enum QQuickFlow_Flow {
    LeftToRight = 0,
    TopToBottom = 1
}
export declare type QQuickFlow = {
    flow: QQuickFlow_Flow | string;
    layoutDirection: any;
    readonly effectiveLayoutDirection: any;
} & QQuickBasePositioner;
export declare type QQuickFocusScope = {} & QQuickItem;
export declare enum QQuickFontLoader_Status {
    Null = 0,
    Ready = 1,
    Loading = 2,
    Error = 3
}
export declare type QQuickFontLoader = {
    source: string | undefined;
    name: string | undefined;
    readonly status: QQuickFontLoader_Status | string;
} & QtQml.QObject;
export declare type QQuickFontMetrics = {
    font: any;
    readonly ascent: number;
    readonly descent: number;
    readonly height: number;
    readonly leading: number;
    readonly lineSpacing: number;
    readonly minimumLeftBearing: number;
    readonly minimumRightBearing: number;
    readonly maximumCharacterWidth: number;
    readonly xHeight: number;
    readonly averageCharacterWidth: number;
    readonly underlinePosition: number;
    readonly overlinePosition: number;
    readonly strikeOutPosition: number;
    readonly lineWidth: number;
    advanceWidth(text: string | undefined): number | undefined;
    boundingRect(text: string | undefined): any;
    tightBoundingRect(text: string | undefined): any;
    elidedText(text: string | undefined, mode: any, width: number | undefined, flags: number | undefined): string | undefined;
    elidedText(text: string | undefined, mode: any, width: number | undefined): string | undefined;
    fontChanged: Signal<Function>;
} & QtQml.QObject;
export declare enum QQuickFontValueType_FontWeight {
    Thin = 0,
    ExtraLight = 12,
    Light = 25,
    Normal = 50,
    Medium = 57,
    DemiBold = 63,
    Bold = 75,
    ExtraBold = 81,
    Black = 87
}
export declare enum QQuickFontValueType_Capitalization {
    MixedCase = 0,
    AllUppercase = 1,
    AllLowercase = 2,
    SmallCaps = 3,
    Capitalize = 4
}
export declare enum QQuickFontValueType_HintingPreference {
    PreferDefaultHinting = 0,
    PreferNoHinting = 1,
    PreferVerticalHinting = 2,
    PreferFullHinting = 3
}
export declare type QQuickFontValueType = {
    family: string | undefined;
    styleName: string | undefined;
    bold: boolean | undefined;
    weight: QQuickFontValueType_FontWeight | string;
    italic: boolean | undefined;
    underline: boolean | undefined;
    overline: boolean | undefined;
    strikeout: boolean | undefined;
    pointSize: number | undefined;
    pixelSize: number | undefined;
    capitalization: QQuickFontValueType_Capitalization | string;
    letterSpacing: number | undefined;
    wordSpacing: number | undefined;
    hintingPreference: QQuickFontValueType_HintingPreference | string;
    kerning: boolean | undefined;
    preferShaping: boolean | undefined;
    toString(): string | undefined;
};
export declare type QQuickGrabGestureEvent = {
    readonly touchPoints: QtQml.QObject;
    readonly dragThreshold: number;
    grab(): void;
} & QtQml.QObject;
export declare type QQuickGradient = {
    readonly stops: QQuickGradientStop;
    updated: Signal<Function>;
} & QtQml.QObject;
export declare type QQuickGradientStop = {
    position: number | undefined;
    color: any;
} & QtQml.QObject;
export declare enum QQuickGraphicsInfo_GraphicsApi {
    Unknown = 0,
    Software = 1,
    OpenGL = 2,
    Direct3D12 = 3
}
export declare enum QQuickGraphicsInfo_ShaderType {
    UnknownShadingLanguage = 0,
    GLSL = 1,
    HLSL = 2
}
export declare enum QQuickGraphicsInfo_ShaderCompilationType {
    RuntimeCompilation = 1,
    OfflineCompilation = 2
}
export declare enum QQuickGraphicsInfo_ShaderSourceType {
    ShaderSourceString = 1,
    ShaderSourceFile = 2,
    ShaderByteCode = 4
}
export declare enum QQuickGraphicsInfo_OpenGLContextProfile {
    OpenGLNoProfile = 0,
    OpenGLCoreProfile = 1,
    OpenGLCompatibilityProfile = 2
}
export declare enum QQuickGraphicsInfo_RenderableType {
    SurfaceFormatUnspecified = 0,
    SurfaceFormatOpenGL = 1,
    SurfaceFormatOpenGLES = 2
}
export declare type QQuickGraphicsInfo = {
    readonly api: QQuickGraphicsInfo_GraphicsApi | string;
    readonly shaderType: QQuickGraphicsInfo_ShaderType | string;
    readonly shaderCompilationType: QQuickGraphicsInfo_ShaderCompilationType | string;
    readonly shaderSourceType: QQuickGraphicsInfo_ShaderSourceType | string;
    readonly majorVersion: number;
    readonly minorVersion: number;
    readonly profile: QQuickGraphicsInfo_OpenGLContextProfile | string;
    readonly renderableType: QQuickGraphicsInfo_RenderableType | string;
} & QtQml.QObject;
export declare enum QQuickGrid_Flow {
    LeftToRight = 0,
    TopToBottom = 1
}
export declare enum QQuickGrid_HAlignment {
    AlignLeft = 1,
    AlignRight = 2,
    AlignHCenter = 4
}
export declare enum QQuickGrid_VAlignment {
    AlignTop = 32,
    AlignBottom = 64,
    AlignVCenter = 128
}
export declare type QQuickGrid = {
    rows: number | undefined;
    columns: number | undefined;
    rowSpacing: number | undefined;
    columnSpacing: number | undefined;
    flow: QQuickGrid_Flow | string;
    layoutDirection: any;
    readonly effectiveLayoutDirection: any;
    horizontalItemAlignment: QQuickGrid_HAlignment | string;
    readonly effectiveHorizontalItemAlignment: QQuickGrid_HAlignment | string;
    verticalItemAlignment: QQuickGrid_VAlignment | string;
    horizontalAlignmentChanged: Signal<Function>;
    effectiveHorizontalAlignmentChanged: Signal<Function>;
    verticalAlignmentChanged: Signal<Function>;
} & QQuickBasePositioner;
export declare type QQuickGridMesh = {
    resolution: any;
} & QQuickShaderEffectMesh;
export declare enum QQuickGridView_Flow {
    FlowLeftToRight = 0,
    FlowTopToBottom = 2
}
export declare enum QQuickGridView_SnapMode {
    NoSnap = 0,
    SnapToRow = 1,
    SnapOneRow = 2
}
export declare type QQuickGridView = {
    flow: QQuickGridView_Flow | string;
    cellWidth: number | undefined;
    cellHeight: number | undefined;
    snapMode: QQuickGridView_SnapMode | string;
    moveCurrentIndexUp(): void;
    moveCurrentIndexDown(): void;
    moveCurrentIndexLeft(): void;
    moveCurrentIndexRight(): void;
    highlightMoveDurationChanged: Signal<Function>;
} & QQuickItemView;
export declare type QQuickGridViewAttached = {} & QQuickItemViewAttached;
export declare enum QQuickImage_HAlignment {
    AlignLeft = 1,
    AlignRight = 2,
    AlignHCenter = 4
}
export declare enum QQuickImage_VAlignment {
    AlignTop = 32,
    AlignBottom = 64,
    AlignVCenter = 128
}
export declare enum QQuickImage_FillMode {
    Stretch = 0,
    PreserveAspectFit = 1,
    PreserveAspectCrop = 2,
    Tile = 3,
    TileVertically = 4,
    TileHorizontally = 5,
    Pad = 6
}
export declare type QQuickImage = {
    fillMode: QQuickImage_FillMode | string;
    readonly paintedWidth: number;
    readonly paintedHeight: number;
    horizontalAlignment: QQuickImage_HAlignment | string;
    verticalAlignment: QQuickImage_VAlignment | string;
    mipmap: boolean | undefined;
    autoTransform: boolean | undefined;
    paintedGeometryChanged: Signal<Function>;
    horizontalAlignmentChanged: Signal<Function>;
    verticalAlignmentChanged: Signal<Function>;
    mipmapChanged: Signal<Function>;
    autoTransformChanged: Signal<Function>;
} & QQuickImageBase;
export declare enum QQuickImageBase_Status {
    Null = 0,
    Ready = 1,
    Loading = 2,
    Error = 3
}
export declare type QQuickImageBase = {
    readonly status: QQuickImageBase_Status | string;
    source: string | undefined;
    readonly progress: number;
    asynchronous: boolean | undefined;
    cache: boolean | undefined;
    sourceSize: any;
    mirror: boolean | undefined;
    sourceChanged: Signal<Function>;
    statusChanged: Signal<Function>;
    progressChanged: Signal<Function>;
} & QQuickImplicitSizeItem;
export declare type QQuickImplicitSizeItem = {
    readonly implicitWidth: number;
    readonly implicitHeight: number;
} & QQuickItem;
export declare type QQuickIntValidator = {
    locale: string | undefined;
    localeNameChanged: Signal<Function>;
} & QIntValidator;
export declare enum QQuickItem_TransformOrigin {
    TopLeft = 0,
    Top = 1,
    TopRight = 2,
    Left = 3,
    Center = 4,
    Right = 5,
    BottomLeft = 6,
    Bottom = 7,
    BottomRight = 8
}
export declare type QQuickItem = {
    parent: QQuickItem | null;
    readonly data: QtQml.QObject;
    readonly resources: QtQml.QObject;
    readonly children: QQuickItem;
    x: number | undefined;
    y: number | undefined;
    z: number | undefined;
    width: number | undefined;
    height: number | undefined;
    opacity: number | undefined;
    enabled: boolean | undefined;
    visible: boolean | undefined;
    readonly visibleChildren: QQuickItem;
    readonly states: QQuickState;
    readonly transitions: QQuickTransition;
    state: string | undefined;
    readonly childrenRect: any;
    readonly anchors: QQuickAnchors;
    readonly left: any;
    readonly right: any;
    readonly horizontalCenter: any;
    readonly top: any;
    readonly bottom: any;
    readonly verticalCenter: any;
    readonly baseline: any;
    baselineOffset: number | undefined;
    clip: boolean | undefined;
    focus: boolean | undefined;
    readonly activeFocus: boolean;
    activeFocusOnTab: boolean | undefined;
    rotation: number | undefined;
    scale: number | undefined;
    transformOrigin: QQuickItem_TransformOrigin | string;
    readonly transformOriginPoint: any;
    readonly transform: QQuickTransform;
    smooth: boolean | undefined;
    antialiasing: boolean | undefined;
    implicitWidth: number | undefined;
    implicitHeight: number | undefined;
    readonly layer: QQuickItemLayer;
    update(): void;
    grabToImage(callback: any, targetSize: any): boolean | undefined;
    grabToImage(callback: any): boolean | undefined;
    contains(point: any): boolean | undefined;
    mapFromItem(param0: any): void;
    mapToItem(param0: any): void;
    mapFromGlobal(param0: any): void;
    mapToGlobal(param0: any): void;
    forceActiveFocus(): void;
    forceActiveFocus(reason: any): void;
    nextItemInFocusChain(forward: boolean | undefined): any;
    nextItemInFocusChain(): any;
    childAt(x: number | undefined, y: number | undefined): any;
    childrenRectChanged: Signal<Function>;
    baselineOffsetChanged: Signal<Function>;
    stateChanged: Signal<Function>;
    focusChanged: Signal<Function>;
    activeFocusChanged: Signal<Function>;
    activeFocusOnTabChanged: Signal<Function>;
    parentChanged: Signal<Function>;
    transformOriginChanged: Signal<Function>;
    smoothChanged: Signal<Function>;
    antialiasingChanged: Signal<Function>;
    clipChanged: Signal<Function>;
    windowChanged: Signal<Function>;
} & QtQml.QObject;
export declare type QQuickItemGrabResult = {
    readonly image: any;
    readonly url: string;
    saveToFile(fileName: string | undefined): boolean | undefined;
    saveToFile(fileName: string | undefined): boolean | undefined;
    ready: Signal<Function>;
} & QtQml.QObject;
export declare type QQuickItemLayer = {
    enabled: boolean | undefined;
    textureSize: any;
    sourceRect: any;
    mipmap: boolean | undefined;
    smooth: boolean | undefined;
    wrapMode: any;
    format: any;
    samplerName: any;
    effect: QtQml.QQmlComponent | null;
    textureMirroring: any;
    samples: number | undefined;
    enabledChanged: Signal<Function>;
    sizeChanged: Signal<Function>;
    mipmapChanged: Signal<Function>;
    wrapModeChanged: Signal<Function>;
    nameChanged: Signal<Function>;
    effectChanged: Signal<Function>;
    smoothChanged: Signal<Function>;
    formatChanged: Signal<Function>;
    sourceRectChanged: Signal<Function>;
    textureMirroringChanged: Signal<Function>;
    samplesChanged: Signal<Function>;
} & QtQml.QObject;
export declare enum QQuickItemView_LayoutDirection {
    LeftToRight = 0,
    RightToLeft = 1,
    VerticalTopToBottom = 2,
    VerticalBottomToTop = 3
}
export declare enum QQuickItemView_VerticalLayoutDirection {
    TopToBottom = 2,
    BottomToTop = 3
}
export declare enum QQuickItemView_HighlightRangeMode {
    NoHighlightRange = 0,
    ApplyRange = 1,
    StrictlyEnforceRange = 2
}
export declare enum QQuickItemView_PositionMode {
    Beginning = 0,
    Center = 1,
    End = 2,
    Visible = 3,
    Contain = 4,
    SnapPosition = 5
}
export declare type QQuickItemView = {
    model: any;
    delegate: QtQml.QQmlComponent | null;
    readonly count: number;
    currentIndex: number | undefined;
    readonly currentItem: QQuickItem;
    keyNavigationWraps: boolean | undefined;
    keyNavigationEnabled: boolean | undefined;
    cacheBuffer: number | undefined;
    displayMarginBeginning: number | undefined;
    displayMarginEnd: number | undefined;
    layoutDirection: any;
    readonly effectiveLayoutDirection: any;
    verticalLayoutDirection: QQuickItemView_VerticalLayoutDirection | string;
    header: QtQml.QQmlComponent | null;
    readonly headerItem: QQuickItem;
    footer: QtQml.QQmlComponent | null;
    readonly footerItem: QQuickItem;
    populate: QQuickTransition | null;
    add: QQuickTransition | null;
    addDisplaced: QQuickTransition | null;
    move: QQuickTransition | null;
    moveDisplaced: QQuickTransition | null;
    remove: QQuickTransition | null;
    removeDisplaced: QQuickTransition | null;
    displaced: QQuickTransition | null;
    highlight: QtQml.QQmlComponent | null;
    readonly highlightItem: QQuickItem;
    highlightFollowsCurrentItem: boolean | undefined;
    highlightRangeMode: QQuickItemView_HighlightRangeMode | string;
    preferredHighlightBegin: number | undefined;
    preferredHighlightEnd: number | undefined;
    highlightMoveDuration: number | undefined;
    positionViewAtIndex(index: number | undefined, mode: number | undefined): void;
    indexAt(x: number | undefined, y: number | undefined): number | undefined;
    itemAt(x: number | undefined, y: number | undefined): any;
    positionViewAtBeginning(): void;
    positionViewAtEnd(): void;
    forceLayout(): void;
    keyNavigationEnabledChanged: Signal<Function>;
    populateTransitionChanged: Signal<Function>;
    addTransitionChanged: Signal<Function>;
    addDisplacedTransitionChanged: Signal<Function>;
    moveTransitionChanged: Signal<Function>;
    moveDisplacedTransitionChanged: Signal<Function>;
    removeTransitionChanged: Signal<Function>;
    removeDisplacedTransitionChanged: Signal<Function>;
    displacedTransitionChanged: Signal<Function>;
} & QQuickFlickable;
export declare type QQuickItemViewAttached = {
    readonly view: QQuickItemView;
    readonly isCurrentItem: boolean;
    delayRemove: boolean | undefined;
    readonly section: string;
    readonly previousSection: string;
    readonly nextSection: string;
    currentItemChanged: Signal<Function>;
    add: Signal<Function>;
    remove: Signal<Function>;
    prevSectionChanged: Signal<Function>;
} & QtQml.QObject;
export declare type QQuickKeyEvent = {
    readonly key: number;
    readonly text: string;
    readonly modifiers: number;
    readonly isAutoRepeat: boolean;
    readonly count: number;
    readonly nativeScanCode: any;
    accepted: boolean | undefined;
    matches(key: any): boolean | undefined;
} & QtQml.QObject;
export declare enum QQuickKeyNavigationAttached_Priority {
    BeforeItem = 0,
    AfterItem = 1
}
export declare type QQuickKeyNavigationAttached = {
    left: QQuickItem | null;
    right: QQuickItem | null;
    up: QQuickItem | null;
    down: QQuickItem | null;
    tab: QQuickItem | null;
    backtab: QQuickItem | null;
    priority: QQuickKeyNavigationAttached_Priority | string;
} & QtQml.QObject;
export declare enum QQuickKeysAttached_Priority {
    BeforeItem = 0,
    AfterItem = 1
}
export declare type QQuickKeysAttached = {
    enabled: boolean | undefined;
    readonly forwardTo: QQuickItem;
    priority: QQuickKeysAttached_Priority | string;
    pressed: Signal<Function>;
    released: Signal<Function>;
    shortcutOverride: Signal<Function>;
    digit0Pressed: Signal<Function>;
    digit1Pressed: Signal<Function>;
    digit2Pressed: Signal<Function>;
    digit3Pressed: Signal<Function>;
    digit4Pressed: Signal<Function>;
    digit5Pressed: Signal<Function>;
    digit6Pressed: Signal<Function>;
    digit7Pressed: Signal<Function>;
    digit8Pressed: Signal<Function>;
    digit9Pressed: Signal<Function>;
    leftPressed: Signal<Function>;
    rightPressed: Signal<Function>;
    upPressed: Signal<Function>;
    downPressed: Signal<Function>;
    tabPressed: Signal<Function>;
    backtabPressed: Signal<Function>;
    asteriskPressed: Signal<Function>;
    numberSignPressed: Signal<Function>;
    escapePressed: Signal<Function>;
    returnPressed: Signal<Function>;
    enterPressed: Signal<Function>;
    deletePressed: Signal<Function>;
    spacePressed: Signal<Function>;
    backPressed: Signal<Function>;
    cancelPressed: Signal<Function>;
    selectPressed: Signal<Function>;
    yesPressed: Signal<Function>;
    noPressed: Signal<Function>;
    context1Pressed: Signal<Function>;
    context2Pressed: Signal<Function>;
    context3Pressed: Signal<Function>;
    context4Pressed: Signal<Function>;
    callPressed: Signal<Function>;
    hangupPressed: Signal<Function>;
    flipPressed: Signal<Function>;
    menuPressed: Signal<Function>;
    volumeUpPressed: Signal<Function>;
    volumeDownPressed: Signal<Function>;
} & QtQml.QObject;
export declare type QQuickLayoutMirroringAttached = {
    enabled: boolean | undefined;
    childrenInherit: boolean | undefined;
} & QtQml.QObject;
export declare enum QQuickListView_Orientation {
    Horizontal = 1,
    Vertical = 2
}
export declare enum QQuickListView_SnapMode {
    NoSnap = 0,
    SnapToItem = 1,
    SnapOneItem = 2
}
export declare enum QQuickListView_HeaderPositioning {
    InlineHeader = 0,
    OverlayHeader = 1,
    PullBackHeader = 2
}
export declare enum QQuickListView_FooterPositioning {
    InlineFooter = 0,
    OverlayFooter = 1,
    PullBackFooter = 2
}
export declare type QQuickListView = {
    highlightMoveVelocity: number | undefined;
    highlightResizeVelocity: number | undefined;
    highlightResizeDuration: number | undefined;
    spacing: number | undefined;
    orientation: QQuickListView_Orientation | string;
    readonly section: QQuickViewSection;
    readonly currentSection: string;
    snapMode: QQuickListView_SnapMode | string;
    headerPositioning: QQuickListView_HeaderPositioning | string;
    footerPositioning: QQuickListView_FooterPositioning | string;
    incrementCurrentIndex(): void;
    decrementCurrentIndex(): void;
    headerPositioningChanged: Signal<Function>;
    footerPositioningChanged: Signal<Function>;
} & QQuickItemView;
export declare type QQuickListViewAttached = {} & QQuickItemViewAttached;
export declare enum QQuickLoader_Status {
    Null = 0,
    Ready = 1,
    Loading = 2,
    Error = 3
}
export declare type QQuickLoader = {
    active: boolean | undefined;
    source: string | undefined;
    sourceComponent: QtQml.QQmlComponent | null;
    readonly item: QtQml.QObject;
    readonly status: QQuickLoader_Status | string;
    readonly progress: number;
    asynchronous: boolean | undefined;
    setSource(param0: any): void;
    loaded: Signal<Function>;
} & QQuickImplicitSizeItem;
export declare type QQuickMatrix4x4 = {
    matrix: any;
} & QQuickTransform;
export declare type QQuickMouseArea = {
    readonly mouseX: number;
    readonly mouseY: number;
    readonly containsMouse: boolean;
    readonly pressed: boolean;
    enabled: boolean | undefined;
    scrollGestureEnabled: boolean | undefined;
    readonly pressedButtons: any;
    acceptedButtons: any;
    hoverEnabled: boolean | undefined;
    readonly drag: QQuickDrag;
    preventStealing: boolean | undefined;
    propagateComposedEvents: boolean | undefined;
    cursorShape: any;
    readonly containsPress: boolean;
    pressAndHoldInterval: number | undefined;
    hoveredChanged: Signal<Function>;
    scrollGestureEnabledChanged: Signal<Function>;
    positionChanged: Signal<Function>;
    mouseXChanged: Signal<Function>;
    mouseYChanged: Signal<Function>;
    pressAndHold: Signal<Function>;
    released: Signal<Function>;
    clicked: Signal<Function>;
    doubleClicked: Signal<Function>;
    wheel: Signal<Function>;
    entered: Signal<Function>;
    exited: Signal<Function>;
    canceled: Signal<Function>;
    containsPressChanged: Signal<Function>;
    pressAndHoldIntervalChanged: Signal<Function>;
} & QQuickItem;
export declare type QQuickMultiPointTouchArea = {
    readonly touchPoints: QQuickTouchPoint;
    minimumTouchPoints: number | undefined;
    maximumTouchPoints: number | undefined;
    mouseEnabled: boolean | undefined;
    pressed: Signal<Function>;
    updated: Signal<Function>;
    released: Signal<Function>;
    canceled: Signal<Function>;
    gestureStarted: Signal<Function>;
    touchUpdated: Signal<Function>;
} & QQuickItem;
export declare type QQuickNumberAnimation = {
    from: number | undefined;
    to: number | undefined;
} & QQuickPropertyAnimation;
export declare type QQuickOpacityAnimator = {} & QQuickAnimator;
export declare enum QQuickOpenGLInfo_ContextProfile {
    NoProfile = 0,
    CoreProfile = 1,
    CompatibilityProfile = 2
}
export declare enum QQuickOpenGLInfo_RenderableType {
    Unspecified = 0,
    OpenGL = 1,
    OpenGLES = 2
}
export declare type QQuickOpenGLInfo = {
    readonly majorVersion: number;
    readonly minorVersion: number;
    readonly profile: QQuickOpenGLInfo_ContextProfile | string;
    readonly renderableType: QQuickOpenGLInfo_RenderableType | string;
} & QtQml.QObject;
export declare type QQuickPackage = {
    readonly data: QtQml.QObject;
} & QtQml.QObject;
export declare type QQuickPackageAttached = {
    name: string | undefined;
} & QtQml.QObject;
export declare enum QQuickPaintedItem_RenderTarget {
    Image = 0,
    FramebufferObject = 1,
    InvertedYFramebufferObject = 2
}
export declare type QQuickPaintedItem = {
    contentsSize: any;
    fillColor: any;
    contentsScale: number | undefined;
    renderTarget: QQuickPaintedItem_RenderTarget | string;
    textureSize: any;
} & QQuickItem;
export declare type QQuickParallelAnimation = {} & QQuickAnimationGroup;
export declare type QQuickParentAnimation = {
    target: QQuickItem | null;
    newParent: QQuickItem | null;
    via: QQuickItem | null;
} & QQuickAnimationGroup;
export declare type QQuickParentChange = {
    target: QQuickItem | null;
    parent: QQuickItem | null;
    x: any;
    y: any;
    width: any;
    height: any;
    scale: any;
    rotation: any;
} & QQuickStateOperation;
export declare type QQuickPath = {
    readonly pathElements: QQuickPathElement;
    startX: number | undefined;
    startY: number | undefined;
    readonly closed: boolean;
    changed: Signal<Function>;
} & QtQml.QObject;
export declare enum QQuickPathAnimation_Orientation {
    Fixed = 0,
    RightFirst = 1,
    LeftFirst = 2,
    BottomFirst = 3,
    TopFirst = 4
}
export declare type QQuickPathAnimation = {
    duration: number | undefined;
    easing: any;
    path: QQuickPath | null;
    target: QQuickItem | null;
    orientation: QQuickPathAnimation_Orientation | string;
    anchorPoint: any;
    orientationEntryDuration: number | undefined;
    orientationExitDuration: number | undefined;
    endRotation: number | undefined;
    durationChanged: Signal<Function>;
    easingChanged: Signal<Function>;
    orientationChanged: Signal<Function>;
    anchorPointChanged: Signal<Function>;
    orientationEntryDurationChanged: Signal<Function>;
    orientationExitDuration