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

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.1",
+    "version": "4.49.1",
     "description": "Types generated from the @open-wa/wa-automate package",
     "scripts": {
         "build": "tsc",