@appium/fake-driver 5.1.3 → 5.1.4

package/build/lib/commands/alert.d.ts

@@ -1,331 +1,79 @@
-/// <reference types="node" />
-/**
- * @template {Class<import('../types').IContextsCommands & import('@appium/types').IFindCommands>} T
- * @param {T} Base
- * @returns {Class<AlertCommands>}
- */
-export function AlertMixin<T extends Class<import("../types").IContextsCommands & import("@appium/types").IFindCommands<any>, {}, any[]>>(Base: T): Class<{
-    assertNoAlert(): void;
-    assertAlert(): void;
+declare namespace _default {
+    /**
+     * @this {FakeDriver}
+     */
+    function assertNoAlert(this: import("../driver").FakeDriver): void;
+    /**
+     * @this {FakeDriver}
+     */
+    function assertNoAlert(this: import("../driver").FakeDriver): void;
+    /**
+     * @this {FakeDriver}
+     */
+    function assertAlert(this: import("../driver").FakeDriver): void;
+    /**
+     * @this {FakeDriver}
+     */
+    function assertAlert(this: import("../driver").FakeDriver): void;
     /**
      * Get the text of an alert
      *
      * @returns {Promise<string>}
+     * @this {FakeDriver}
+     */
+    function getAlertText(this: import("../driver").FakeDriver): Promise<string>;
+    /**
+     * Get the text of an alert
+     *
+     * @returns {Promise<string>}
+     * @this {FakeDriver}
+     */
+    function getAlertText(this: import("../driver").FakeDriver): Promise<string>;
+    /**
+     * Set the text of an alert
+     *
+     * @param {string} text
+     * @returns {Promise<void>}
+     * @this {FakeDriver}
      */
-    getAlertText(): Promise<string>;
+    function setAlertText(this: import("../driver").FakeDriver, text: string): Promise<void>;
     /**
      * Set the text of an alert
      *
      * @param {string} text
      * @returns {Promise<void>}
+     * @this {FakeDriver}
      */
-    setAlertText(text: string): Promise<void>;
+    function setAlertText(this: import("../driver").FakeDriver, text: string): Promise<void>;
     /**
      * Accept an alert
      *
      * @returns {Promise<void>}
+     * @this {FakeDriver}
      */
-    postAcceptAlert(): Promise<void>;
+    function postAcceptAlert(this: import("../driver").FakeDriver): Promise<void>;
+    /**
+     * Accept an alert
+     *
+     * @returns {Promise<void>}
+     * @this {FakeDriver}
+     */
+    function postAcceptAlert(this: import("../driver").FakeDriver): Promise<void>;
     /**
      * Dismiss an alert
      *
-     * @returns {Promise<null>}
+     * @returns {Promise<void>}
+     * @this {FakeDriver}
+     */
+    function postDismissAlert(this: import("../driver").FakeDriver): Promise<void>;
+    /**
+     * Dismiss an alert
+     *
+     * @returns {Promise<void>}
+     * @this {FakeDriver}
      */
-    postDismissAlert: () => Promise<void>;
-    assertWebviewContext(): void;
-    elMap: Record<string, import("../fake-element").FakeElement>;
-    maxElId: number;
-    appModel: import("../fake-app").FakeApp;
-    focusedElId: string;
-    curContext: string;
-    server?: import("@appium/types").AppiumServer | undefined;
-    serverHost?: string | undefined;
-    serverPort?: number | undefined;
-    serverPath?: string | undefined;
-    setUrl?(url: string): Promise<void>;
-    getUrl?(): Promise<string>;
-    back?(): Promise<void>;
-    forward?(): Promise<void>;
-    refresh?(): Promise<void>;
-    title?(): Promise<string>;
-    getWindowHandle?(): Promise<string>;
-    closeWindow?(): Promise<string[]>;
-    setWindow?(handle: string): Promise<void>;
-    getWindowHandles?(): Promise<string[]>;
-    createNewWindow?(type?: import("@appium/types").NewWindowType | undefined): Promise<import("@appium/types").NewWindow>;
-    setFrame?(id: string | number | null): Promise<void>;
-    switchToParentFrame?(): Promise<void>;
-    getWindowRect?(): Promise<import("@appium/types").Rect>;
-    setWindowRect?(x: number, y: number, width: number, height: number): Promise<import("@appium/types").Rect>;
-    maximizeWindow?(): Promise<import("@appium/types").Rect>;
-    minimizeWindow?(): Promise<import("@appium/types").Rect>;
-    fullScreenWindow?(): Promise<import("@appium/types").Rect>;
-    active?(): Promise<import("@appium/types").Element>;
-    elementShadowRoot?(elementId: string): Promise<import("@appium/types").Element>;
-    elementSelected?(elementId: string): Promise<boolean>;
-    getAttribute?(name: string, elementId: string): Promise<string | null>;
-    getProperty?(name: string, elementId: string): Promise<string | null>;
-    getCssProperty?(name: string, elementId: string): Promise<string>;
-    getText?(elementId: string): Promise<string>;
-    getName?(elementId: string): Promise<string>;
-    getElementRect?(elementId: string): Promise<import("@appium/types").Rect>;
-    elementEnabled?(elementId: string): Promise<boolean>;
-    getComputedRole?(elementId: string): Promise<string | null>;
-    getComputedLabel?(elementId: string): Promise<string | null>;
-    elementDisplayed?(elementId: string): Promise<boolean>;
-    click?(elementId: string): Promise<void>;
-    clear?(elementId: string): Promise<void>;
-    setValue?(text: string, elementId: string): Promise<void>;
-    execute?(script: string, args: unknown[]): Promise<unknown>;
-    executeAsync?(script: string, args: unknown[]): Promise<unknown>;
-    getCookies?(): Promise<import("@appium/types").Cookie[]>;
-    getCookie?(name: string): Promise<import("@appium/types").Cookie>;
-    setCookie?(cookie: import("@appium/types").Cookie): Promise<void>;
-    deleteCookie?(name: string): Promise<void>;
-    deleteCookies?(): Promise<void>;
-    performActions?(actions: import("@appium/types").ActionSequence[]): Promise<void>;
-    releaseActions?(): Promise<void>;
-    getScreenshot?(): Promise<string>;
-    getElementScreenshot?(elementId: string): Promise<string>;
-    mobileShake?(): Promise<void>;
-    getDeviceTime?(format?: string | undefined): Promise<string>;
-    lock?(seconds?: number | undefined): Promise<void>;
-    unlock?(): Promise<void>;
-    isLocked?(): Promise<boolean>;
-    startRecordingScreen?(options?: import("@appium/types").StartScreenRecordOptions | undefined): Promise<void>;
-    stopRecordingScreen?(options?: import("@appium/types").StopScreenRecordOptions | undefined): Promise<string>;
-    getPerformanceDataTypes?(): Promise<string[]>;
-    getPerformanceData?(packageName: string, dataType: string, dataReadTimeout?: number | undefined): Promise<string[]>;
-    pressKeyCode?(keycode: number, metastate?: number | undefined, flags?: number | undefined): Promise<void>;
-    longPressKeyCode?(keycode: number, metastate?: number | undefined, flags?: number | undefined): Promise<void>;
-    fingerprint?(fingerprintId: number): Promise<void>;
-    sendSMS?(phoneNumber: string, message: string): Promise<void>;
-    gsmCall?(phoneNumber: string, action: string): Promise<void>;
-    gsmSignal?(signalStrength: string): Promise<void>;
-    gsmVoice?(state: string): Promise<void>;
-    powerCapacity?(percent: number): Promise<void>;
-    powerAC?(state: string): Promise<void>;
-    networkSpeed?(netspeed: string): Promise<void>;
-    keyevent?(keycode: string, metastate?: string | undefined): Promise<void>;
-    mobileRotation?(x: number, y: number, radius: number, rotation: number, touchCount: number, duration: string, elementId?: string | undefined): Promise<void>;
-    getCurrentActivity?(): Promise<string>;
-    getCurrentPackage?(): Promise<string>;
-    installApp?(appPath: string, options?: unknown): Promise<void>;
-    activateApp?(appId: string, options?: unknown): Promise<void>;
-    removeApp?(appId: string, options?: unknown): Promise<void>;
-    terminateApp?(appId: string, options?: unknown): Promise<void>;
-    isAppInstalled?(appId: string): Promise<boolean>;
-    queryAppState?(appId: string): Promise<0 | 1 | 3 | 4>;
-    hideKeyboard?(strategy?: string | undefined, key?: string | undefined, keyCode?: string | undefined, keyName?: string | undefined): Promise<void>;
-    isKeyboardShown?(): Promise<boolean>;
-    pushFile?(path: string, data: string): Promise<void>;
-    pullFile?(path: string): Promise<string>;
-    pullFolder?(path: string): Promise<string>;
-    toggleFlightMode?(): Promise<void>;
-    toggleData?(): Promise<void>;
-    toggleWiFi?(): Promise<void>;
-    toggleLocationServices?(): Promise<void>;
-    openNotifications?(): Promise<void>;
-    startActivity?(appPackage: string, appActivity: string, appWaitPackage?: string | undefined, appWaitActivity?: string | undefined, intentAction?: string | undefined, intentCategory?: string | undefined, intentFlags?: string | undefined, optionalIntentArguments?: string | undefined, dontStopAppOnReset?: boolean | undefined): Promise<void>;
-    getSystemBars?(): Promise<unknown[]>;
-    getDisplayDensity?(): Promise<number>;
-    touchId?(match: boolean): Promise<void>;
-    toggleEnrollTouchId?(enabled: boolean): Promise<void>;
-    launchApp?(): Promise<void>;
-    closeApp?(): Promise<void>;
-    background?(seconds: number | null): Promise<void>;
-    endCoverage?(intent: string, path: string): Promise<void>;
-    getStrings?(language?: string | undefined, stringFile?: string | undefined): Promise<Record<string, unknown>>;
-    setValueImmediate?(value: string, elementId: string): Promise<void>;
-    replaceValue?(value: string, elementId: string): Promise<void>;
-    receiveAsyncResponse?(response: unknown): Promise<void>;
-    setClipboard?(content: string, contentType?: string | undefined, label?: string | undefined): Promise<void>;
-    getClipboard?(contentType?: string | undefined): Promise<string>;
-    asyncScriptTimeout?(ms: number): Promise<void>;
-    getWindowSize?(): Promise<import("@appium/types").Size>;
-    getLocation?(elementId: string): Promise<import("@appium/types").Position>;
-    getLocationInView?(elementId: string): Promise<import("@appium/types").Position>;
-    getSize?(elementId: string): Promise<import("@appium/types").Size>;
-    equalsElement?(elementId: string, otherElementId: string): Promise<boolean>;
-    submit?(elementId: string): Promise<void>;
-    keys?(value: string[]): Promise<void>;
-    availableIMEEngines?(): Promise<string[]>;
-    getActiveIMEEngine?(): Promise<string>;
-    isIMEActivated?(): Promise<boolean>;
-    deactivateIMEEngine?(): Promise<void>;
-    activateIMEEngine?(engine: string): Promise<void>;
-    getOrientation?(): Promise<string>;
-    setOrientation?(orientation: string): Promise<void>;
-    moveTo?(element?: string | null | undefined, xOffset?: number | undefined, yOffset?: number | undefined): Promise<void>;
-    buttonDown?(button?: number | undefined): Promise<void>;
-    buttonUp?(button?: number | undefined): Promise<void>;
-    clickCurrent?(button?: number | undefined): Promise<void>;
-    doubleClick?(): Promise<void>;
-    touchDown?(x: number, y: number): Promise<void>;
-    touchUp?(x: number, y: number): Promise<void>;
-    touchMove?(x: number, y: number): Promise<void>;
-    touchLongClick?(elementId: string): Promise<void>;
-    flick?(element?: string | undefined, xSpeed?: number | undefined, ySpeed?: number | undefined, xOffset?: number | undefined, yOffset?: number | undefined, speed?: number | undefined): Promise<void>;
-    getGeoLocation?(): Promise<import("@appium/types").Location>;
-    setGeoLocation?(location: Partial<import("@appium/types").Location>): Promise<void>;
-    getCurrentContext?(): Promise<string | null>;
-    setContext?(name: string): Promise<void>;
-    getContexts?(): Promise<string[]>;
-    getPageIndex?(elementId: string): Promise<string>;
-    getNetworkConnection?(): Promise<number>;
-    setNetworkConnection?(type: number): Promise<void>;
-    performTouch?(actions: unknown): Promise<void>;
-    performMultiAction?(actions: unknown, elementId: string): Promise<void>;
-    getRotation?(): Promise<import("@appium/types").Rotation>;
-    setRotation?(x: number, y: number, z: number): Promise<void>;
-    executeCdp?(cmd: string, params: unknown): Promise<unknown>;
-    addVirtualAuthenticator?(protocol: "ctap/u2f" | "ctap2" | "ctap2_1", transport: string, hasResidentKey?: boolean | undefined, hasUserVerification?: boolean | undefined, isUserConsenting?: boolean | undefined, isUserVerified?: boolean | undefined): Promise<string>;
-    removeVirtualAuthenticator?(authenticatorId: string): Promise<void>;
-    addAuthCredential?(credentialId: string, isResidentCredential: boolean, rpId: string, privateKey: string, userHandle: string, signCount: number, authenticatorId: string): Promise<void>;
-    getAuthCredential?(): Promise<import("@appium/types").Credential[]>;
-    removeAllAuthCredentials?(): Promise<void>;
-    removeAuthCredential?(credentialId: string, authenticatorId: string): Promise<void>;
-    setUserAuthVerified?(isUserVerified: boolean, authenticatorId: string): Promise<void>;
-    proxyCommand?<T_1 = any>(url: string, method: import("@appium/types").HTTPMethod, body?: string | undefined): Promise<T_1>;
-    cliArgs: import("@appium/types").StringRecord;
-    executeCommand(cmd: string, ...args: any[]): Promise<any>;
-    startUnexpectedShutdown(err?: Error | undefined): Promise<void>;
-    startNewCommandTimeout(): Promise<void>;
-    reset(): Promise<void>;
-    caps?: Partial<import("@appium/types").ConstraintsToCaps<{
-        readonly app: {
-            readonly presence: true;
-            readonly isString: true;
-        };
-        readonly uniqueApp: {
-            readonly isBoolean: true;
-        };
-    }> & void> | undefined;
-    originalCaps?: import("@appium/types").W3CCapabilities<{
-        readonly app: {
-            readonly presence: true;
-            readonly isString: true;
-        };
-        readonly uniqueApp: {
-            readonly isBoolean: true;
-        };
-    }, void> | undefined;
-    desiredCapConstraints: {
-        readonly app: {
-            readonly presence: true;
-            readonly isString: true;
-        };
-        readonly uniqueApp: {
-            readonly isBoolean: true;
-        };
-    };
-    assignServer?(server: import("@appium/types").AppiumServer, host: string, port: number, path: string): void;
-    getSessions(): Promise<import("@appium/types").MultiSessionData<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS, void>[]>;
-    getSession(): Promise<import("@appium/types").SingularSessionData<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS, void>>;
-    supportedLogTypes: Readonly<import("@appium/types").LogDefRecord<{
-        readonly app: {
-            readonly presence: true;
-            readonly isString: true;
-        };
-        readonly uniqueApp: {
-            readonly isBoolean: true;
-        };
-    }>>;
-    getLogTypes(): Promise<string[]>;
-    getLog(logType: string): Promise<unknown[]>;
-    findElement(strategy: string, selector: string): Promise<import("@appium/types").Element>;
-    findElements(strategy: string, selector: string): Promise<import("@appium/types").Element[]>;
-    findElementFromElement(strategy: string, selector: string, elementId: string): Promise<import("@appium/types").Element>;
-    findElementsFromElement(strategy: string, selector: string, elementId: string): Promise<import("@appium/types").Element[]>;
-    findElementFromShadowRoot?(strategy: string, selector: string, shadowId: string): Promise<import("@appium/types").Element>;
-    findElementsFromShadowRoot?(strategy: string, selector: string, shadowId: string): Promise<import("@appium/types").Element[]>;
-    findElOrEls<Mult extends boolean>(strategy: string, selector: string, mult: Mult, context?: any): Promise<Mult extends true ? import("@appium/types").Element[] : import("@appium/types").Element>;
-    findElOrElsWithProcessing<Mult_1 extends boolean>(strategy: string, selector: string, mult: Mult_1, context?: any): Promise<Mult_1 extends true ? import("@appium/types").Element[] : import("@appium/types").Element>;
-    getPageSource(): Promise<string>;
-    updateSettings: (settings: import("@appium/types").StringRecord) => Promise<void>;
-    getSettings(): Promise<import("@appium/types").StringRecord>;
-    timeouts(type: string, ms: string | number, script?: number | undefined, pageLoad?: number | undefined, implicit?: string | number | undefined): Promise<void>;
-    setNewCommandTimeout(ms: number): void;
-    implicitWait(ms: string | number): Promise<void>;
-    setImplicitWait(ms: number): void;
-    implicitWaitForCondition(condition: () => Promise<any>): Promise<unknown>;
-    getTimeouts(): Promise<Record<string, number>>;
-    implicitWaitW3C(ms: number): Promise<void>;
-    implicitWaitMJSONWP(ms: number): Promise<void>;
-    pageLoadTimeoutW3C(ms: number): Promise<void>;
-    pageLoadTimeoutMJSONWP(ms: number): Promise<void>;
-    scriptTimeoutW3C(ms: number): Promise<void>;
-    scriptTimeoutMJSONWP(ms: number): Promise<void>;
-    newCommandTimeout(ms: number): Promise<void>;
-    parseTimeoutArgument(ms: string | number): number;
-    logCustomEvent(vendor: string, event: string): Promise<void>;
-    getLogEvents(type?: string | string[] | undefined): Promise<import("@appium/types").EventHistory | Record<string, number>>;
-    executeMethod(script: string, args: [] | [import("@appium/types").StringRecord]): Promise<any>;
-    createSession(w3cCaps1: import("@appium/types").W3CCapabilities<{
-        readonly app: {
-            readonly presence: true;
-            readonly isString: true;
-        };
-        readonly uniqueApp: {
-            readonly isBoolean: true;
-        };
-    }, void>, w3cCaps2?: import("@appium/types").W3CCapabilities<{
-        readonly app: {
-            readonly presence: true;
-            readonly isString: true;
-        };
-        readonly uniqueApp: {
-            readonly isBoolean: true;
-        };
-    }, void> | undefined, w3cCaps3?: import("@appium/types").W3CCapabilities<{
-        readonly app: {
-            readonly presence: true;
-            readonly isString: true;
-        };
-        readonly uniqueApp: {
-            readonly isBoolean: true;
-        };
-    }, void> | undefined, driverData?: import("@appium/types").DriverData[] | undefined): Promise<[string, any]>;
-    deleteSession(sessionId?: string | undefined, driverData?: import("@appium/types").DriverData[] | undefined): Promise<void>;
-    shouldValidateCaps: boolean;
-    sessionId: string | null;
-    opts: import("@appium/types").DriverOpts<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS>;
-    initialOpts: import("@appium/types").ServerArgs;
-    protocol?: string | undefined;
-    helpers: import("@appium/types").DriverHelpers<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS>;
-    basePath: string;
-    relaxedSecurityEnabled: boolean;
-    allowInsecure: string[];
-    denyInsecure: string[];
-    newCommandTimeoutMs: number;
-    implicitWaitMs: number;
-    locatorStrategies: string[];
-    webLocatorStrategies: string[];
-    eventEmitter: import("events");
-    settings: import("@appium/types").DeviceSettings<any>;
-    log: import("@appium/types").AppiumLogger;
-    driverData?: import("@appium/types").DriverData | undefined;
-    isCommandsQueueEnabled: boolean;
-    eventHistory: import("@appium/types").EventHistory;
-    onUnexpectedShutdown(handler: () => any): void;
-    getStatus(): Promise<any>;
-    sessionExists(sessionId: string): boolean;
-    isW3CProtocol(): boolean;
-    isMjsonwpProtocol(): boolean;
-    isFeatureEnabled(name: string): boolean;
-    assertFeatureEnabled(name: string): void;
-    validateLocatorStrategy(strategy: string, webContext?: boolean | undefined): void;
-    proxyActive(sessionId?: string | undefined): boolean;
-    getProxyAvoidList(sessionId?: string | undefined): import("@appium/types").RouteMatcher[];
-    canProxy(sessionId?: string | undefined): boolean;
-    proxyRouteIsAvoided(sessionId: string, method: string, url: string): boolean;
-    addManagedDriver(driver: import("@appium/types").Driver<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS, import("@appium/types").StringRecord, any>): void;
-    getManagedDrivers(): import("@appium/types").Driver<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS, import("@appium/types").StringRecord, any>[];
-    clearNewCommandTimeout(): Promise<void>;
-    logEvent(eventName: string): void;
-    driverForSession(sessionId: string): import("@appium/types").Core<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS> | null;
-}>;
-export type FakeDriverCore = import('../driver').FakeDriverCore;
-export type Class<T, U = {}, V = any[]> = import('@appium/types').Class<T, U, V>;
-export type IAlertCommands = import('../types').IAlertCommands;
+    function postDismissAlert(this: import("../driver").FakeDriver): Promise<void>;
+}
+export default _default;
+export type FakeDriver = import('../driver').FakeDriver;
 //# sourceMappingURL=alert.d.ts.map

package/build/lib/commands/alert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"alert.d.ts","sourceRoot":"","sources":["../../../lib/commands/alert.js"],"names":[],"mappings":";AAEA;;;;GAIG;AACH,oJAFa;;;IAmBT;;;;OAIG;oBADU,QAAQ,MAAM,CAAC;IAO5B;;;;;OAKG;uBAFQ,MAAM,GACJ,QAAQ,IAAI,CAAC;IAW1B;;;;OAIG;uBADU,QAAQ,IAAI,CAAC;IAO1B;;;;OAIG;4BAXU,QAAQ,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA/CG,CA+DhC;6BAGY,OAAO,WAAW,EAAE,cAAc;0CAKlC,OAAO,eAAe,EAAE,KAAK,CAAC,CAAC,EAAC,CAAC,EAAC,CAAC,CAAC;6BAIpC,OAAO,UAAU,EAAE,cAAc"}
+{"version":3,"file":"alert.d.ts","sourceRoot":"","sources":["../../../lib/commands/alert.js"],"names":[],"mappings":";IAGE;;OAEG;IACH,mEAIC;IAPD;;OAEG;IACH,mEAIC;IAED;;OAEG;IACH,iEAIC;IAPD;;OAEG;IACH,iEAIC;IAED;;;;;OAKG;IACH,6EAGC;IATD;;;;;OAKG;IACH,6EAGC;IAED;;;;;;OAMG;IACH,yFAOC;IAdD;;;;;;OAMG;IACH,yFAOC;IAED;;;;;OAKG;IACH,8EAGC;IATD;;;;;OAKG;IACH,8EAGC;IAED;;;;;OAKG;IACH,+EAEC;IARD;;;;;OAKG;IACH,+EAEC;;;yBAIU,OAAO,WAAW,EAAE,UAAU"}

package/build/lib/commands/alert.js

@@ -1,81 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AlertMixin = void 0;
 const driver_1 = require("appium/driver");
-/**
- * @template {Class<import('../types').IContextsCommands & import('@appium/types').IFindCommands>} T
- * @param {T} Base
- * @returns {Class<AlertCommands>}
- */
-function AlertMixin(Base) {
+exports.default = {
     /**
-     * @implements {IAlertCommands}
+     * @this {FakeDriver}
      */
-    class AlertCommands extends Base {
-        constructor() {
-            super(...arguments);
-            /**
-             * Dismiss an alert
-             *
-             * @returns {Promise<null>}
-             */
-            this.postDismissAlert = this.postAcceptAlert;
-        }
-        assertNoAlert() {
-            if (this.appModel.hasAlert()) {
-                throw new driver_1.errors.UnexpectedAlertOpenError();
-            }
+    assertNoAlert() {
+        if (this.appModel.hasAlert()) {
+            throw new driver_1.errors.UnexpectedAlertOpenError();
         }
-        assertAlert() {
-            if (!this.appModel.hasAlert()) {
-                throw new driver_1.errors.NoAlertOpenError();
-            }
-        }
-        /**
-         * Get the text of an alert
-         *
-         * @returns {Promise<string>}
-         */
-        async getAlertText() {
-            this.assertAlert();
-            return this.appModel.alertText();
+    },
+    /**
+     * @this {FakeDriver}
+     */
+    assertAlert() {
+        if (!this.appModel.hasAlert()) {
+            throw new driver_1.errors.NoAlertOpenError();
         }
-        /**
-         * Set the text of an alert
-         *
-         * @param {string} text
-         * @returns {Promise<void>}
-         */
-        async setAlertText(text) {
-            this.assertAlert();
-            try {
-                this.appModel.setAlertText(text);
-            }
-            catch (e) {
-                throw new driver_1.errors.InvalidElementStateError();
-            }
+    },
+    /**
+     * Get the text of an alert
+     *
+     * @returns {Promise<string>}
+     * @this {FakeDriver}
+     */
+    async getAlertText() {
+        this.assertAlert();
+        return this.appModel.alertText();
+    },
+    /**
+     * Set the text of an alert
+     *
+     * @param {string} text
+     * @returns {Promise<void>}
+     * @this {FakeDriver}
+     */
+    async setAlertText(text) {
+        this.assertAlert();
+        try {
+            this.appModel.setAlertText(text);
         }
-        /**
-         * Accept an alert
-         *
-         * @returns {Promise<void>}
-         */
-        async postAcceptAlert() {
-            this.assertAlert();
-            this.appModel.handleAlert();
+        catch (e) {
+            throw new driver_1.errors.InvalidElementStateError();
         }
-    }
-    return AlertCommands;
-}
-exports.AlertMixin = AlertMixin;
-/**
- * @typedef {import('../driver').FakeDriverCore} FakeDriverCore
- */
-/**
- * @template T,[U={}],[V=Array<any>]
- * @typedef {import('@appium/types').Class<T,U,V>} Class
- */
+    },
+    /**
+     * Accept an alert
+     *
+     * @returns {Promise<void>}
+     * @this {FakeDriver}
+     */
+    async postAcceptAlert() {
+        this.assertAlert();
+        this.appModel.handleAlert();
+    },
+    /**
+     * Dismiss an alert
+     *
+     * @returns {Promise<void>}
+     * @this {FakeDriver}
+     */
+    async postDismissAlert() {
+        return this.postAcceptAlert();
+    },
+};
 /**
- * @typedef {import('../types').IAlertCommands} IAlertCommands
+ * @typedef {import('../driver').FakeDriver} FakeDriver
  */
 //# sourceMappingURL=alert.js.map

package/build/lib/commands/alert.js.map

@@ -1 +1 @@
-{"version":3,"file":"alert.js","sourceRoot":"","sources":["../../../lib/commands/alert.js"],"names":[],"mappings":";;;AAAA,0CAAqC;AAErC;;;;GAIG;AACH,SAAgB,UAAU,CAAC,IAAI;IAC7B;;OAEG;IACH,MAAM,aAAc,SAAQ,IAAI;QAAhC;;YAgDE;;;;eAIG;YACH,qBAAgB,GAAG,IAAI,CAAC,eAAe,CAAC;QAC1C,CAAC;QArDC,aAAa;YACX,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE;gBAC5B,MAAM,IAAI,eAAM,CAAC,wBAAwB,EAAE,CAAC;aAC7C;QACH,CAAC;QAED,WAAW;YACT,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE;gBAC7B,MAAM,IAAI,eAAM,CAAC,gBAAgB,EAAE,CAAC;aACrC;QACH,CAAC;QAED;;;;WAIG;QACH,KAAK,CAAC,YAAY;YAChB,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;QACnC,CAAC;QAED;;;;;WAKG;QACH,KAAK,CAAC,YAAY,CAAC,IAAI;YACrB,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI;gBACF,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;aAClC;YAAC,OAAO,CAAC,EAAE;gBACV,MAAM,IAAI,eAAM,CAAC,wBAAwB,EAAE,CAAC;aAC7C;QACH,CAAC;QAED;;;;WAIG;QACH,KAAK,CAAC,eAAe;YACnB,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAC9B,CAAC;KAQF;IAED,OAAO,aAAa,CAAC;AACvB,CAAC;AA7DD,gCA6DC;AAED;;GAEG;AAEH;;;GAGG;AAEH;;GAEG"}
+{"version":3,"file":"alert.js","sourceRoot":"","sources":["../../../lib/commands/alert.js"],"names":[],"mappings":";;AAAA,0CAAqC;AAErC,kBAAe;IACb;;OAEG;IACH,aAAa;QACX,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE;YAC5B,MAAM,IAAI,eAAM,CAAC,wBAAwB,EAAE,CAAC;SAC7C;IACH,CAAC;IAED;;OAEG;IACH,WAAW;QACT,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE;YAC7B,MAAM,IAAI,eAAM,CAAC,gBAAgB,EAAE,CAAC;SACrC;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,YAAY;QAChB,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;IACnC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,YAAY,CAAC,IAAI;QACrB,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI;YACF,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;SAClC;QAAC,OAAO,CAAC,EAAE;YACV,MAAM,IAAI,eAAM,CAAC,wBAAwB,EAAE,CAAC;SAC7C;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,eAAe;QACnB,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;IAC9B,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,gBAAgB;QACpB,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC;IAChC,CAAC;CACF,CAAC;AAEF;;GAEG"}