@sebbo2002/node-pyatv 6.0.0-develop.2 → 6.0.0

package/dist/lib/index.d.ts

@@ -1,6 +1,806 @@
-export { NodePyATVDeviceOptions, NodePyATVDeviceState, NodePyATVEventValueType, NodePyATVExecutableType, NodePyATVFindAndInstanceOptions, NodePyATVFindOptions, NodePyATVGetStateOptions, NodePyATVInstanceOptions, NodePyATVKeys, NodePyATVListenerState, NodePyATVMediaType, NodePyATVPowerState, NodePyATVProtocol, NodePyATVRepeatState, NodePyATVService, NodePyATVShuffleState, NodePyATVState, NodePyATVVersionResponse } from './types.js';
-export { default as NodePyATVDeviceEvent } from './device-event.js';
-export { default as NodePyATVDeviceEvents } from './device-events.js';
-export { default as NodePyATVDevice } from './device.js';
-export { default as NodePyATVInstance } from './instance.js';
-export { default } from './instance.js';
+import { SpawnOptions, ChildProcess } from 'child_process';
+import { EventEmitter } from 'events';
+
+/**
+ * @internal
+ */
+declare class FakeChildProcessStdIn extends EventEmitter {
+    write(data: string): void;
+}
+/**
+ * @internal
+ */
+declare class FakeChildProcess extends EventEmitter {
+    cmd: string;
+    args: ReadonlyArray<string>;
+    timeout: NodeJS.Timeout | undefined;
+    stdout: EventEmitter;
+    stderr: EventEmitter;
+    stdin: FakeChildProcessStdIn;
+    constructor(command: string, args: ReadonlyArray<string>, options: SpawnOptions, callback: (cp: FakeChildProcessController) => void);
+    kill(): void;
+}
+/**
+ * @internal
+ */
+declare class FakeChildProcessController {
+    _cp: FakeChildProcess;
+    _code: number | null;
+    constructor(cp: FakeChildProcess);
+    cmd(): string;
+    stdout(content: string | Record<string, unknown>): this;
+    stderr(content: string): this;
+    onStdIn(listener: (...args: any[]) => void): this;
+    error(error: Error): this;
+    code(exitCode: number): this;
+    end(content?: string | Record<string, unknown>): this;
+}
+
+declare enum NodePyATVExecutableType {
+    atvremote = "atvremote",
+    atvscript = "atvscript"
+}
+declare enum NodePyATVProtocol {
+    dmap = "dmap",
+    mrp = "mrp",
+    airplay = "airplay",
+    mdns = "mdns"
+}
+declare enum NodePyATVMediaType {
+    music = "music",
+    tv = "tv",
+    video = "video",
+    unknown = "unknown"
+}
+declare enum NodePyATVDeviceState {
+    idle = "idle",
+    loading = "loading",
+    paused = "paused",
+    playing = "playing",
+    seeking = "seeking",
+    stopped = "stopped"
+}
+declare enum NodePyATVRepeatState {
+    all = "all",
+    track = "track",
+    off = "off"
+}
+declare enum NodePyATVShuffleState {
+    albums = "albums",
+    songs = "songs",
+    off = "off"
+}
+declare enum NodePyATVPowerState {
+    on = "on",
+    off = "off"
+}
+declare enum NodePyATVKeys {
+    down = "down",
+    home = "home",
+    homeHold = "homeHold",
+    left = "left",
+    menu = "menu",
+    next = "next",
+    pause = "pause",
+    play = "play",
+    playPause = "playPause",
+    previous = "previous",
+    right = "right",
+    select = "select",
+    skipBackward = "skipBackward",
+    skipForward = "skipForward",
+    stop = "stop",
+    suspend = "suspend",
+    topMenu = "topMenu",
+    up = "up",
+    volumeDown = "volumeDown",
+    volumeUp = "volumeUp",
+    wakeup = "wakeup",
+    turnOff = "turnOff",
+    turnOn = "turnOn"
+}
+declare enum NodePyATVListenerState {
+    stopped = 0,
+    starting = 1,
+    started = 2,
+    stopping = 3
+}
+type NodePyATVStateIndex = keyof NodePyATVState;
+type NodePyATVEventValueType = (string | number | NodePyATVMediaType | NodePyATVDeviceState | NodePyATVShuffleState | NodePyATVRepeatState);
+interface NodePyATVInstanceOptions {
+    atvremotePath?: string;
+    atvscriptPath?: string;
+    debug?: true | ((msg: string) => void);
+    noColors?: true;
+    spawn?: (command: string, args: Array<string>, options: SpawnOptions) => (ChildProcess | FakeChildProcess);
+}
+interface NodePyATVVersionResponse {
+    pyatv: string | null;
+    module: string | null;
+}
+interface NodePyATVFindOptions {
+    host?: string;
+    hosts?: string[];
+    id?: string;
+    protocol?: NodePyATVProtocol;
+    dmapCredentials?: string;
+    mrpCredentials?: string;
+    airplayCredentials?: string;
+    companionCredentials?: string;
+    raopCredentials?: string;
+}
+interface NodePyATVFindAndInstanceOptions extends NodePyATVInstanceOptions, NodePyATVFindOptions {
+}
+interface NodePyATVDeviceOptions extends NodePyATVFindAndInstanceOptions {
+    host: string;
+    name: string;
+    model?: string;
+    modelName?: string;
+    os?: string;
+    version?: string;
+    services?: NodePyATVService[];
+}
+interface NodePyATVGetStateOptions {
+    maxAge?: number;
+}
+interface NodePyATVService {
+    protocol: NodePyATVProtocol;
+    port: number;
+}
+interface NodePyATVState {
+    dateTime: Date | null;
+    hash: string | null;
+    mediaType: NodePyATVMediaType | null;
+    deviceState: NodePyATVDeviceState | null;
+    title: string | null;
+    artist: string | null;
+    album: string | null;
+    genre: string | null;
+    totalTime: number | null;
+    position: number | null;
+    shuffle: NodePyATVShuffleState | null;
+    repeat: NodePyATVRepeatState | null;
+    app: string | null;
+    appId: string | null;
+    powerState: NodePyATVPowerState | null;
+}
+interface NodePyATVApp {
+    id: string;
+    name: string;
+    launch: () => Promise<void>;
+}
+
+declare class NodePyATVDeviceEvent {
+    protected readonly values: {
+        key: NodePyATVStateIndex;
+        old: NodePyATVEventValueType;
+        new: NodePyATVEventValueType;
+        device: NodePyATVDevice;
+    };
+    /**
+     *
+     * @param values
+     * @internal
+     */
+    constructor(values: {
+        key: NodePyATVStateIndex;
+        old: NodePyATVEventValueType;
+        new: NodePyATVEventValueType;
+        device: NodePyATVDevice;
+    });
+    /**
+     * References the attribute name which was changed. So if the
+     * title has been updated, this would be `title`.
+     */
+    get key(): NodePyATVStateIndex;
+    /**
+     * Holds the old value which was there
+     * before the value was changed.
+     */
+    get oldValue(): NodePyATVEventValueType;
+    /**
+     * @alias value
+     */
+    get newValue(): NodePyATVEventValueType;
+    /**
+     * New, current value for `key`
+     */
+    get value(): NodePyATVEventValueType;
+    /**
+     * References the device instance this
+     * event originates from
+     */
+    get device(): NodePyATVDevice;
+}
+
+/**
+ * @internal
+ */
+declare class NodePyATVDeviceEvents extends EventEmitter {
+    private readonly options;
+    private readonly state;
+    private readonly device;
+    private pyatv;
+    private timeout;
+    private listenerState;
+    constructor(state: NodePyATVState, device: NodePyATVDevice, options: NodePyATVDeviceOptions);
+    applyStateAndEmitEvents(newState: NodePyATVState): void;
+    private parsePushUpdate;
+    private applyPushUpdate;
+    private checkListener;
+    private startListening;
+    protected stopListening(reqId: string): Promise<void>;
+    addListener(event: string | symbol, listener: (event: NodePyATVDeviceEvent) => void): this;
+    on(event: string | symbol, listener: (event: NodePyATVDeviceEvent) => void): this;
+    once(event: string | symbol, listener: (event: NodePyATVDeviceEvent) => void): this;
+    prependListener(event: string | symbol, listener: (event: NodePyATVDeviceEvent) => void): this;
+    off(event: string | symbol, listener: (event: NodePyATVDeviceEvent) => void): this;
+    removeAllListeners(event?: string | symbol): this;
+    removeListener(event: string | symbol, listener: (event: NodePyATVDeviceEvent) => void): this;
+    listenerCount(event?: string | symbol): number;
+}
+
+/**
+ * Represents an Apple TV. Use [[getState]] to query the current state (e.g. media
+ * type and title). You can also use the attribute methods (e.g. [[getTitle]] to get
+ * the state. If you want realtime updates, subscribe to it's events with an
+ * `EventEmitter` like API, so for example by using [[on]], [[once]] or [[addListener]].
+ * It's also possible to send key commands by using [[pressKey]] or methods like [[pause]].
+ */
+declare class NodePyATVDevice implements EventEmitter {
+    private readonly options;
+    private readonly state;
+    private readonly events;
+    constructor(options: NodePyATVDeviceOptions);
+    /**
+     * Get the name of the Apple TV.
+     *
+     * ```typescript
+     * import pyatv from '@sebbo2002/node-pyatv';
+     * const devices = await pyatv.find();
+     * devices.forEach(device =>
+     *     console.log(device.name)
+     * );
+     * ```
+     */
+    get name(): string;
+    /**
+     * Get the IP address of the Apple TV.
+     */
+    get host(): string;
+    /**
+     * Get the ID of the Apple TV.
+     */
+    get id(): string | undefined;
+    /**
+     * Get the used protocol to connect to the Apple TV.
+     */
+    get protocol(): NodePyATVProtocol | undefined;
+    /**
+     * Get the model identifier of the device. Only set, if the
+     * device was found using [[find()]]. Requires pyatv ≧ 0.10.3.
+     *
+     * @example device.model → "Gen4K"
+     */
+    get model(): string | undefined;
+    /**
+     * Get the model name of the device. Only set, if the device
+     * was found with [[find()]]. Requires pyatv ≧ 0.10.3.
+     *
+     * @example device.modelName → "Apple TV 4K"
+     */
+    get modelName(): string | undefined;
+    /**
+     * Get the operating system of the device. Only set, if the
+     * device was found with [[find()]]. Requires pyatv ≧ 0.10.3.
+     *
+     * @example device.os → "TvOS"
+     */
+    get os(): string | undefined;
+    /**
+     * Get the device version. Only set, if the device was found
+     * during a scan using [[find()]]. Requires pyatv ≧ 0.10.3.
+     *
+     * @example device.version → "15.5.1"
+     */
+    get version(): string | undefined;
+    /**
+     * Returns a list of services supported by the device. Ony set, if
+     * the device was found during a scan using [[find()]]. Requires
+     * pyatv ≧ 0.10.3.
+     *
+     * @example device.services → [
+     *   {
+     *     "protocol": "airplay",
+     *     "port": 7000
+     *   },
+     *   {
+     *     "protocol": "dmap",
+     *     "port": 3689
+     *   }
+     * ]
+     */
+    get services(): NodePyATVService[] | undefined;
+    /**
+     * Returns true, if debugging is enabled. Returns the custom
+     * logging method, if one was specified. Otherwise, if debug
+     * log is disabled, returns undefined.
+     */
+    get debug(): true | ((msg: string) => void) | undefined;
+    /**
+     * Enable or disable debugging or set a custom
+     * debugging method to use.
+     *
+     * @param debug
+     */
+    set debug(debug: true | ((msg: string) => void) | undefined);
+    /**
+     * Returns an object with `name`, `host`, `id` and `protocol`.
+     * Can be used to initiate a new device instance.
+     *
+     * @category Basic
+     */
+    toJSON(): {
+        name: string;
+        host: string;
+        id: string | undefined;
+        protocol: NodePyATVProtocol | undefined;
+    };
+    /**
+     * Returns a string. Just for debugging, etc.
+     *
+     * @category Basic
+     */
+    toString(): string;
+    /**
+     * Returns an [[NodePyATVState]] object representing the current state
+     * of the device. Has an internal cache, which has a default TTL of 5s.
+     * You can change this default value by passing the `maxAge` option.
+     *
+     * ```typescript
+     * await device.getState({maxAge: 10000}); // cache TTL: 10s
+     * ```
+     *
+     * @param options
+     * @category State
+     */
+    getState(options?: NodePyATVGetStateOptions): Promise<NodePyATVState>;
+    /**
+     * Removes the state node-pyatv cached for this device.
+     *
+     * @category State
+     */
+    clearState(): void;
+    private applyState;
+    /**
+     * Get the date and time when the state was last updated.
+     * @param options
+     * @category State
+     */
+    getDateTime(options?: NodePyATVGetStateOptions): Promise<Date | null>;
+    /**
+     * Get the hash of the current media
+     * @param options
+     * @category State
+     */
+    getHash(options?: NodePyATVGetStateOptions): Promise<string | null>;
+    /**
+     * Get the media type of the current media
+     * @param options
+     * @category State
+     */
+    getMediaType(options?: NodePyATVGetStateOptions): Promise<NodePyATVMediaType | null>;
+    /**
+     * Get the state of this device (e.g. playing, etc.)
+     * @param options
+     * @category State
+     */
+    getDeviceState(options?: NodePyATVGetStateOptions): Promise<NodePyATVDeviceState | null>;
+    /**
+     * Returns the title of the current playing media
+     * @param options
+     * @category State
+     */
+    getTitle(options?: NodePyATVGetStateOptions): Promise<string | null>;
+    /**
+     * Returns the artist of the current playing media
+     * @param options
+     * @category State
+     */
+    getArtist(options?: NodePyATVGetStateOptions): Promise<string | null>;
+    /**
+     * Returns the album of the current playing media
+     * @param options
+     * @category State
+     */
+    getAlbum(options?: NodePyATVGetStateOptions): Promise<string | null>;
+    /**
+     * Returns the genre of the current playing media
+     * @param options
+     * @category State
+     */
+    getGenre(options?: NodePyATVGetStateOptions): Promise<string | null>;
+    /**
+     * Returns the media length of the current playing media
+     * @param options
+     * @category State
+     */
+    getTotalTime(options?: NodePyATVGetStateOptions): Promise<number | null>;
+    /**
+     * Returns the title of the current playing media
+     * @param options
+     * @category State
+     */
+    getPosition(options?: NodePyATVGetStateOptions): Promise<number | null>;
+    /**
+     * Returns the shuffle state
+     * @param options
+     * @category State
+     */
+    getShuffle(options?: NodePyATVGetStateOptions): Promise<NodePyATVShuffleState | null>;
+    /**
+     * Returns the repeat state
+     * @param options
+     * @category State
+     */
+    getRepeat(options?: NodePyATVGetStateOptions): Promise<NodePyATVRepeatState | null>;
+    /**
+     * Returns the currently used app
+     * @param options
+     * @category State
+     */
+    getApp(options?: NodePyATVGetStateOptions): Promise<string | null>;
+    /**
+     * Returns the id of the currently used app
+     * @param options
+     * @category State
+     */
+    getAppId(options?: NodePyATVGetStateOptions): Promise<string | null>;
+    /**
+     * Returns the list of installed apps on the Apple TV. Probably requires `companionCredentials`,
+     * see https://pyatv.dev/documentation/atvremote/#apps for more details.
+     */
+    listApps(): Promise<NodePyATVApp[]>;
+    private _pressKey;
+    /**
+     * Send a key press to the Apple TV
+     *
+     * ```typescript
+     * await device.pressKey(NodePyATVKeys.home);
+     * ```
+     *
+     * <br />
+     *
+     * ```javascript
+     * await device.pressKey('home');
+     * ```
+     *
+     * @param key
+     * @category Control
+     */
+    pressKey(key: NodePyATVKeys): Promise<void>;
+    /**
+     * Send the "down" command
+     * @category Control
+     */
+    down(): Promise<void>;
+    /**
+     * Send the "home" command
+     * @category Control
+     */
+    home(): Promise<void>;
+    /**
+     * Send the "homeHold" command
+     * @category Control
+     */
+    homeHold(): Promise<void>;
+    /**
+     * Send the "left" command
+     * @category Control
+     */
+    left(): Promise<void>;
+    /**
+     * Send the "menu" command
+     * @category Control
+     */
+    menu(): Promise<void>;
+    /**
+     * Send the "next" command
+     * @category Control
+     */
+    next(): Promise<void>;
+    /**
+     * Send the "pause" command
+     * @category Control
+     */
+    pause(): Promise<void>;
+    /**
+     * Send the "play" command
+     * @category Control
+     */
+    play(): Promise<void>;
+    /**
+     * Send the "playPause" command
+     * @category Control
+     */
+    playPause(): Promise<void>;
+    /**
+     * Send the "previous" command
+     * @category Control
+     */
+    previous(): Promise<void>;
+    /**
+     * Send the "right" command
+     * @category Control
+     */
+    right(): Promise<void>;
+    /**
+     * Send the "select" command
+     * @category Control
+     */
+    select(): Promise<void>;
+    /**
+     * Send the "skipBackward" command
+     * @category Control
+     */
+    skipBackward(): Promise<void>;
+    /**
+     * Send the "skipForward" command
+     * @category Control
+     */
+    skipForward(): Promise<void>;
+    /**
+     * Send the "stop" command
+     * @category Control
+     */
+    stop(): Promise<void>;
+    /**
+     * Send the "suspend" command
+     * @category Control
+     * @deprecated
+     */
+    suspend(): Promise<void>;
+    /**
+     * Send the "topMenu" command
+     * @category Control
+     */
+    topMenu(): Promise<void>;
+    /**
+     * Send the "up" command
+     * @category Control
+     */
+    up(): Promise<void>;
+    /**
+     * Send the "volumeDown" command
+     * @category Control
+     */
+    volumeDown(): Promise<void>;
+    /**
+     * Send the "volumeUp" command
+     * @category Control
+     */
+    volumeUp(): Promise<void>;
+    /**
+     * Send the "wakeup" command
+     * @category Control
+     * @deprecated
+     */
+    wakeup(): Promise<void>;
+    /**
+     * Send the "turn_off" command
+     * @category Control
+     */
+    turnOff(): Promise<void>;
+    /**
+     * Send the "turn_on" command
+     * @category Control
+     */
+    turnOn(): Promise<void>;
+    /**
+     * Launch an application. Probably requires `companionCredentials`, see
+     * https://pyatv.dev/documentation/atvremote/#apps for more details.
+     * @param id App identifier, e.g. `com.netflix.Netflix`
+     */
+    launchApp(id: string): Promise<void>;
+    /**
+     * Add an event listener. Will start the event subscription with the
+     * Apple TV as long as there are listeners for any event registered.
+     * @param event
+     * @param listener
+     * @category Event
+     */
+    addListener(event: string | symbol, listener: (event: NodePyATVDeviceEvent) => void): this;
+    /**
+     * Emit an event.
+     * @param event
+     * @param payload
+     * @category Event
+     */
+    emit(event: string | symbol, payload: NodePyATVDeviceEvent): boolean;
+    /**
+     * Get all event names which are currently known.
+     * @category Event
+     */
+    eventNames(): Array<string | symbol>;
+    /**
+     * Get max number of listeners allowed
+     * @category Event
+     */
+    getMaxListeners(): number;
+    /**
+     * Get number of listeners for event
+     * @param event
+     * @category Event
+     */
+    listenerCount(event: string | symbol): number;
+    /**
+     * Get listeners for event. Will also return
+     * node-pyatv wrappers (e.g. once)
+     *
+     * @param event
+     * @category Event
+     */
+    listeners(event: string | symbol): Function[];
+    /**
+     * Remove an event listener. Will stop the event subscription with the
+     * Apple TV if this was the last event listener.
+     * @param event
+     * @param listener
+     * @category Event
+     */
+    off(event: string | symbol, listener: (event: NodePyATVDeviceEvent | Error) => void): this;
+    /**
+     * Add an event listener. Will start the event subscription with the
+     * Apple TV as long as there are listeners for any event registered.
+     * @param event
+     * @param listener
+     * @category Event
+     */
+    on(event: string | symbol, listener: (event: NodePyATVDeviceEvent | Error) => void): this;
+    /**
+     * Add an event listener. Will start the event subscription with the
+     * Apple TV as long as there are listeners for any event registered.
+     * Removes the listener automatically after the first occurrence.
+     * @param event
+     * @param listener
+     * @category Event
+     */
+    once(event: string | symbol, listener: (event: NodePyATVDeviceEvent | Error) => void): this;
+    /**
+     * @param event
+     * @param listener
+     * @category Event
+     */
+    prependListener(event: string | symbol, listener: (event: NodePyATVDeviceEvent | Error) => void): this;
+    /**
+     * @param event
+     * @param listener
+     * @category Event
+     */
+    prependOnceListener(event: string | symbol, listener: (event: NodePyATVDeviceEvent | Error) => void): this;
+    /**
+     * @param event
+     * @category Event
+     */
+    rawListeners(event: string | symbol): Function[];
+    /**
+     * Removes all listeners, either for the given event or
+     * for every event. Will stop the event subscription with
+     * the Apple TV if this was the last event listener.
+     *
+     * @param event
+     * @category Event
+     */
+    removeAllListeners(event?: string | symbol): this;
+    /**
+     * Remove an event listener. Will stop the event subscription with the
+     * Apple TV if this was the last event listener.
+     * @param event
+     * @param listener
+     * @category Event
+     */
+    removeListener(event: string | symbol, listener: (event: NodePyATVDeviceEvent) => void): this;
+    /**
+     * @param n
+     * @category Event
+     */
+    setMaxListeners(n: number): this;
+}
+
+/**
+ * Default class exported by `@sebbo2002/node-pyatv`. Use [[find]] to scan for devices in your local network. Use
+ * [[device]] to connect to a known device by passing (at least) it's name and IP.
+ *
+ * ```typescript
+ * import pyatv from '@sebbo2002/node-pyatv';
+ * ```
+ */
+declare class NodePyATVInstance {
+    private readonly options;
+    /**
+     * Checks if pyatv is installed and ready to be used.
+     * Will throw an error if not.
+     *
+     * @param options
+     */
+    static check(options?: NodePyATVInstanceOptions): Promise<void>;
+    /**
+     * Resolves with the version of pyatv and of the module itself.
+     * If a value can't be found, null is returned instead.
+     *
+     * @param options
+     */
+    static version(options?: NodePyATVInstanceOptions): Promise<NodePyATVVersionResponse>;
+    /**
+     * Scan the network for Apple TVs by using pyatv's atvscript. See [[NodePyATVFindAndInstanceOptions]]
+     * for the options allowed. Use the `host` / `hosts` attribute to filter by IP addresses. Resolves with
+     * an array of [[NodePyATVDevice]].
+     *
+     * ```typescript
+     * import pyatv from '@sebbo2002/node-pyatv';
+     * const devices = await pyatv.find();
+     * console.log(devices);
+     * ```
+     *
+     * @param options
+     */
+    static find(options?: NodePyATVFindAndInstanceOptions): Promise<NodePyATVDevice[]>;
+    /**
+     * Create a [[NodePyATVDevice]] to query the state and control it.
+     * At least `host` and `name` are required.
+     *
+     * @param options
+     */
+    static device(options: NodePyATVDeviceOptions): NodePyATVDevice;
+    /**
+     * Use this to apply [[NodePyATVInstanceOptions]]
+     * (e.g. debug log method) to all further requests
+     *
+     * ```typescript
+     * import pyatv from '@sebbo2002/node-pyatv';
+     * const myPyatv = new pyatv({debug: true});
+     * const devices = myPyatv.find();
+     * console.log(devices);
+     * ```
+     * @param options
+     */
+    constructor(options?: NodePyATVInstanceOptions);
+    /**
+     * Checks if pyatv is installed and ready to be used.
+     * Will throw an error if not.
+     *
+     * @param options
+     */
+    check(options?: NodePyATVInstanceOptions): Promise<void>;
+    /**
+     * Resolves with the version of pyatv and of the module itself.
+     * If a value can't be found, null is returned instead.
+     *
+     * @param options
+     */
+    version(options?: NodePyATVInstanceOptions): Promise<NodePyATVVersionResponse>;
+    /**
+     * Scan the network for Apple TVs by using pyatv's atvscript. See [[NodePyATVFindAndInstanceOptions]]
+     * for the options allowed. Use the `host` / `hosts` attribute to filter by IP addresses. Resolves with
+     * an array of [[NodePyATVDevice]].
+     *
+     * ```typescript
+     * import pyatv from '@sebbo2002/node-pyatv';
+     * const myPyATV = new pyatv({debug: true});
+     * const devices = await myPyATV.find();
+     * console.log(devices);
+     * ```
+     *
+     * @param options
+     */
+    find(options?: NodePyATVFindAndInstanceOptions): Promise<NodePyATVDevice[]>;
+    /**
+     * Create a [[NodePyATVDevice]] to query the state and control it.
+     * At least `host` and `name` are required.
+     *
+     * @param options
+     */
+    device(options: NodePyATVDeviceOptions): NodePyATVDevice;
+}
+
+export { NodePyATVDevice, NodePyATVDeviceEvent, NodePyATVDeviceEvents, NodePyATVDeviceOptions, NodePyATVDeviceState, NodePyATVEventValueType, NodePyATVExecutableType, NodePyATVFindAndInstanceOptions, NodePyATVFindOptions, NodePyATVGetStateOptions, NodePyATVInstance, NodePyATVInstanceOptions, NodePyATVKeys, NodePyATVListenerState, NodePyATVMediaType, NodePyATVPowerState, NodePyATVProtocol, NodePyATVRepeatState, NodePyATVService, NodePyATVShuffleState, NodePyATVState, NodePyATVVersionResponse, NodePyATVInstance as default };