botmancers 0.5.0 → 0.6.1

package/app/node_modules/@slack/socket-mode/dist/src/SocketModeClient.js

@@ -0,0 +1,363 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketModeClient = void 0;
+const web_api_1 = require("@slack/web-api");
+const eventemitter3_1 = require("eventemitter3");
+const package_json_1 = __importDefault(require("../package.json"));
+const errors_1 = require("./errors");
+const logger_1 = __importStar(require("./logger"));
+const SlackWebSocket_1 = require("./SlackWebSocket");
+const UnrecoverableSocketModeStartError_1 = require("./UnrecoverableSocketModeStartError");
+// Lifecycle events as described in the README
+var State;
+(function (State) {
+    State["Connecting"] = "connecting";
+    State["Connected"] = "connected";
+    State["Reconnecting"] = "reconnecting";
+    State["Disconnecting"] = "disconnecting";
+    State["Disconnected"] = "disconnected";
+    State["Authenticated"] = "authenticated";
+})(State || (State = {}));
+/**
+ * A Socket Mode Client allows programs to communicate with the
+ * [Slack Platform's Events API](https://https://docs.slack.dev/apis/events-api) over WebSocket connections.
+ * This object uses the EventEmitter pattern to dispatch incoming events
+ * and has a built in send method to acknowledge incoming events over the WebSocket connection.
+ */
+class SocketModeClient extends eventemitter3_1.EventEmitter {
+    constructor({ logger = undefined, logLevel = undefined, autoReconnectEnabled = true, pingPongLoggingEnabled = false, clientPingTimeout = 5000, serverPingTimeout = 30000, appToken = '', clientOptions = {}, } = { appToken: '' }) {
+        super();
+        /**
+         * Internal count for managing the reconnection state
+         */
+        this.numOfConsecutiveReconnectionFailures = 0;
+        this.customLoggerProvided = false;
+        /**
+         * Sentinel tracking if user invoked `disconnect()`; for enforcing shutting down of client
+         * even if `autoReconnectEnabled` is `true`.
+         */
+        this.shuttingDown = false;
+        if (!appToken) {
+            throw new Error('Must provide an App-Level Token when initializing a Socket Mode Client');
+        }
+        this.pingPongLoggingEnabled = pingPongLoggingEnabled;
+        this.clientPingTimeoutMS = clientPingTimeout;
+        this.serverPingTimeoutMS = serverPingTimeout;
+        // Setup the logger
+        if (typeof logger !== 'undefined') {
+            this.customLoggerProvided = true;
+            this.logger = logger;
+            if (typeof logLevel !== 'undefined') {
+                this.logger.debug('The logLevel given to Socket Mode was ignored as you also gave logger');
+            }
+        }
+        else {
+            this.logger = logger_1.default.getLogger(SocketModeClient.loggerName, logLevel !== null && logLevel !== void 0 ? logLevel : logger_1.LogLevel.INFO, logger);
+        }
+        this.webClientOptions = clientOptions;
+        if (this.webClientOptions.retryConfig === undefined) {
+            // For faster retries of apps.connections.open API calls for reconnecting
+            this.webClientOptions.retryConfig = { retries: 100, factor: 1.3 };
+        }
+        this.webClient = new web_api_1.WebClient('', Object.assign({ logger, logLevel: this.logger.getLevel(), headers: { Authorization: `Bearer ${appToken}` } }, clientOptions));
+        this.autoReconnectEnabled = autoReconnectEnabled;
+        // bind to error, message and close events emitted from the web socket
+        this.on('error', (err) => {
+            this.logger.error(`WebSocket error! ${err}`);
+        });
+        this.on('close', () => {
+            // Underlying WebSocket connection was closed, possibly reconnect.
+            if (!this.shuttingDown && this.autoReconnectEnabled) {
+                this.delayReconnectAttempt(this.start);
+            }
+            else {
+                // If reconnect is disabled or user explicitly called `disconnect()`, emit a disconnected state.
+                this.emit(State.Disconnected);
+            }
+        });
+        this.on('ws_message', this.onWebSocketMessage.bind(this));
+        this.logger.debug('The Socket Mode client has successfully initialized');
+    }
+    // PUBLIC METHODS
+    /**
+     * Start a Socket Mode session app.
+     * This method must be called before any messages can be sent or received,
+     * or to disconnect the client via the `disconnect` method.
+     */
+    async start() {
+        // python equiv: SocketModeClient.connect
+        this.shuttingDown = false;
+        this.logger.debug('Starting Socket Mode session ...');
+        // create a socket connection using SlackWebSocket
+        this.websocket = new SlackWebSocket_1.SlackWebSocket({
+            url: await this.retrieveWSSURL(),
+            // web socket events relevant to this client will be emitted into the instance of this class
+            // see bottom of constructor for where we bind to these events
+            client: this,
+            logLevel: this.logger.getLevel(),
+            logger: this.customLoggerProvided ? this.logger : undefined,
+            httpAgent: this.webClientOptions.agent,
+            clientPingTimeoutMS: this.clientPingTimeoutMS,
+            serverPingTimeoutMS: this.serverPingTimeoutMS,
+            pingPongLoggingEnabled: this.pingPongLoggingEnabled,
+        });
+        // Return a promise that resolves with the connection information
+        return new Promise((resolve, reject) => {
+            var _a;
+            // biome-ignore lint/suspicious/noExplicitAny: untyped connection callback parameters
+            let connectedCallback = (_res) => { };
+            // biome-ignore lint/suspicious/noExplicitAny: untyped connection callback parameters
+            let disconnectedCallback = (_err) => { };
+            connectedCallback = (result) => {
+                this.removeListener(State.Disconnected, disconnectedCallback);
+                resolve(result);
+            };
+            disconnectedCallback = (err) => {
+                this.removeListener(State.Connected, connectedCallback);
+                reject(err);
+            };
+            this.once(State.Connected, connectedCallback);
+            this.once(State.Disconnected, disconnectedCallback);
+            this.emit(State.Connecting);
+            (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.connect();
+        });
+    }
+    /**
+     * End a Socket Mode session. After this method is called no messages will be sent or received
+     * unless you call start() again later.
+     */
+    disconnect() {
+        this.shuttingDown = true;
+        this.logger.debug('Manually disconnecting this Socket Mode client');
+        this.emit(State.Disconnecting);
+        return new Promise((resolve, _reject) => {
+            var _a;
+            if (!this.websocket) {
+                this.emit(State.Disconnected);
+                resolve();
+            }
+            else {
+                // Resolve (or reject) on disconnect
+                this.once(State.Disconnected, resolve);
+                (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.disconnect();
+            }
+        });
+    }
+    // PRIVATE/PROTECTED METHODS
+    /**
+     * Initiates a reconnect, taking into account configurable delays and number of reconnect attempts and failures.
+     * Accepts a callback to invoke after any calculated delays.
+     */
+    delayReconnectAttempt(cb) {
+        this.numOfConsecutiveReconnectionFailures += 1;
+        const msBeforeRetry = this.clientPingTimeoutMS * this.numOfConsecutiveReconnectionFailures;
+        this.logger.debug(`Before trying to reconnect, this client will wait for ${msBeforeRetry} milliseconds`);
+        return new Promise((res, _rej) => {
+            setTimeout(() => {
+                if (this.shuttingDown) {
+                    this.logger.debug('Client shutting down, will not attempt reconnect.');
+                }
+                else {
+                    this.logger.debug('Continuing with reconnect...');
+                    this.emit(State.Reconnecting);
+                    cb.apply(this).then(res);
+                }
+            }, msBeforeRetry);
+        });
+    }
+    /**
+     * Retrieves a new WebSocket URL to connect to.
+     */
+    async retrieveWSSURL() {
+        // python equiv: BaseSocketModeClient.issue_new_wss_url
+        try {
+            this.logger.debug('Going to retrieve a new WSS URL ...');
+            const resp = await this.webClient.apps.connections.open({});
+            if (!resp.url) {
+                const msg = `apps.connections.open did not return a URL! (response: ${resp})`;
+                this.logger.error(msg);
+                throw new Error(msg);
+            }
+            this.numOfConsecutiveReconnectionFailures = 0;
+            this.emit(State.Authenticated, resp);
+            return resp.url;
+        }
+        catch (error) {
+            // TODO: Python catches rate limit errors when interacting with this API: https://github.com/slackapi/python-slack-sdk/blob/main/slack_sdk/socket_mode/client.py#L51
+            this.logger.error(`Failed to retrieve a new WSS URL (error: ${error})`);
+            const err = error;
+            let isRecoverable = true;
+            if (err.code === web_api_1.ErrorCode.PlatformError &&
+                Object.values(UnrecoverableSocketModeStartError_1.UnrecoverableSocketModeStartError).includes(err.data.error)) {
+                isRecoverable = false;
+            }
+            else if (err.code === web_api_1.ErrorCode.RequestError) {
+                isRecoverable = false;
+            }
+            else if (err.code === web_api_1.ErrorCode.HTTPError) {
+                isRecoverable = false;
+            }
+            if (this.autoReconnectEnabled && isRecoverable) {
+                return await this.delayReconnectAttempt(this.retrieveWSSURL);
+            }
+            throw error;
+        }
+    }
+    /**
+     * `onmessage` handler for the client's WebSocket.
+     * This will parse the payload and dispatch the application-relevant events for each incoming message.
+     * Mediates:
+     * - raising the State.Connected event (when Slack sends a type:hello message)
+     * - disconnecting the underlying socket (when Slack sends a type:disconnect message)
+     */
+    async onWebSocketMessage(data, isBinary) {
+        var _a;
+        if (isBinary) {
+            this.logger.debug('Unexpected binary message received, ignoring.');
+            return;
+        }
+        const payload = data.toString();
+        // TODO: should we redact things in here?
+        this.logger.debug(`Received a message on the WebSocket: ${payload}`);
+        // Parse message into slack event
+        let event;
+        try {
+            event = JSON.parse(payload);
+        }
+        catch (parseError) {
+            // Prevent application from crashing on a bad message, but log an error to bring attention
+            this.logger.debug(`Unable to parse an incoming WebSocket message (will ignore): ${parseError}, ${payload}`);
+            return;
+        }
+        // Slack has finalized the handshake with a hello message; we are good to go.
+        if (event.type === 'hello') {
+            this.emit(State.Connected);
+            return;
+        }
+        // Slack is recycling the pod handling the connection (or otherwise requires the client to reconnect)
+        if (event.type === 'disconnect') {
+            this.logger.debug(`Received "${event.type}" (${event.reason}) message - disconnecting.${this.autoReconnectEnabled ? ' Will reconnect.' : ''}`);
+            (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.disconnect();
+            return;
+        }
+        // Define Ack, a helper method for acknowledging events incoming from Slack
+        const ack = async (response) => {
+            if (this.logger.getLevel() === logger_1.LogLevel.DEBUG) {
+                this.logger.debug(`Calling ack() - type: ${event.type}, envelope_id: ${event.envelope_id}, data: ${JSON.stringify(response)}`);
+            }
+            await this.send(event.envelope_id, response);
+        };
+        // For events_api messages, expose the type of the event
+        if (event.type === 'events_api') {
+            this.emit(event.payload.event.type, {
+                ack,
+                envelope_id: event.envelope_id,
+                body: event.payload,
+                event: event.payload.event,
+                retry_num: event.retry_attempt,
+                retry_reason: event.retry_reason,
+                accepts_response_payload: event.accepts_response_payload,
+            });
+        }
+        else {
+            // Emit just ack and body for all other types of messages
+            this.emit(event.type, {
+                ack,
+                envelope_id: event.envelope_id,
+                body: event.payload,
+                accepts_response_payload: event.accepts_response_payload,
+            });
+        }
+        // Emitter for all slack events
+        // (this can be used in tools like bolt-js)
+        this.emit('slack_event', {
+            ack,
+            envelope_id: event.envelope_id,
+            type: event.type,
+            body: event.payload,
+            retry_num: event.retry_attempt,
+            retry_reason: event.retry_reason,
+            accepts_response_payload: event.accepts_response_payload,
+        });
+    }
+    /**
+     * Method for sending an outgoing message of an arbitrary type over the WebSocket connection.
+     * Primarily used to send acknowledgements back to slack for incoming events
+     * @param id the envelope id
+     * @param body the message body or string text
+     */
+    send(id, body = {}) {
+        const _body = typeof body === 'string' ? { text: body } : body;
+        const message = { envelope_id: id, payload: Object.assign({}, _body) };
+        return new Promise((resolve, reject) => {
+            var _a;
+            const wsState = (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.readyState;
+            this.logger.debug(`send() method was called (WebSocket state: ${wsState ? SlackWebSocket_1.WS_READY_STATES[wsState] : 'uninitialized'})`);
+            if (this.websocket === undefined) {
+                this.logger.error('Failed to send a message as the client is not connected');
+                reject((0, errors_1.sendWhileDisconnectedError)());
+            }
+            else if (!this.websocket.isActive()) {
+                this.logger.error('Failed to send a message as the client has no active connection');
+                reject((0, errors_1.sendWhileNotReadyError)());
+            }
+            else {
+                this.emit('outgoing_message', message);
+                const flatMessage = JSON.stringify(message);
+                this.logger.debug(`Sending a WebSocket message: ${flatMessage}`);
+                this.websocket.send(flatMessage, (error) => {
+                    if (error) {
+                        this.logger.error(`Failed to send a WebSocket message (error: ${error})`);
+                        return reject((0, errors_1.websocketErrorWithOriginal)(error));
+                    }
+                    return resolve();
+                });
+            }
+        });
+    }
+}
+exports.SocketModeClient = SocketModeClient;
+/**
+ * The name used to prefix all logging generated from this class
+ */
+SocketModeClient.loggerName = 'SocketModeClient';
+/* Instrumentation */
+(0, web_api_1.addAppMetadata)({ name: package_json_1.default.name, version: package_json_1.default.version });
+exports.default = SocketModeClient;
+//# sourceMappingURL=SocketModeClient.js.map

package/app/node_modules/@slack/socket-mode/dist/src/UnrecoverableSocketModeStartError.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnrecoverableSocketModeStartError = void 0;
+// NOTE: there may be a better way to add metadata to an error about being "unrecoverable" than to keep an
+// independent enum, probably a Set (this isn't used as a type).
+var UnrecoverableSocketModeStartError;
+(function (UnrecoverableSocketModeStartError) {
+    UnrecoverableSocketModeStartError["NotAuthed"] = "not_authed";
+    UnrecoverableSocketModeStartError["InvalidAuth"] = "invalid_auth";
+    UnrecoverableSocketModeStartError["AccountInactive"] = "account_inactive";
+    UnrecoverableSocketModeStartError["UserRemovedFromTeam"] = "user_removed_from_team";
+    UnrecoverableSocketModeStartError["TeamDisabled"] = "team_disabled";
+})(UnrecoverableSocketModeStartError || (exports.UnrecoverableSocketModeStartError = UnrecoverableSocketModeStartError = {}));
+//# sourceMappingURL=UnrecoverableSocketModeStartError.js.map

package/app/node_modules/@slack/socket-mode/dist/src/errors.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCode = void 0;
+exports.websocketErrorWithOriginal = websocketErrorWithOriginal;
+exports.platformErrorFromEvent = platformErrorFromEvent;
+exports.noReplyReceivedError = noReplyReceivedError;
+exports.sendWhileDisconnectedError = sendWhileDisconnectedError;
+exports.sendWhileNotReadyError = sendWhileNotReadyError;
+/**
+ * A dictionary of codes for errors produced by this package
+ */
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["SendWhileDisconnectedError"] = "slack_socket_mode_send_while_disconnected_error";
+    ErrorCode["SendWhileNotReadyError"] = "slack_socket_mode_send_while_not_ready_error";
+    ErrorCode["SendMessagePlatformError"] = "slack_socket_mode_send_message_platform_error";
+    ErrorCode["WebsocketError"] = "slack_socket_mode_websocket_error";
+    ErrorCode["NoReplyReceivedError"] = "slack_socket_mode_no_reply_received_error";
+    ErrorCode["InitializationError"] = "slack_socket_mode_initialization_error";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+/**
+ * Factory for producing a {@link CodedError} from a generic error
+ */
+function errorWithCode(error, code) {
+    // NOTE: might be able to return something more specific than a CodedError with conditional typing
+    const codedError = error;
+    codedError.code = code;
+    return codedError;
+}
+/**
+ * A factory to create SMWebsocketError objects.
+ */
+function websocketErrorWithOriginal(original) {
+    const error = errorWithCode(new Error(original.message), ErrorCode.WebsocketError);
+    error.original = original;
+    return error;
+}
+/**
+ * A factory to create SMPlatformError objects.
+ */
+function platformErrorFromEvent(
+// biome-ignore lint/suspicious/noExplicitAny: errors can be anything
+event) {
+    const error = errorWithCode(new Error(`An API error occurred: ${event.error.msg}`), ErrorCode.SendMessagePlatformError);
+    error.data = event;
+    return error;
+}
+// TODO: Is the below factory needed still?
+/**
+ * A factory to create SMNoReplyReceivedError objects.
+ */
+function noReplyReceivedError() {
+    return errorWithCode(new Error('Message sent but no server acknowledgement was received. This may be caused by the client ' +
+        'changing connection state rather than any issue with the specific message. Check before resending.'), ErrorCode.NoReplyReceivedError);
+}
+/**
+ * A factory to create SMSendWhileDisconnectedError objects.
+ */
+function sendWhileDisconnectedError() {
+    return errorWithCode(new Error('Failed to send a WebSocket message as the client is not connected'), ErrorCode.NoReplyReceivedError);
+}
+/**
+ * A factory to create SMSendWhileNotReadyError objects.
+ */
+function sendWhileNotReadyError() {
+    return errorWithCode(new Error('Failed to send a WebSocket message as the client is not ready'), ErrorCode.NoReplyReceivedError);
+}
+//# sourceMappingURL=errors.js.map

package/app/node_modules/@slack/socket-mode/dist/src/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/// <reference lib="es2017" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnrecoverableSocketModeStartError = exports.SocketModeClient = exports.LogLevel = exports.ErrorCode = void 0;
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "ErrorCode", { enumerable: true, get: function () { return errors_1.ErrorCode; } });
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_1.LogLevel; } });
+var SocketModeClient_1 = require("./SocketModeClient");
+Object.defineProperty(exports, "SocketModeClient", { enumerable: true, get: function () { return SocketModeClient_1.SocketModeClient; } });
+var UnrecoverableSocketModeStartError_1 = require("./UnrecoverableSocketModeStartError");
+Object.defineProperty(exports, "UnrecoverableSocketModeStartError", { enumerable: true, get: function () { return UnrecoverableSocketModeStartError_1.UnrecoverableSocketModeStartError; } });
+//# sourceMappingURL=index.js.map

package/app/node_modules/@slack/socket-mode/dist/src/logger.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+const logger_1 = require("@slack/logger");
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_1.LogLevel; } });
+let instanceCount = 0;
+exports.default = {
+    getLogger: function getLogger(name, level, existingLogger) {
+        // Get a unique ID for the logger.
+        const instanceId = instanceCount;
+        instanceCount += 1;
+        // Set up the logger.
+        const logger = (() => {
+            if (existingLogger !== undefined) {
+                return existingLogger;
+            }
+            return new logger_1.ConsoleLogger();
+        })();
+        logger.setName(`socket-mode:${name}:${instanceId}`);
+        if (level !== undefined) {
+            logger.setLevel(level);
+        }
+        return logger;
+    },
+};
+//# sourceMappingURL=logger.js.map

package/app/node_modules/@slack/socket-mode/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@slack/socket-mode",
+  "version": "2.0.7",
+  "description": "Official library for using the Slack Platform's Socket Mode API",
+  "author": "Slack Technologies, LLC",
+  "license": "MIT",
+  "keywords": [
+    "slack",
+    "socket",
+    "websocket",
+    "firewall",
+    "bot",
+    "client",
+    "http",
+    "websocket",
+    "api",
+    "proxy",
+    "state",
+    "connection"
+  ],
+  "main": "dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "engines": {
+    "node": ">= 18",
+    "npm": ">= 8.6.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/slackapi/node-slack-sdk.git"
+  },
+  "homepage": "https://docs.slack.dev/tools/node-slack-sdk/socket-mode/",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/slackapi/node-slack-sdk/issues"
+  },
+  "scripts": {
+    "build": "npm run build:clean && tsc",
+    "build:clean": "shx rm -rf ./dist",
+    "docs": "npx typedoc --plugin typedoc-plugin-markdown",
+    "prepack": "npm run build",
+    "test": "npm run test:unit && npm run test:integration",
+    "test:node18": "npm run build && bash -c 'node --test --test-reporter=spec --import tsx src/*.test.ts' && npm run test:integration",
+    "test:integration": "npm run build && node --import tsx --test test/integration.test.js",
+    "test:unit": "npm run build && node --experimental-test-coverage --test-reporter=spec --test-reporter-destination=stdout --test-reporter=lcov --test-reporter-destination=lcov.info --test-reporter=junit --test-reporter-destination=test-results.xml --import tsx --test src/*.test.ts",
+    "watch": "npx nodemon --watch 'src' --ext 'ts' --exec npm test"
+  },
+  "dependencies": {
+    "@slack/logger": "^4.0.1",
+    "@slack/web-api": "^7.15.0",
+    "@types/node": ">=18",
+    "@types/ws": "^8",
+    "eventemitter3": "^5",
+    "ws": "^8"
+  },
+  "devDependencies": {
+    "@types/proxyquire": "^1.3.31",
+    "@types/sinon": "^21",
+    "nodemon": "^3.1.0",
+    "proxyquire": "^2.1.3",
+    "sinon": "^21"
+  }
+}

package/app/node_modules/@slack/types/dist/block-kit/block-elements.js

@@ -0,0 +1,4 @@
+"use strict";
+// This file contains objects documented here: https://docs.slack.dev/reference/block-kit/block-elements
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=block-elements.js.map

package/app/node_modules/@slack/types/dist/block-kit/blocks.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=blocks.js.map

package/app/node_modules/@slack/types/dist/block-kit/composition-objects.js

@@ -0,0 +1,4 @@
+"use strict";
+// This file contains objects documented here: https://docs.slack.dev/reference/block-kit/composition-objects
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=composition-objects.js.map

package/app/node_modules/@slack/types/dist/block-kit/extensions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=extensions.js.map

package/app/node_modules/@slack/types/dist/calls.js

@@ -0,0 +1,6 @@
+"use strict";
+// These types represent users in Slack Calls, which is an API for showing 3rd party calls within the Slack client.
+// More information on the API guide for Calls: https://docs.slack.dev/apis/web-api/using-the-calls-api
+// and on User objects for use with Calls: https://docs.slack.dev/apis/web-api/using-the-calls-api
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=calls.js.map

package/app/node_modules/@slack/types/dist/chunk.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=chunk.js.map

package/app/node_modules/@slack/types/dist/dialog.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=dialog.js.map

package/app/node_modules/@slack/types/dist/events/app.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=app.js.map

package/app/node_modules/@slack/types/dist/events/assistant.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=assistant.js.map

package/app/node_modules/@slack/types/dist/events/call.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=call.js.map

package/app/node_modules/@slack/types/dist/events/channel.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=channel.js.map

package/app/node_modules/@slack/types/dist/events/dnd.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=dnd.js.map

package/app/node_modules/@slack/types/dist/events/email.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=email.js.map

package/app/node_modules/@slack/types/dist/events/emoji.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=emoji.js.map

package/app/node_modules/@slack/types/dist/events/file.js

@@ -0,0 +1,4 @@
+"use strict";
+// NOTE: `file_comment_added` and `file_comment_edited` are left out because they are discontinued
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=file.js.map

package/app/node_modules/@slack/types/dist/events/function.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=function.js.map

package/app/node_modules/@slack/types/dist/events/grid-migration.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=grid-migration.js.map

package/app/node_modules/@slack/types/dist/events/group.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=group.js.map

package/app/node_modules/@slack/types/dist/events/im.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=im.js.map