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

package/dist/lib/{device.d.ts → index.d.cts}

@@ -1,7 +1,245 @@
-/// <reference types="node" resolution-mode="require"/>
-import { NodePyATVApp, NodePyATVDeviceOptions, NodePyATVDeviceState, NodePyATVGetStateOptions, NodePyATVKeys, NodePyATVMediaType, NodePyATVProtocol, NodePyATVRepeatState, NodePyATVService, NodePyATVShuffleState, NodePyATVState } from './types.js';
-import { NodePyATVDeviceEvent } from '../lib/index.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
@@ -9,7 +247,7 @@ import { EventEmitter } from 'events';
  * `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]].
  */
-export default class NodePyATVDevice implements EventEmitter {
+declare class NodePyATVDevice implements EventEmitter {
     private readonly options;
     private readonly state;
     private readonly events;
@@ -468,3 +706,101 @@ export default class NodePyATVDevice implements EventEmitter {
      */
     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 };