@openclaw/slack 2026.9.4 → 2026.9.5

package/node_modules/@slack/socket-mode/node_modules/undici-types/header.d.ts

@@ -1,165 +0,0 @@
-import { Autocomplete } from './utility'
-
-/**
- * The header type declaration of `undici`.
- */
-export type IncomingHttpHeaders = Record<string, string | string[] | undefined>
-
-/**
- * The header type declaration of `undici` for outgoing requests.
- */
-export type OutgoingHttpHeaders = Record<string, number | string | string[] | undefined>
-
-type HeaderNames = Autocomplete<
-  | 'Accept'
-  | 'Accept-CH'
-  | 'Accept-Charset'
-  | 'Accept-Encoding'
-  | 'Accept-Language'
-  | 'Accept-Patch'
-  | 'Accept-Post'
-  | 'Accept-Ranges'
-  | 'Access-Control-Allow-Credentials'
-  | 'Access-Control-Allow-Headers'
-  | 'Access-Control-Allow-Methods'
-  | 'Access-Control-Allow-Origin'
-  | 'Access-Control-Expose-Headers'
-  | 'Access-Control-Max-Age'
-  | 'Access-Control-Request-Headers'
-  | 'Access-Control-Request-Method'
-  | 'Age'
-  | 'Allow'
-  | 'Alt-Svc'
-  | 'Alt-Used'
-  | 'Authorization'
-  | 'Cache-Control'
-  | 'Clear-Site-Data'
-  | 'Connection'
-  | 'Content-Disposition'
-  | 'Content-Encoding'
-  | 'Content-Language'
-  | 'Content-Length'
-  | 'Content-Location'
-  | 'Content-Range'
-  | 'Content-Security-Policy'
-  | 'Content-Security-Policy-Report-Only'
-  | 'Content-Type'
-  | 'Cookie'
-  | 'Cross-Origin-Embedder-Policy'
-  | 'Cross-Origin-Opener-Policy'
-  | 'Cross-Origin-Resource-Policy'
-  | 'Date'
-  | 'Device-Memory'
-  | 'ETag'
-  | 'Expect'
-  | 'Expect-CT'
-  | 'Expires'
-  | 'Forwarded'
-  | 'From'
-  | 'Host'
-  | 'If-Match'
-  | 'If-Modified-Since'
-  | 'If-None-Match'
-  | 'If-Range'
-  | 'If-Unmodified-Since'
-  | 'Keep-Alive'
-  | 'Last-Modified'
-  | 'Link'
-  | 'Location'
-  | 'Max-Forwards'
-  | 'Origin'
-  | 'Permissions-Policy'
-  | 'Priority'
-  | 'Proxy-Authenticate'
-  | 'Proxy-Authorization'
-  | 'Range'
-  | 'Referer'
-  | 'Referrer-Policy'
-  | 'Retry-After'
-  | 'Sec-Fetch-Dest'
-  | 'Sec-Fetch-Mode'
-  | 'Sec-Fetch-Site'
-  | 'Sec-Fetch-User'
-  | 'Sec-Purpose'
-  | 'Sec-WebSocket-Accept'
-  | 'Server'
-  | 'Server-Timing'
-  | 'Service-Worker-Navigation-Preload'
-  | 'Set-Cookie'
-  | 'SourceMap'
-  | 'Strict-Transport-Security'
-  | 'TE'
-  | 'Timing-Allow-Origin'
-  | 'Trailer'
-  | 'Transfer-Encoding'
-  | 'Upgrade'
-  | 'Upgrade-Insecure-Requests'
-  | 'User-Agent'
-  | 'Vary'
-  | 'Via'
-  | 'WWW-Authenticate'
-  | 'X-Content-Type-Options'
-  | 'X-Frame-Options'
->
-
-type IANARegisteredMimeType = Autocomplete<
-  | 'audio/aac'
-  | 'video/x-msvideo'
-  | 'image/avif'
-  | 'video/av1'
-  | 'application/octet-stream'
-  | 'image/bmp'
-  | 'text/css'
-  | 'text/csv'
-  | 'application/vnd.ms-fontobject'
-  | 'application/epub+zip'
-  | 'image/gif'
-  | 'application/gzip'
-  | 'text/html'
-  | 'image/x-icon'
-  | 'text/calendar'
-  | 'image/jpeg'
-  | 'text/javascript'
-  | 'application/json'
-  | 'application/ld+json'
-  | 'audio/x-midi'
-  | 'audio/mpeg'
-  | 'video/mp4'
-  | 'video/mpeg'
-  | 'audio/ogg'
-  | 'video/ogg'
-  | 'application/ogg'
-  | 'audio/opus'
-  | 'font/otf'
-  | 'application/pdf'
-  | 'image/png'
-  | 'application/rtf'
-  | 'image/svg+xml'
-  | 'image/tiff'
-  | 'video/mp2t'
-  | 'font/ttf'
-  | 'text/plain'
-  | 'application/wasm'
-  | 'video/webm'
-  | 'audio/webm'
-  | 'image/webp'
-  | 'font/woff'
-  | 'font/woff2'
-  | 'application/xhtml+xml'
-  | 'application/xml'
-  | 'application/zip'
-  | 'video/3gpp'
-  | 'video/3gpp2'
-  | 'model/gltf+json'
-  | 'model/gltf-binary'
->
-
-type KnownHeaderValues = {
-  'content-type': IANARegisteredMimeType
-}
-
-export type HeaderRecord = {
-  [K in HeaderNames | Lowercase<HeaderNames>]?: Lowercase<K> extends keyof KnownHeaderValues
-    ? KnownHeaderValues[Lowercase<K>]
-    : string
-}

package/node_modules/@slack/socket-mode/node_modules/undici-types/index.d.ts

@@ -1,93 +0,0 @@
-import Dispatcher from './dispatcher'
-import { setGlobalDispatcher, getGlobalDispatcher } from './global-dispatcher'
-import { setGlobalOrigin, getGlobalOrigin } from './global-origin'
-import Pool from './pool'
-import { RedirectHandler, DecoratorHandler } from './handlers'
-
-import BalancedPool from './balanced-pool'
-import RoundRobinPool from './round-robin-pool'
-import Client from './client'
-import H2CClient from './h2c-client'
-import buildConnector from './connector'
-import errors from './errors'
-import Agent from './agent'
-import Dispatcher1Wrapper from './dispatcher1-wrapper'
-import MockClient from './mock-client'
-import MockPool from './mock-pool'
-import MockAgent from './mock-agent'
-import { SnapshotAgent } from './snapshot-agent'
-import { MockCallHistory, MockCallHistoryLog } from './mock-call-history'
-import mockErrors from './mock-errors'
-import ProxyAgent from './proxy-agent'
-import Socks5ProxyAgent from './socks5-proxy-agent'
-import EnvHttpProxyAgent from './env-http-proxy-agent'
-import RetryHandler from './retry-handler'
-import RetryAgent from './retry-agent'
-import { request, pipeline, stream, connect, upgrade } from './api'
-import interceptors from './interceptors'
-
-import CacheInterceptor from './cache-interceptor'
-declare const cacheStores: {
-  MemoryCacheStore: typeof CacheInterceptor.MemoryCacheStore;
-  SqliteCacheStore: typeof CacheInterceptor.SqliteCacheStore;
-}
-
-export * from './util'
-export * from './cookies'
-export * from './eventsource'
-export * from './fetch'
-export * from './formdata'
-export * from './diagnostics-channel'
-export * from './websocket'
-export * from './content-type'
-export * from './cache'
-export { Interceptable } from './mock-interceptor'
-
-declare function globalThisInstall (): void
-
-export { Dispatcher, BalancedPool, RoundRobinPool, Pool, Client, buildConnector, errors, Agent, Dispatcher1Wrapper, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, cacheStores, MockClient, MockPool, MockAgent, SnapshotAgent, MockCallHistory, MockCallHistoryLog, mockErrors, ProxyAgent, Socks5ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent, H2CClient, globalThisInstall as install }
-export default Undici
-
-declare namespace Undici {
-  const Dispatcher: typeof import('./dispatcher').default
-  const Pool: typeof import('./pool').default
-  const RedirectHandler: typeof import ('./handlers').RedirectHandler
-  const DecoratorHandler: typeof import ('./handlers').DecoratorHandler
-  const RetryHandler: typeof import ('./retry-handler').default
-  const BalancedPool: typeof import('./balanced-pool').default
-  const RoundRobinPool: typeof import('./round-robin-pool').default
-  const Client: typeof import('./client').default
-  const H2CClient: typeof import('./h2c-client').default
-  const buildConnector: typeof import('./connector').default
-  const errors: typeof import('./errors').default
-  const Agent: typeof import('./agent').default
-  const Dispatcher1Wrapper: typeof import('./dispatcher1-wrapper').default
-  const setGlobalDispatcher: typeof import('./global-dispatcher').setGlobalDispatcher
-  const getGlobalDispatcher: typeof import('./global-dispatcher').getGlobalDispatcher
-  const request: typeof import('./api').request
-  const stream: typeof import('./api').stream
-  const pipeline: typeof import('./api').pipeline
-  const connect: typeof import('./api').connect
-  const upgrade: typeof import('./api').upgrade
-  const MockClient: typeof import('./mock-client').default
-  const MockPool: typeof import('./mock-pool').default
-  const MockAgent: typeof import('./mock-agent').default
-  const SnapshotAgent: typeof import('./snapshot-agent').SnapshotAgent
-  const MockCallHistory: typeof import('./mock-call-history').MockCallHistory
-  const MockCallHistoryLog: typeof import('./mock-call-history').MockCallHistoryLog
-  const mockErrors: typeof import('./mock-errors').default
-  const ProxyAgent: typeof import('./proxy-agent').default
-  const Socks5ProxyAgent: typeof import('./socks5-proxy-agent').default
-  const fetch: typeof import('./fetch').fetch
-  const Headers: typeof import('./fetch').Headers
-  const Response: typeof import('./fetch').Response
-  const Request: typeof import('./fetch').Request
-  const FormData: typeof import('./formdata').FormData
-  const caches: typeof import('./cache').caches
-  const interceptors: typeof import('./interceptors').default
-  const cacheStores: {
-    MemoryCacheStore: typeof import('./cache-interceptor').default.MemoryCacheStore,
-    SqliteCacheStore: typeof import('./cache-interceptor').default.SqliteCacheStore
-  }
-  const install: typeof globalThisInstall
-}

package/node_modules/@slack/socket-mode/node_modules/undici-types/interceptors.d.ts

@@ -1,80 +0,0 @@
-import CacheHandler from './cache-interceptor'
-import Dispatcher from './dispatcher'
-import RetryHandler from './retry-handler'
-import { LookupOptions } from 'node:dns'
-
-export default Interceptors
-
-declare namespace Interceptors {
-  export type DumpInterceptorOpts = { maxSize?: number }
-  export type RetryInterceptorOpts = RetryHandler.RetryOptions
-  export type RedirectInterceptorOpts = { maxRedirections?: number, throwOnMaxRedirect?: boolean }
-  export type DecompressInterceptorOpts = {
-    skipErrorResponses?: boolean
-    skipStatusCodes?: number[]
-  }
-
-  export type ResponseErrorInterceptorOpts = { throwOnError: boolean }
-  export type CacheInterceptorOpts = CacheHandler.CacheOptions
-
-  // DNS interceptor
-  export type DNSInterceptorRecord = { address: string, ttl: number, family: 4 | 6 }
-  export type DNSInterceptorOriginRecords = { records: { 4: { ips: DNSInterceptorRecord[] } | null, 6: { ips: DNSInterceptorRecord[] } | null } }
-  export type DNSStorage = {
-    size: number
-    get(origin: string): DNSInterceptorOriginRecords | null
-    set(origin: string, records: DNSInterceptorOriginRecords | null, options: { ttl: number }): void
-    delete(origin: string): void
-    full(): boolean
-  }
-  export type DNSInterceptorOpts = {
-    maxTTL?: number
-    maxItems?: number
-    lookup?: (origin: URL, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, addresses: DNSInterceptorRecord[]) => void) => void
-    pick?: (origin: URL, records: DNSInterceptorOriginRecords, affinity: 4 | 6) => DNSInterceptorRecord
-    dualStack?: boolean
-    affinity?: 4 | 6
-    storage?: DNSStorage
-  }
-
-  // Deduplicate interceptor
-  export type DeduplicateMethods = 'GET' | 'HEAD' | 'OPTIONS' | 'TRACE'
-  export type DeduplicateInterceptorOpts = {
-    /**
-     * The HTTP methods to deduplicate.
-     * Note: Only safe HTTP methods can be deduplicated.
-     * @default ['GET']
-     */
-    methods?: DeduplicateMethods[]
-    /**
-     * Header names that, if present in a request, will cause the request to skip deduplication.
-     * Header name matching is case-insensitive.
-     * @default []
-     */
-    skipHeaderNames?: string[]
-    /**
-     * Header names to exclude from the deduplication key.
-     * Requests with different values for these headers will still be deduplicated together.
-     * Useful for headers like `x-request-id` that vary per request but shouldn't affect deduplication.
-     * Header name matching is case-insensitive.
-     * @default []
-     */
-    excludeHeaderNames?: string[]
-    /**
-     * Maximum bytes buffered per paused waiting deduplicated handler.
-     * If a waiting handler remains paused and exceeds this threshold,
-     * it is failed with an abort error to prevent unbounded memory growth.
-     * @default 5 * 1024 * 1024
-     */
-    maxBufferSize?: number
-  }
-
-  export function dump (opts?: DumpInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
-  export function retry (opts?: RetryInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
-  export function redirect (opts?: RedirectInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
-  export function decompress (opts?: DecompressInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
-  export function responseError (opts?: ResponseErrorInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
-  export function dns (opts?: DNSInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
-  export function cache (opts?: CacheInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
-  export function deduplicate (opts?: DeduplicateInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
-}

package/node_modules/@slack/socket-mode/node_modules/undici-types/mock-agent.d.ts

@@ -1,68 +0,0 @@
-import Agent from './agent'
-import Dispatcher from './dispatcher'
-import { Interceptable, MockInterceptor } from './mock-interceptor'
-import MockDispatch = MockInterceptor.MockDispatch
-import { MockCallHistory } from './mock-call-history'
-
-export default MockAgent
-
-interface PendingInterceptor extends MockDispatch {
-  origin: string;
-}
-
-/** A mocked Agent class that implements the Agent API. It allows one to intercept HTTP requests made through undici and return mocked responses instead. */
-declare class MockAgent<TMockAgentOptions extends MockAgent.Options = MockAgent.Options> extends Dispatcher {
-  constructor (options?: TMockAgentOptions)
-  /** Creates and retrieves mock Dispatcher instances which can then be used to intercept HTTP requests. If the number of connections on the mock agent is set to 1, a MockClient instance is returned. Otherwise a MockPool instance is returned. */
-  get<TInterceptable extends Interceptable>(origin: string): TInterceptable
-  get<TInterceptable extends Interceptable>(origin: RegExp): TInterceptable
-  get<TInterceptable extends Interceptable>(origin: ((origin: string) => boolean)): TInterceptable
-  /** Dispatches a mocked request. */
-  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
-  /** Closes the mock agent and waits for registered mock pools and clients to also close before resolving. */
-  close (): Promise<void>
-  /** Disables mocking in MockAgent. */
-  deactivate (): void
-  /** Enables mocking in a MockAgent instance. When instantiated, a MockAgent is automatically activated. Therefore, this method is only effective after `MockAgent.deactivate` has been called. */
-  activate (): void
-  /** Define host matchers so only matching requests that aren't intercepted by the mock dispatchers will be attempted. */
-  enableNetConnect (): void
-  enableNetConnect (host: string): void
-  enableNetConnect (host: RegExp): void
-  enableNetConnect (host: ((host: string) => boolean)): void
-  /** Causes all requests to throw when requests are not matched in a MockAgent intercept. */
-  disableNetConnect (): void
-  /** get call history. returns the MockAgent call history or undefined if the option is not enabled. */
-  getCallHistory (): MockCallHistory | undefined
-  /** clear every call history. Any MockCallHistoryLog will be deleted on the MockCallHistory instance */
-  clearCallHistory (): void
-  /** Enable call history. Any subsequence calls will then be registered. */
-  enableCallHistory (): this
-  /** Disable call history. Any subsequence calls will then not be registered. */
-  disableCallHistory (): this
-  pendingInterceptors (): PendingInterceptor[]
-  assertNoPendingInterceptors (options?: {
-    pendingInterceptorsFormatter?: PendingInterceptorsFormatter;
-  }): void
-}
-
-interface PendingInterceptorsFormatter {
-  format(pendingInterceptors: readonly PendingInterceptor[]): string;
-}
-
-declare namespace MockAgent {
-  /** MockAgent options. */
-  export interface Options extends Agent.Options {
-    /** A custom agent to be encapsulated by the MockAgent. */
-    agent?: Dispatcher;
-
-    /** Ignore trailing slashes in the path */
-    ignoreTrailingSlash?: boolean;
-
-    /** Accept URLs with search parameters using non standard syntaxes. default false */
-    acceptNonStandardSearchParameters?: boolean;
-
-    /** Enable call history. you can either call MockAgent.enableCallHistory(). default false */
-    enableCallHistory?: boolean
-  }
-}

package/node_modules/@slack/socket-mode/node_modules/undici-types/mock-call-history.d.ts

@@ -1,111 +0,0 @@
-import Dispatcher from './dispatcher'
-
-declare namespace MockCallHistoryLog {
-  /** request's configuration properties */
-  export type MockCallHistoryLogProperties = 'protocol' | 'host' | 'port' | 'origin' | 'path' | 'hash' | 'fullUrl' | 'method' | 'searchParams' | 'body' | 'headers'
-}
-
-/** a log reflecting request configuration  */
-declare class MockCallHistoryLog {
-  constructor (requestInit: Dispatcher.DispatchOptions)
-  /** protocol used. ie. 'https:' or 'http:' etc... */
-  protocol: string
-  /** request's host. */
-  host: string
-  /** request's port. */
-  port: string
-  /** request's origin. ie. https://localhost:3000. */
-  origin: string
-  /** path. never contains searchParams. */
-  path: string
-  /** request's hash. */
-  hash: string
-  /** the full url requested. */
-  fullUrl: string
-  /** request's method. */
-  method: string
-  /** search params. */
-  searchParams: Record<string, string>
-  /** request's body */
-  body: string | null | undefined
-  /** request's headers */
-  headers: Record<string, string | string[]> | null | undefined
-
-  /** returns an Map of property / value pair */
-  toMap (): Map<MockCallHistoryLog.MockCallHistoryLogProperties, string | Record<string, string | string[]> | null | undefined>
-
-  /** returns a string computed with all key value pair */
-  toString (): string
-}
-
-declare namespace MockCallHistory {
-  export type FilterCallsOperator = 'AND' | 'OR'
-
-  /** modify the filtering behavior */
-  export interface FilterCallsOptions {
-    /** the operator to apply when filtering. 'OR' will adds any MockCallHistoryLog matching any criteria given. 'AND' will adds only MockCallHistoryLog matching every criteria given. (default 'OR')  */
-    operator?: FilterCallsOperator | Lowercase<FilterCallsOperator>
-  }
-  /** a function to be executed for filtering MockCallHistoryLog */
-  export type FilterCallsFunctionCriteria = (log: MockCallHistoryLog) => boolean
-
-  /** parameter to filter MockCallHistoryLog */
-  export type FilterCallsParameter = string | RegExp | undefined | null
-
-  /** an object to execute multiple filtering at once */
-  export interface FilterCallsObjectCriteria extends Record<string, FilterCallsParameter> {
-    /** filter by request protocol. ie https: */
-    protocol?: FilterCallsParameter;
-    /** filter by request host. */
-    host?: FilterCallsParameter;
-    /** filter by request port. */
-    port?: FilterCallsParameter;
-    /** filter by request origin. */
-    origin?: FilterCallsParameter;
-    /** filter by request path. */
-    path?: FilterCallsParameter;
-    /** filter by request hash. */
-    hash?: FilterCallsParameter;
-    /** filter by request fullUrl. */
-    fullUrl?: FilterCallsParameter;
-    /** filter by request method. */
-    method?: FilterCallsParameter;
-  }
-}
-
-/** a call history to track requests configuration */
-declare class MockCallHistory {
-  constructor (name: string)
-  /** returns an array of MockCallHistoryLog. */
-  calls (): Array<MockCallHistoryLog>
-  /** returns the first MockCallHistoryLog */
-  firstCall (): MockCallHistoryLog | undefined
-  /** returns the last MockCallHistoryLog. */
-  lastCall (): MockCallHistoryLog | undefined
-  /** returns the nth MockCallHistoryLog. */
-  nthCall (position: number): MockCallHistoryLog | undefined
-  /** return all MockCallHistoryLog matching any of criteria given. if an object is used with multiple properties, you can change the operator to apply during filtering on options */
-  filterCalls (criteria: MockCallHistory.FilterCallsFunctionCriteria | MockCallHistory.FilterCallsObjectCriteria | RegExp, options?: MockCallHistory.FilterCallsOptions): Array<MockCallHistoryLog>
-  /** return all MockCallHistoryLog matching the given protocol. if a string is given, it is matched with includes */
-  filterCallsByProtocol (protocol: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
-  /** return all MockCallHistoryLog matching the given host. if a string is given, it is matched with includes */
-  filterCallsByHost (host: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
-  /** return all MockCallHistoryLog matching the given port. if a string is given, it is matched with includes */
-  filterCallsByPort (port: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
-  /** return all MockCallHistoryLog matching the given origin. if a string is given, it is matched with includes */
-  filterCallsByOrigin (origin: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
-  /** return all MockCallHistoryLog matching the given path. if a string is given, it is matched with includes */
-  filterCallsByPath (path: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
-  /** return all MockCallHistoryLog matching the given hash. if a string is given, it is matched with includes */
-  filterCallsByHash (hash: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
-  /** return all MockCallHistoryLog matching the given fullUrl. if a string is given, it is matched with includes */
-  filterCallsByFullUrl (fullUrl: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
-  /** return all MockCallHistoryLog matching the given method. if a string is given, it is matched with includes */
-  filterCallsByMethod (method: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
-  /** clear all MockCallHistoryLog on this MockCallHistory. */
-  clear (): void
-  /** use it with for..of loop or spread operator */
-  [Symbol.iterator]: () => Generator<MockCallHistoryLog>
-}
-
-export { MockCallHistoryLog, MockCallHistory }

package/node_modules/@slack/socket-mode/node_modules/undici-types/mock-client.d.ts

@@ -1,27 +0,0 @@
-import Client from './client'
-import Dispatcher from './dispatcher'
-import MockAgent from './mock-agent'
-import { MockInterceptor, Interceptable } from './mock-interceptor'
-
-export default MockClient
-
-/** MockClient extends the Client API and allows one to mock requests. */
-declare class MockClient extends Client implements Interceptable {
-  constructor (origin: string, options: MockClient.Options)
-  /** Intercepts any matching requests that use the same origin as this mock client. */
-  intercept (options: MockInterceptor.Options): MockInterceptor
-  /** Dispatches a mocked request. */
-  dispatch (options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandler): boolean
-  /** Closes the mock client and gracefully waits for enqueued requests to complete. */
-  close (): Promise<void>
-  /** Clean up all the prepared mocks. */
-  cleanMocks (): void
-}
-
-declare namespace MockClient {
-  /** MockClient options. */
-  export interface Options extends Client.Options {
-    /** The agent to associate this MockClient with. */
-    agent: MockAgent;
-  }
-}

package/node_modules/@slack/socket-mode/node_modules/undici-types/mock-errors.d.ts

@@ -1,12 +0,0 @@
-import Errors from './errors'
-
-export default MockErrors
-
-declare namespace MockErrors {
-  /** The request does not match any registered mock dispatches. */
-  export class MockNotMatchedError extends Errors.UndiciError {
-    constructor (message?: string)
-    name: 'MockNotMatchedError'
-    code: 'UND_MOCK_ERR_MOCK_NOT_MATCHED'
-  }
-}

package/node_modules/@slack/socket-mode/node_modules/undici-types/mock-interceptor.d.ts

@@ -1,94 +0,0 @@
-import { IncomingHttpHeaders } from './header'
-import Dispatcher from './dispatcher'
-import { BodyInit, Headers } from './fetch'
-
-/** The scope associated with a mock dispatch. */
-declare class MockScope<TData extends object = object> {
-  constructor (mockDispatch: MockInterceptor.MockDispatch<TData>)
-  /** Delay a reply by a set amount of time in ms. */
-  delay (waitInMs: number): MockScope<TData>
-  /** Persist the defined mock data for the associated reply. It will return the defined mock data indefinitely. */
-  persist (): MockScope<TData>
-  /** Define a reply for a set amount of matching requests. */
-  times (repeatTimes: number): MockScope<TData>
-}
-
-/** The interceptor for a Mock. */
-declare class MockInterceptor {
-  constructor (options: MockInterceptor.Options, mockDispatches: MockInterceptor.MockDispatch[])
-  /** Mock an undici request with the defined reply. */
-  reply<TData extends object = object>(replyOptionsCallback: MockInterceptor.MockReplyOptionsCallback<TData>): MockScope<TData>
-  reply<TData extends object = object>(
-    statusCode: number,
-    data?: TData | Buffer | string | MockInterceptor.MockResponseDataHandler<TData>,
-    responseOptions?: MockInterceptor.MockResponseOptions
-  ): MockScope<TData>
-  /** Mock an undici request by throwing the defined reply error. */
-  replyWithError<TError extends Error = Error>(error: TError): MockScope
-  /** Set default reply headers on the interceptor for subsequent mocked replies. */
-  defaultReplyHeaders (headers: IncomingHttpHeaders): MockInterceptor
-  /** Set default reply trailers on the interceptor for subsequent mocked replies. */
-  defaultReplyTrailers (trailers: Record<string, string>): MockInterceptor
-  /** Set automatically calculated content-length header on subsequent mocked replies. */
-  replyContentLength (): MockInterceptor
-}
-
-declare namespace MockInterceptor {
-  /** MockInterceptor options. */
-  export interface Options {
-    /** Path to intercept on. */
-    path: string | RegExp | ((path: string) => boolean);
-    /** Method to intercept on. Defaults to GET. */
-    method?: string | RegExp | ((method: string) => boolean);
-    /** Body to intercept on. */
-    body?: string | RegExp | ((body: string) => boolean);
-    /** Headers to intercept on. */
-    headers?: Record<string, string | RegExp | ((body: string) => boolean)> | ((headers: Record<string, string>) => boolean);
-    /** Query params to intercept on */
-    query?: Record<string, any>;
-  }
-  export interface MockDispatch<TData extends object = object, TError extends Error = Error> extends Options {
-    times: number | null;
-    persist: boolean;
-    consumed: boolean;
-    data: MockDispatchData<TData, TError>;
-  }
-  export interface MockDispatchData<TData extends object = object, TError extends Error = Error> extends MockResponseOptions {
-    error: TError | null;
-    statusCode?: number;
-    data?: TData | string;
-  }
-  export interface MockResponseOptions {
-    headers?: IncomingHttpHeaders;
-    trailers?: Record<string, string>;
-  }
-
-  export interface MockResponseCallbackOptions {
-    path: string;
-    method: string;
-    headers?: Headers | Record<string, string>;
-    origin?: string;
-    body?: BodyInit | Dispatcher.DispatchOptions['body'] | null;
-  }
-
-  export type MockResponseDataHandler<TData extends object = object> = (
-    opts: MockResponseCallbackOptions
-  ) => TData | Buffer | string
-
-  export type MockReplyOptionsCallback<TData extends object = object> = (
-    opts: MockResponseCallbackOptions
-  ) => { statusCode: number, data?: TData | Buffer | string, responseOptions?: MockResponseOptions }
-}
-
-interface Interceptable extends Dispatcher {
-  /** Intercepts any matching requests that use the same origin as this mock client. */
-  intercept(options: MockInterceptor.Options): MockInterceptor;
-  /** Clean up all the prepared mocks. */
-  cleanMocks (): void
-}
-
-export {
-  Interceptable,
-  MockInterceptor,
-  MockScope
-}