from .core import send_message, ControlFloorResponse


def ackVideoFrame(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("ackVideoFrame", allow_errors=allow_errors)


def backgroundApplication(bundleId: str, processId: int = 0, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("backgroundApplication", args=locals(), allow_errors=allow_errors)


def benchmark(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("benchmark", allow_errors=allow_errors)


def broadcastText(text: str, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("broadcastText", args=locals(), allow_errors=allow_errors)


def burstVideo(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("burstVideo", allow_errors=allow_errors)


def cacheHardwareData(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("cacheHardwareData", allow_errors=allow_errors)


def cancel(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("cancel", allow_errors=allow_errors)


def cancelAllFileDownloads(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("cancelAllFileDownloads", allow_errors=allow_errors)


def cancelAllFileUploads(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("cancelAllFileUploads", allow_errors=allow_errors)


def cancelAllMediaDownloads(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("cancelAllMediaDownloads", allow_errors=allow_errors)


def cancelAllMediaUploads(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("cancelAllMediaUploads", allow_errors=allow_errors)


def cancelFileDownload(url: str = "", transferId: str = "", allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("cancelFileDownload", args=locals(), allow_errors=allow_errors)


def cancelFileUpload(transferId: str = "", allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("cancelFileUpload", args=locals(), allow_errors=allow_errors)


def cancelMediaDownload(url: str = "", transferId: str = "", allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("cancelMediaDownload", args=locals(), allow_errors=allow_errors)


def cancelMediaUpload(transferId: str = "", allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("cancelMediaUpload", args=locals(), allow_errors=allow_errors)


def centerSwipeDown(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("centerSwipeDown", allow_errors=allow_errors)


def centerSwipeLeft(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("centerSwipeLeft", allow_errors=allow_errors)


def centerSwipeRight(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("centerSwipeRight", allow_errors=allow_errors)


def centerSwipeUp(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("centerSwipeUp", allow_errors=allow_errors)


def clearCFAgentConfiguration(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("clearCFAgentConfiguration", allow_errors=allow_errors)


def clearCachedHardwareData(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("clearCachedHardwareData", allow_errors=allow_errors)


def clearCurrentElementText(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("clearCurrentElementText", allow_errors=allow_errors)


def clearInstallationIdentifier(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("clearInstallationIdentifier", allow_errors=allow_errors)


def clearLicenseGrant(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("clearLicenseGrant", allow_errors=allow_errors)


def click(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("click", args=locals(), allow_errors=allow_errors)


def continueFileUpload(data: str = "", transferId: str = "", allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("continueFileUpload", args=locals(), allow_errors=allow_errors)


def continueMediaUpload(data: str = "", transferId: str = "", allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("continueMediaUpload", args=locals(), allow_errors=allow_errors)


def disableCurrentApplication(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("disableCurrentApplication", allow_errors=allow_errors)


def disableSwitch(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("disableSwitch", args=locals(), allow_errors=allow_errors)


def doubleClick(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("doubleClick", args=locals(), allow_errors=allow_errors)


def doubleTap(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("doubleTap", args=locals(), allow_errors=allow_errors)


def edgeSwipeDown(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("edgeSwipeDown", allow_errors=allow_errors)


def edgeSwipeLeft(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("edgeSwipeLeft", allow_errors=allow_errors)


def edgeSwipeRight(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("edgeSwipeRight", allow_errors=allow_errors)


def edgeSwipeUp(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("edgeSwipeUp", allow_errors=allow_errors)


def enableCurrentApplication(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("enableCurrentApplication", allow_errors=allow_errors)


def enableSwitch(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("enableSwitch", args=locals(), allow_errors=allow_errors)


def getActiveApplication(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getActiveApplication", allow_errors=allow_errors)


def getAlert(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getAlert", allow_errors=allow_errors)


def getApplicationStack(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getApplicationStack", allow_errors=allow_errors)


def getApplicationStructure(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getApplicationStructure", args=locals(), allow_errors=allow_errors)


def getButtons(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    unnamedOnly: bool = False,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getButtons", args=locals(), allow_errors=allow_errors)


def getCFAgentCapabilities(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getCFAgentCapabilities", allow_errors=allow_errors)


def getCFAgentConfiguration(excludeKeyboard: bool = False, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getCFAgentConfiguration", args=locals(), allow_errors=allow_errors)


def getCFAgentDeviceInformation(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getCFAgentDeviceInformation", allow_errors=allow_errors)


def getCachedHardwareData(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getCachedHardwareData", allow_errors=allow_errors)


def getColorCountForRegion(
    x: int = 0,
    y: int = 0,
    width: int = 0,
    height: int = 0,
    format: str = "",
    useFullResolution: bool = False,
    useLogicalResolution: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getColorCountForRegion", args=locals(), allow_errors=allow_errors)


def getColorCountsForRegions(
    format: str = "",
    regions: list[dict[str:int]] | None = [],
    useFullResolution: bool = False,
    useLogicalResolution: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getColorCountsForRegions", args=locals(), allow_errors=allow_errors)


def getDeviceOrientation(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getDeviceOrientation", allow_errors=allow_errors)


def getDownloadFolder(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getDownloadFolder", allow_errors=allow_errors)


def getElement(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getElement", args=locals(), allow_errors=allow_errors)


def getElementAtPoint(
    x: float = 0,
    y: float = 0,
    includeValue: bool = False,
    scaleCoordinates: bool = False,
    withIdentifier: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getElementAtPoint", args=locals(), allow_errors=allow_errors)


def getElementHandle(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getElementHandle", args=locals(), allow_errors=allow_errors)


def getElementWithKeyboardFocus(
    fields: str | list[str] | None = [], omitEmptyStrings: bool = False, allow_errors: bool = False
) -> "ControlFloorResponse":
    return send_message("getElementWithKeyboardFocus", args=locals(), allow_errors=allow_errors)


def getElements(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    unnamedOnly: bool = False,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getElements", args=locals(), allow_errors=allow_errors)


def getElementsAlongLine(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x1: float = 0,
    y1: float = 0,
    x2: float = 0,
    y2: float = 0,
    step: float = 0,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    unnamedOnly: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getElementsAlongLine", args=locals(), allow_errors=allow_errors)


def getElementsAtPoints(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    points: list[dict[str:int]] | None = [],
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    unnamedOnly: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getElementsAtPoints", args=locals(), allow_errors=allow_errors)


def getFileContents(path: str, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getFileContents", args=locals(), allow_errors=allow_errors)


def getFileList(path: str, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getFileList", args=locals(), allow_errors=allow_errors)


def getFilenameForURL(url: str = "", allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getFilenameForURL", args=locals(), allow_errors=allow_errors)


def getFullResolutionScreenshot(
    format: str = "",
    jpegQuality: int = 0,
    maxDimension: int = 0,
    maxHeight: int = 0,
    maxScale: float = 0,
    maxWidth: int = 0,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getFullResolutionScreenshot", args=locals(), allow_errors=allow_errors)


def getHTTPStatusForURL(url: str = "", method: str = "", allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getHTTPStatusForURL", args=locals(), allow_errors=allow_errors)


def getHistogramForRegion(
    x: int = 0,
    y: int = 0,
    width: int = 0,
    height: int = 0,
    format: str = "",
    useFullResolution: bool = False,
    useLogicalResolution: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getHistogramForRegion", args=locals(), allow_errors=allow_errors)


def getHistogramsForRegions(
    format: str = "",
    regions: list[dict[str:int]] | None = [],
    useFullResolution: bool = False,
    useLogicalResolution: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getHistogramsForRegions", args=locals(), allow_errors=allow_errors)


def getInputElements(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    unnamedOnly: bool = False,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getInputElements", args=locals(), allow_errors=allow_errors)


def getInstalledKeyboards(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getInstalledKeyboards", allow_errors=allow_errors)


def getInteractiveElements(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    unnamedOnly: bool = False,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getInteractiveElements", args=locals(), allow_errors=allow_errors)


def getInterfaceOrientation(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getInterfaceOrientation", allow_errors=allow_errors)


def getInternetStatus(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getInternetStatus", allow_errors=allow_errors)


def getKeyboardPlist(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getKeyboardPlist", allow_errors=allow_errors)


def getKeyboards(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    unnamedOnly: bool = False,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getKeyboards", args=locals(), allow_errors=allow_errors)


def getKeys(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    unnamedOnly: bool = False,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getKeys", args=locals(), allow_errors=allow_errors)


def getLicenseGrant(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getLicenseGrant", allow_errors=allow_errors)


def getLicenseGrantRequest(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getLicenseGrantRequest", allow_errors=allow_errors)


def getLiveApplicationStructure(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getLiveApplicationStructure", args=locals(), allow_errors=allow_errors)


def getNamedElementAtPoint(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getNamedElementAtPoint", args=locals(), allow_errors=allow_errors)


def getNamedElements(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    unnamedOnly: bool = False,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getNamedElements", args=locals(), allow_errors=allow_errors)


def getNamedInputElements(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    unnamedOnly: bool = False,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getNamedInputElements", args=locals(), allow_errors=allow_errors)


def getNetworkInterfaces(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getNetworkInterfaces", allow_errors=allow_errors)


def getOrSelectDownloadFolder(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getOrSelectDownloadFolder", allow_errors=allow_errors)


def getPixelAtPoint(
    x: int = 0,
    y: int = 0,
    format: str = "",
    useFullResolution: bool = False,
    useLogicalResolution: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getPixelAtPoint", args=locals(), allow_errors=allow_errors)


def getPixelsAtPoints(
    points: list[dict[str:int]] | None = [],
    format: str = "",
    useFullResolution: bool = False,
    useLogicalResolution: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getPixelsAtPoints", args=locals(), allow_errors=allow_errors)


def getPixelsInRegion(
    x: int = 0,
    y: int = 0,
    width: int = 0,
    height: int = 0,
    format: str = "",
    useFullResolution: bool = False,
    useLogicalResolution: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getPixelsInRegion", args=locals(), allow_errors=allow_errors)


def getPixelsInRegions(
    format: str = "",
    regions: list[dict[str:int]] | None = [],
    useFullResolution: bool = False,
    useLogicalResolution: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getPixelsInRegions", args=locals(), allow_errors=allow_errors)


def getScreenshot(
    format: str = "",
    jpegQuality: int = 0,
    maxDimension: int = 0,
    maxHeight: int = 0,
    maxScale: float = 0,
    maxWidth: int = 0,
    useFullResolution: bool = False,
    useLogicalResolution: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getScreenshot", args=locals(), allow_errors=allow_errors)


def getScrollRegion(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getScrollRegion", args=locals(), allow_errors=allow_errors)


def getSwitches(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    unnamedOnly: bool = False,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getSwitches", args=locals(), allow_errors=allow_errors)


def getSystemApplicationStructure(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getSystemApplicationStructure", args=locals(), allow_errors=allow_errors)


def getSystemButtons(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    unnamedOnly: bool = False,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getSystemButtons", args=locals(), allow_errors=allow_errors)


def getSystemSwitches(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    unnamedOnly: bool = False,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getSystemSwitches", args=locals(), allow_errors=allow_errors)


def getUnnamedElements(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    unnamedOnly: bool = False,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getUnnamedElements", args=locals(), allow_errors=allow_errors)


def getUnnamedInteractiveElements(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    containsElementAtCenter: bool = False,
    elementSearchPath: str | list[str] | None = [],
    fields: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    insideElementAtCenter: bool = False,
    matchesElementAtCenter: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    nestsWithElementAtCenter: bool = False,
    omitEmptyStrings: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    unnamedOnly: bool = False,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("getUnnamedInteractiveElements", args=locals(), allow_errors=allow_errors)


def getVideoSize(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getVideoSize", allow_errors=allow_errors)


def getVideoStreamConfiguration(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getVideoStreamConfiguration", allow_errors=allow_errors)


def getVideoStreamStatus(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getVideoStreamStatus", allow_errors=allow_errors)


def getWifiIP(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getWifiIP", allow_errors=allow_errors)


def getWindowSize(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("getWindowSize", allow_errors=allow_errors)


def hugo(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("hugo", allow_errors=allow_errors)


def idleVideo(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("idleVideo", allow_errors=allow_errors)


def inspectDevice(
    keyboardValidation: str = "",
    skipSecondaryCharacterDetection: bool = False,
    validateSecondaryCharacters: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("inspectDevice", args=locals(), allow_errors=allow_errors)


def iohid(page: int = 0, usage: int = 0, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("iohid", args=locals(), allow_errors=allow_errors)


def launchApplication(bundleId: str, relaunch: bool = False, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("launchApplication", args=locals(), allow_errors=allow_errors)


def loadCFAgentConfiguration(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("loadCFAgentConfiguration", allow_errors=allow_errors)


def loadSignedLicenseGrant(data: str = "", signature: str = "", allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("loadSignedLicenseGrant", args=locals(), allow_errors=allow_errors)


def logText(text: str, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("logText", args=locals(), allow_errors=allow_errors)


def mouseDown(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("mouseDown", args=locals(), allow_errors=allow_errors)


def mouseUp(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("mouseUp", args=locals(), allow_errors=allow_errors)


def multiTouchGesture(paths: list | None = [], allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("multiTouchGesture", args=locals(), allow_errors=allow_errors)


def openURL(url: str = "", allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("openURL", args=locals(), allow_errors=allow_errors)


def ozymandias(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("ozymandias", allow_errors=allow_errors)


def performGesture(
    gesture: str,
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("performGesture", args=locals(), allow_errors=allow_errors)


def searchForElementDepth(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    noNotices: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("searchForElementDepth", args=locals(), allow_errors=allow_errors)


def searchForNamedElements(
    elementTypes: str | list[str] | None = [],
    caseInsensitive: bool = False,
    fields: str | list[str] | None = [],
    maxElements: int = 0,
    noNotices: bool = False,
    omitEmptyStrings: bool = False,
    stopElementIds: list[str] | None = [],
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("searchForNamedElements", args=locals(), allow_errors=allow_errors)


def secureTapText(text: str, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("secureTapText", args=locals(), allow_errors=allow_errors)


def secureTypeText(text: str, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("secureTypeText", args=locals(), allow_errors=allow_errors)


def selectDownloadFolder(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("selectDownloadFolder", allow_errors=allow_errors)


def setAudioStreamConfiguration(
    encoding: str = "", silence: str = "", allow_errors: bool = False
) -> "ControlFloorResponse":
    return send_message("setAudioStreamConfiguration", args=locals(), allow_errors=allow_errors)


def setDeviceOrientation(orientation: str, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("setDeviceOrientation", args=locals(), allow_errors=allow_errors)


def setVideoStreamConfiguration(
    clientHeightLandscape: int = 0,
    clientHeightPortrait: int = 0,
    clientWidthLandscape: int = 0,
    clientWidthPortrait: int = 0,
    logicalHeightPortrait: int = 0,
    logicalWidthPortrait: int = 0,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("setVideoStreamConfiguration", args=locals(), allow_errors=allow_errors)


def showControlCenter(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("showControlCenter", allow_errors=allow_errors)


def simulateGetWindowSizeBug(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("simulateGetWindowSizeBug", allow_errors=allow_errors)


def simulateHomeButton(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("simulateHomeButton", allow_errors=allow_errors)


def simulateLockButton(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("simulateLockButton", allow_errors=allow_errors)


def simulateVolumeDownButton(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("simulateVolumeDownButton", allow_errors=allow_errors)


def simulateVolumeUpButton(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("simulateVolumeUpButton", allow_errors=allow_errors)


def siri(text: str, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("siri", args=locals(), allow_errors=allow_errors)


def startAudio(encoding: str = "", silence: str = "", allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("startAudio", args=locals(), allow_errors=allow_errors)


def startFileDownload(
    url: str = "",
    destination: str = "",
    filename: str = "",
    overwrite: bool = False,
    size: int = 0,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("startFileDownload", args=locals(), allow_errors=allow_errors)


def startFileUpload(
    data: str = "",
    destination: str = "",
    filename: str = "",
    overwrite: bool = False,
    size: int = 0,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("startFileUpload", args=locals(), allow_errors=allow_errors)


def startMediaDownload(
    url: str = "",
    destination: str = "",
    filename: str = "",
    overwrite: bool = False,
    size: int = 0,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("startMediaDownload", args=locals(), allow_errors=allow_errors)


def startMediaUpload(
    data: str = "",
    destination: str = "",
    filename: str = "",
    overwrite: bool = False,
    size: int = 0,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("startMediaUpload", args=locals(), allow_errors=allow_errors)


def startVideo(
    clientHeightLandscape: int = 0,
    clientHeightPortrait: int = 0,
    clientWidthLandscape: int = 0,
    clientWidthPortrait: int = 0,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("startVideo", args=locals(), allow_errors=allow_errors)


def stopAudio(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("stopAudio", allow_errors=allow_errors)


def stopVideo(allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("stopVideo", allow_errors=allow_errors)


def swipe(path: list | None = [], allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("swipe", args=locals(), allow_errors=allow_errors)


def swipeDown(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    width: float = 0,
    height: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("swipeDown", args=locals(), allow_errors=allow_errors)


def swipeLeft(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    width: float = 0,
    height: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("swipeLeft", args=locals(), allow_errors=allow_errors)


def swipeRight(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    width: float = 0,
    height: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("swipeRight", args=locals(), allow_errors=allow_errors)


def swipeUp(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    width: float = 0,
    height: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("swipeUp", args=locals(), allow_errors=allow_errors)


def tap(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    duration: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    pressure: float = 0,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("tap", args=locals(), allow_errors=allow_errors)


def tapAndHold(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("tapAndHold", args=locals(), allow_errors=allow_errors)


def tapAndHoldFirm(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("tapAndHoldFirm", args=locals(), allow_errors=allow_errors)


def tapFirm(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("tapFirm", args=locals(), allow_errors=allow_errors)


def tapText(text: str, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("tapText", args=locals(), allow_errors=allow_errors)


def terminatedApplication(bundleId: str, processId: int = 0, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("terminatedApplication", args=locals(), allow_errors=allow_errors)


def toggleSwitch(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("toggleSwitch", args=locals(), allow_errors=allow_errors)


def tripleTap(
    elementIds: str | list[str] | None = [],
    elementTypes: str | list[str] | None = [],
    x: float = 0,
    y: float = 0,
    avoidSnapshots: bool = False,
    caseInsensitive: bool = False,
    elementSearchPath: str | list[str] | None = [],
    includeAllNamedElements: bool = False,
    maxArrayCount: int = 0,
    maxChildren: int = 0,
    maxDepth: int = 0,
    namedOnly: bool = False,
    processId: int = 0,
    rootElementIds: str | list[str] | None = [],
    rootElementTypes: str | list[str] | None = [],
    scaleCoordinates: bool = False,
    timeout: float = 0,
    useApplicationSnapshot: bool = False,
    useCoordinates: bool = False,
    allow_errors: bool = False,
) -> "ControlFloorResponse":
    return send_message("tripleTap", args=locals(), allow_errors=allow_errors)


def typeSpecialKey(key: str, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("typeSpecialKey", args=locals(), allow_errors=allow_errors)


def typeText(text: str, allow_errors: bool = False) -> "ControlFloorResponse":
    return send_message("typeText", args=locals(), allow_errors=allow_errors)


def updateApplication(
    bundleId: str, isOverlay: bool = False, processId: int = 0, allow_errors: bool = False
) -> "ControlFloorResponse":
    return send_message("updateApplication", args=locals(), allow_errors=allow_errors)
