@open-wa/wa-automate-types-only 4.48.0 → 4.49.1

package/dist/api/Client.d.ts

@@ -208,7 +208,8 @@ export declare class Client {
      */
     onPlugged(fn: (plugged: boolean) => void): Promise<Listener | boolean>;
     /**
-     * Requires a Story License Key
+     * {@license:restricted@}
+     *
      * Listens to when a contact posts a new story.
      * @event
      *
@@ -1693,30 +1694,55 @@ export declare class Client {
      */
     postVideoStatus(data: DataURL, caption: Content): Promise<MessageId | string | boolean>;
     /**
-     * Consumes a list of id strings of statuses to delete.
-     * @param statusesToDelete string [] | stringan array of ids of statuses to delete.
+     * {@license:restricted@}
+     *
+     * Consumes a list of id strings of stories to delete.
+     *
+     * @param statusesToDelete string [] | string an array of ids of stories to delete.
      * @returns boolean. True if it worked.
      */
-    deleteStatus(statusesToDelete: string | string[]): Promise<boolean>;
+    deleteStory(statusesToDelete: string | string[]): Promise<boolean>;
+    /**
+     * @deprecated
+     * Alias for deleteStory
+     */
+    deleteStatus: (statusesToDelete: string | string[]) => Promise<boolean>;
     /**
-     * Deletes all your existing statuses.
+     * {@license:restricted@}
+     *
+     * Deletes all your existing stories.
      * @returns boolean. True if it worked.
      */
-    deleteAllStatus(): Promise<boolean>;
+    deleteAllStories(): Promise<boolean>;
+    /**
+     * @deprecated
+     * Alias for deleteStory
+     */
+    deleteAllStatus: () => Promise<boolean>;
     /**
-     * retrieves all existing statuses.
+     * {@license:restricted@}
+     *
+     * Retrieves all existing stories.
      *
      * Only works with a Story License Key
      */
-    getMyStatusArray(): Promise<Message[]>;
+    getMyStoryArray(): Promise<Message[]>;
+    /**
+     * @deprecated
+     * Alias for deleteStory
+     */
+    getMyStatusArray: () => Promise<Message[]>;
     /**
-       * Retrieves an array of user ids that have 'read' your story.
-       *
-       * @param id string The id of the story
-       *
-       * Only works with a Story License Key
-       */
-    getStoryViewers(id: string): Promise<ContactId[]>;
+     * {@license:restricted@}
+     *
+     * Retrieves an array of user ids that have 'read' your story.
+     *
+     * @param id string The id of the story
+     *
+     */
+    getStoryViewers(id?: string): Promise<ContactId[] | {
+        [k: MessageId]: ContactId[];
+    }>;
     /**
      * Clears all chats of all messages. This does not delete chats. Please be careful with this as it will remove all messages from whatsapp web and the host device. This feature is great for privacy focussed bots.
      *

package/dist/connect/index.d.ts

@@ -0,0 +1 @@
+export * from './socket';

package/dist/connect/socket.d.ts

@@ -0,0 +1,96 @@
+import { EventEmitter2 } from 'eventemitter2';
+import { Socket } from "socket.io-client";
+import { Client } from "../api/Client";
+import { SimpleListener } from "../api/model/events";
+import { Chat, ChatId, Message } from '..';
+import { MessageCollector } from '../structures/MessageCollector';
+import { CollectorFilter, CollectorOptions } from '../structures/Collector';
+/**
+ * A convenience type that includes all keys from the `Client`.
+ */
+export declare type ClientMethods = keyof Client;
+/**
+ * [ALPHA - API will 100% change in the near future. Don't say I didn't warn you.]
+ *
+ *
+ * An easy to use socket implementation that allows users to connect into remote instances of the EASY API.
+ *
+ * How to use it:
+ *
+ * 1. Make sure you're running an instance of the EASY API and make sure to start it with the `--socket` flag
+ *      ```bash
+ *          > docker run -e PORT=8080 -p 8080:8080 openwa/wa-automate:latest --socket
+ *      ```
+ * 2. Use this in your code:
+ *
+ *      ```javascript
+ *          import { SocketClient } from "@open-wa/wa-automate";
+ *
+ *          SocketClient.connect("http://localhost:8080").then(async client => {
+ *              //now you can use the client similar to how you would use the http express middleware.
+ *
+ *              //There are two main commands from this client
+ *
+ *              // 1. client.listen - use this for your listeners
+ *
+ *              await client.listen("onMessage", message => {
+ *                  ...
+ *              })
+ *
+ *              // 2. client.asj - ask the main host client to get things done
+ *
+ *              await client.ask("sendText", {
+ *                  "to" : "44771234567@c.us",
+ *                  "content": "hellow socket"
+ *              })
+ *
+ *              // or you can send the arguments in order as an array (or tuple, as the cool kids would say)
+ *              await client.ask("sendText", [
+ *                  "44771234567@c.us",
+ *                  "hellow socket"
+ *              ])
+ *
+ *          })
+ *      ```
+ */
+export declare class SocketClient {
+    url: string;
+    apiKey: string;
+    socket: Socket;
+    /**
+     * A local version of the `ev` EventEmitter2
+     */
+    ev: EventEmitter2;
+    listeners: {
+        [listener in SimpleListener]?: {
+            [id: string]: (data: any) => any;
+        };
+    };
+    /**
+     * The main way to create the socket baed client.
+     * @param url URL of the socket server (i.e the EASY API instance address)
+     * @param apiKey optional api key if set
+     * @returns SocketClient
+     */
+    static connect(url: string, apiKey?: string, ev?: boolean): Promise<SocketClient & Client>;
+    createMessageCollector(c: Message | ChatId | Chat, filter: CollectorFilter<[Message]>, options: CollectorOptions): Promise<MessageCollector>;
+    constructor(url: string, apiKey?: string, ev?: boolean);
+    ask<M extends ClientMethods, P extends Parameters<Pick<Client, M>[M]>>(method: M, args?: any[] | P | {
+        [k: string]: unknown;
+    }): Promise<unknown>;
+    /**
+     * Set a callback on a simple listener
+     * @param listener The listener name (e.g onMessage, onAnyMessage, etc.)
+     * @param callback The callback you need to run on the selected listener
+     * @returns The id of the callback
+     */
+    listen(listener: SimpleListener, callback: (data: unknown) => void): Promise<string>;
+    /**
+     * Discard a callback
+     *
+     * @param listener The listener name (e.g onMessage, onAnyMessage, etc.)
+     * @param callbackId The ID from `listen`
+     * @returns boolean - true if the callback was found and discarded, false if the callback is not found
+     */
+    stopListener(listener: SimpleListener, callbackId: string): boolean;
+}

package/dist/controllers/browser.ignore.d.ts

@@ -0,0 +1,13 @@
+import { Browser, Page } from 'puppeteer';
+import { Spin } from './events';
+import { ConfigObject } from '../api/model';
+export declare let BROWSER_START_TS: number;
+export declare function initPage(sessionId?: string, config?: ConfigObject, customUserAgent?: string, spinner?: Spin, _page?: Page, skipAuth?: boolean): Promise<Page>;
+export declare const deleteSessionData: (config: ConfigObject) => boolean;
+export declare const getSessionDataFilePath: (sessionId: string, config: ConfigObject) => string | boolean;
+export declare const addScript: (page: Page, js: string) => Promise<unknown>;
+export declare function injectApi(page: Page): Promise<Page>;
+/**
+ * @internal
+ */
+export declare const kill: (p: Page, b?: Browser, exit?: boolean, pid?: number, reason?: string) => Promise<void>;

package/dist/controllers/data_dir_watcher.d.ts

@@ -0,0 +1,2 @@
+import { ConfigObject } from '../api/model/config';
+export declare function setupDataDirWatcher(config: ConfigObject): Promise<void>;

package/dist/utils/configSchema.d.ts

@@ -0,0 +1,5 @@
+export declare const getConfigWithCase: (config?: {
+    path: string;
+    tsconfig: string;
+    type: string;
+}) => unknown;

package/dist/utils/elastic.d.ts

@@ -0,0 +1,50 @@
+import { Request, Response } from "express";
+declare type CustomResponse = Response & {
+    _swsReq: any;
+};
+export declare class ElasticEmitter {
+    queue: any;
+    pipeline: any;
+    username: any;
+    password: any;
+    elasticURL: any;
+    enabled: boolean;
+    lastFlush: any;
+    hostname: any;
+    sanitize: any;
+    version: string;
+    es7: boolean;
+    ES_MAX_BUFF: number;
+    indexBuffer: string;
+    bufferCount: number;
+    indexPrefix: string;
+    ip: any;
+    /**
+     *
+     * @param elasticUrl Elastic search endpoint URL
+     * @param username Elastic username
+     * @param password Elastic passowrd
+     * @param pipeline Pipeline to send the RRR
+     */
+    constructor(elasticURL: string, username: string, password: string, max?: number, pipeline?: string, indexPrefix?: string);
+    private get elasticURLBulk();
+    private initTemplate;
+    processRecord(rrr: any): Promise<void>;
+    flush(): Promise<void>;
+    elasticMiddleware(config: {
+        sanitize: Function;
+    }): (req: Request, res: CustomResponse, next: any) => unknown;
+    private collectRequestResponseData;
+    private handleRequest;
+    private processRequest;
+    private processResponse;
+}
+export declare const getStatusCodeClass: (code: number) => string;
+export declare const swsStringRecursive: (output: any, val: any) => any;
+export declare const swsStringValue: (val: any) => string;
+export declare const getPort: (req: any) => number;
+export declare const getResponseContentLength: (req: any, res: any) => any;
+export declare const getRemoteIP: (req: any) => string;
+export declare const getRemoteRealIP: (req: any) => any;
+export declare const getApiOpParameterValues: (path: any, method: any, req: any) => {};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@open-wa/wa-automate-types-only",
-    "version": "4.48.0",
+    "version": "4.49.1",
     "description": "Types generated from the @open-wa/wa-automate package",
     "scripts": {
         "build": "tsc",