@openclaw/feishu 2026.7.2-beta.7 → 2026.7.33

package/node_modules/@larksuiteoapi/node-sdk/node_modules/undici-types/errors.d.ts

@@ -0,0 +1,177 @@
+import { IncomingHttpHeaders } from './header'
+import Client from './client'
+
+export default Errors
+
+declare namespace Errors {
+  export class UndiciError extends Error {
+    name: string
+    code: string
+  }
+
+  /** Connect timeout error. */
+  export class ConnectTimeoutError extends UndiciError {
+    name: 'ConnectTimeoutError'
+    code: 'UND_ERR_CONNECT_TIMEOUT'
+  }
+
+  /** A header exceeds the `headersTimeout` option. */
+  export class HeadersTimeoutError extends UndiciError {
+    name: 'HeadersTimeoutError'
+    code: 'UND_ERR_HEADERS_TIMEOUT'
+  }
+
+  /** Headers overflow error. */
+  export class HeadersOverflowError extends UndiciError {
+    name: 'HeadersOverflowError'
+    code: 'UND_ERR_HEADERS_OVERFLOW'
+  }
+
+  /** A body exceeds the `bodyTimeout` option. */
+  export class BodyTimeoutError extends UndiciError {
+    name: 'BodyTimeoutError'
+    code: 'UND_ERR_BODY_TIMEOUT'
+  }
+
+  export class ResponseError extends UndiciError {
+    constructor (
+      message: string,
+      code: number,
+      options: {
+        headers?: IncomingHttpHeaders | string[] | null,
+        body?: null | Record<string, any> | string
+      }
+    )
+    name: 'ResponseError'
+    code: 'UND_ERR_RESPONSE'
+    statusCode: number
+    body: null | Record<string, any> | string
+    headers: IncomingHttpHeaders | string[] | null
+  }
+
+  /** Passed an invalid argument. */
+  export class InvalidArgumentError extends UndiciError {
+    name: 'InvalidArgumentError'
+    code: 'UND_ERR_INVALID_ARG'
+  }
+
+  /** Returned an invalid value. */
+  export class InvalidReturnValueError extends UndiciError {
+    name: 'InvalidReturnValueError'
+    code: 'UND_ERR_INVALID_RETURN_VALUE'
+  }
+
+  /** The request has been aborted by the user. */
+  export class RequestAbortedError extends UndiciError {
+    name: 'AbortError'
+    code: 'UND_ERR_ABORTED'
+  }
+
+  /** Expected error with reason. */
+  export class InformationalError extends UndiciError {
+    name: 'InformationalError'
+    code: 'UND_ERR_INFO'
+  }
+
+  /** Request body length does not match content-length header. */
+  export class RequestContentLengthMismatchError extends UndiciError {
+    name: 'RequestContentLengthMismatchError'
+    code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH'
+  }
+
+  /** Response body length does not match content-length header. */
+  export class ResponseContentLengthMismatchError extends UndiciError {
+    name: 'ResponseContentLengthMismatchError'
+    code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH'
+  }
+
+  /** Trying to use a destroyed client. */
+  export class ClientDestroyedError extends UndiciError {
+    name: 'ClientDestroyedError'
+    code: 'UND_ERR_DESTROYED'
+  }
+
+  /** Trying to use a closed client. */
+  export class ClientClosedError extends UndiciError {
+    name: 'ClientClosedError'
+    code: 'UND_ERR_CLOSED'
+  }
+
+  /** There is an error with the socket. */
+  export class SocketError extends UndiciError {
+    name: 'SocketError'
+    code: 'UND_ERR_SOCKET'
+    socket: Client.SocketInfo | null
+  }
+
+  /** Encountered unsupported functionality. */
+  export class NotSupportedError extends UndiciError {
+    name: 'NotSupportedError'
+    code: 'UND_ERR_NOT_SUPPORTED'
+  }
+
+  /** No upstream has been added to the BalancedPool. */
+  export class BalancedPoolMissingUpstreamError extends UndiciError {
+    name: 'MissingUpstreamError'
+    code: 'UND_ERR_BPL_MISSING_UPSTREAM'
+  }
+
+  export class HTTPParserError extends UndiciError {
+    name: 'HTTPParserError'
+    code: string
+  }
+
+  /** The response exceed the length allowed. */
+  export class ResponseExceededMaxSizeError extends UndiciError {
+    name: 'ResponseExceededMaxSizeError'
+    code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE'
+  }
+
+  export class RequestRetryError extends UndiciError {
+    constructor (
+      message: string,
+      statusCode: number,
+      headers?: IncomingHttpHeaders | string[] | null,
+      body?: null | Record<string, any> | string
+    )
+    name: 'RequestRetryError'
+    code: 'UND_ERR_REQ_RETRY'
+    statusCode: number
+    data: {
+      count: number;
+    }
+
+    headers: Record<string, string | string[]>
+  }
+
+  export class SecureProxyConnectionError extends UndiciError {
+    constructor (
+      cause?: Error,
+      message?: string,
+      options?: Record<any, any>
+    )
+    name: 'SecureProxyConnectionError'
+    code: 'UND_ERR_PRX_TLS'
+  }
+
+  export class MaxOriginsReachedError extends UndiciError {
+    name: 'MaxOriginsReachedError'
+    code: 'UND_ERR_MAX_ORIGINS_REACHED'
+  }
+
+  /** SOCKS5 proxy related error. */
+  export class Socks5ProxyError extends UndiciError {
+    constructor (
+      message?: string,
+      code?: string
+    )
+    name: 'Socks5ProxyError'
+    code: string
+  }
+
+  /** WebSocket decompressed message exceeded maximum size. */
+  export class MessageSizeExceededError extends UndiciError {
+    name: 'MessageSizeExceededError'
+    code: 'UND_ERR_WS_MESSAGE_SIZE_EXCEEDED'
+  }
+}

package/node_modules/@larksuiteoapi/node-sdk/node_modules/undici-types/eventsource.d.ts

@@ -0,0 +1,66 @@
+import { MessageEvent, ErrorEvent } from './websocket'
+import Dispatcher from './dispatcher'
+
+import {
+  EventListenerOptions,
+  AddEventListenerOptions,
+  EventListenerOrEventListenerObject
+} from './patch'
+
+interface EventSourceEventMap {
+  error: ErrorEvent
+  message: MessageEvent
+  open: Event
+}
+
+interface EventSource extends EventTarget {
+  close(): void
+  readonly CLOSED: 2
+  readonly CONNECTING: 0
+  readonly OPEN: 1
+  onerror: ((this: EventSource, ev: ErrorEvent) => any) | null
+  onmessage: ((this: EventSource, ev: MessageEvent) => any) | null
+  onopen: ((this: EventSource, ev: Event) => any) | null
+  readonly readyState: 0 | 1 | 2
+  readonly url: string
+  readonly withCredentials: boolean
+
+  addEventListener<K extends keyof EventSourceEventMap>(
+    type: K,
+    listener: (this: EventSource, ev: EventSourceEventMap[K]) => any,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  removeEventListener<K extends keyof EventSourceEventMap>(
+    type: K,
+    listener: (this: EventSource, ev: EventSourceEventMap[K]) => any,
+    options?: boolean | EventListenerOptions
+  ): void
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions
+  ): void
+}
+
+export declare const EventSource: {
+  prototype: EventSource
+  new (url: string | URL, init?: EventSourceInit): EventSource
+  readonly CLOSED: 2
+  readonly CONNECTING: 0
+  readonly OPEN: 1
+}
+
+interface EventSourceInit {
+  withCredentials?: boolean
+  // @deprecated use `node.dispatcher` instead
+  dispatcher?: Dispatcher
+  node?: {
+    dispatcher?: Dispatcher
+    reconnectionTime?: number
+  }
+}

package/node_modules/@larksuiteoapi/node-sdk/node_modules/undici-types/fetch.d.ts

@@ -0,0 +1,231 @@
+// based on https://github.com/Ethan-Arrowood/undici-fetch/blob/249269714db874351589d2d364a0645d5160ae71/index.d.ts (MIT license)
+// and https://github.com/node-fetch/node-fetch/blob/914ce6be5ec67a8bab63d68510aabf07cb818b6d/index.d.ts (MIT license)
+/// <reference types="node" />
+
+import { Blob } from 'node:buffer'
+import { URL, URLSearchParams } from 'node:url'
+import { ReadableStream } from 'node:stream/web'
+import { FormData } from './formdata'
+import { HeaderRecord } from './header'
+import Dispatcher from './dispatcher'
+
+export type RequestInfo = string | URL | Request
+
+export declare function fetch (
+  input: RequestInfo,
+  init?: RequestInit
+): Promise<Response>
+
+export type BodyInit =
+  | ArrayBuffer
+  | AsyncIterable<Uint8Array>
+  | Blob
+  | FormData
+  | Iterable<Uint8Array>
+  | NodeJS.ArrayBufferView
+  | URLSearchParams
+  | null
+  | string
+
+export class BodyMixin {
+  readonly body: ReadableStream | null
+  readonly bodyUsed: boolean
+
+  readonly arrayBuffer: () => Promise<ArrayBuffer>
+  readonly blob: () => Promise<Blob>
+  readonly bytes: () => Promise<Uint8Array>
+  /**
+   * @deprecated This method is not recommended for parsing multipart/form-data bodies in server environments.
+   * It is recommended to use a library such as [@fastify/busboy](https://www.npmjs.com/package/@fastify/busboy) as follows:
+   *
+   * @example
+   * ```js
+   * import { Busboy } from '@fastify/busboy'
+   * import { Readable } from 'node:stream'
+   *
+   * const response = await fetch('...')
+   * const busboy = new Busboy({ headers: { 'content-type': response.headers.get('content-type') } })
+   *
+   * // handle events emitted from `busboy`
+   *
+   * Readable.fromWeb(response.body).pipe(busboy)
+   * ```
+   */
+  readonly formData: () => Promise<FormData>
+  readonly json: () => Promise<unknown>
+  readonly text: () => Promise<string>
+}
+
+export interface SpecIterator<T, TReturn = any, TNext = undefined> {
+  next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
+}
+
+export interface SpecIteratorObject<T, TReturn = undefined, TNext = unknown> extends SpecIterator<T, TReturn, TNext> {
+  [Symbol.iterator](): SpecIteratorObject<T, TReturn, TNext>;
+  map<U>(callbackfn: (value: T, index: number) => U): SpecIteratorObject<U>;
+  filter<S extends T>(predicate: (value: T, index: number) => value is S): SpecIteratorObject<S>;
+  filter(predicate: (value: T, index: number) => unknown): SpecIteratorObject<T>;
+  take(limit: number): SpecIteratorObject<T>;
+  drop(count: number): SpecIteratorObject<T>;
+  flatMap<U>(callbackfn: (value: T, index: number) => Iterator<U> | Iterable<U>): SpecIteratorObject<U>;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T): T;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T, initialValue: T): T;
+  reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number) => U, initialValue: U): U;
+  toArray(): T[];
+  forEach(callbackfn: (value: T, index: number) => void): void;
+  some(predicate: (value: T, index: number) => unknown): boolean;
+  every(predicate: (value: T, index: number) => unknown): boolean;
+  find<S extends T>(predicate: (value: T, index: number) => value is S): S | undefined;
+  find(predicate: (value: T, index: number) => unknown): T | undefined;
+  readonly [Symbol.toStringTag]: string;
+}
+
+export interface SpecIterableIterator<T> extends SpecIteratorObject<T> {
+  [Symbol.iterator](): SpecIterableIterator<T>;
+}
+
+export interface SpecIterable<T> {
+  [Symbol.iterator](): SpecIterableIterator<T>;
+}
+
+export type HeadersInit = [string, string][] | HeaderRecord | Headers
+
+export declare class Headers implements SpecIterable<[string, string]> {
+  constructor (init?: HeadersInit)
+  readonly append: (name: string, value: string) => void
+  readonly delete: (name: string) => void
+  readonly get: (name: string) => string | null
+  readonly has: (name: string) => boolean
+  readonly set: (name: string, value: string) => void
+  readonly getSetCookie: () => string[]
+  readonly forEach: (
+    callbackfn: (value: string, key: string, iterable: Headers) => void,
+    thisArg?: unknown
+  ) => void
+
+  readonly keys: () => SpecIterableIterator<string>
+  readonly values: () => SpecIterableIterator<string>
+  readonly entries: () => SpecIterableIterator<[string, string]>
+  readonly [Symbol.iterator]: () => SpecIterableIterator<[string, string]>
+}
+
+export type RequestCache =
+  | 'default'
+  | 'force-cache'
+  | 'no-cache'
+  | 'no-store'
+  | 'only-if-cached'
+  | 'reload'
+
+export type RequestCredentials = 'omit' | 'include' | 'same-origin'
+
+type RequestDestination =
+  | ''
+  | 'audio'
+  | 'audioworklet'
+  | 'document'
+  | 'embed'
+  | 'font'
+  | 'image'
+  | 'manifest'
+  | 'object'
+  | 'paintworklet'
+  | 'report'
+  | 'script'
+  | 'sharedworker'
+  | 'style'
+  | 'track'
+  | 'video'
+  | 'worker'
+  | 'xslt'
+
+export interface RequestInit {
+  body?: BodyInit | null
+  cache?: RequestCache
+  credentials?: RequestCredentials
+  dispatcher?: Dispatcher
+  duplex?: RequestDuplex
+  headers?: HeadersInit
+  integrity?: string
+  keepalive?: boolean
+  method?: string
+  mode?: RequestMode
+  redirect?: RequestRedirect
+  referrer?: string
+  referrerPolicy?: ReferrerPolicy
+  signal?: AbortSignal | null
+  window?: null
+}
+
+export type ReferrerPolicy =
+  | ''
+  | 'no-referrer'
+  | 'no-referrer-when-downgrade'
+  | 'origin'
+  | 'origin-when-cross-origin'
+  | 'same-origin'
+  | 'strict-origin'
+  | 'strict-origin-when-cross-origin'
+  | 'unsafe-url'
+
+export type RequestMode = 'cors' | 'navigate' | 'no-cors' | 'same-origin'
+
+export type RequestRedirect = 'error' | 'follow' | 'manual'
+
+export type RequestDuplex = 'half'
+
+export declare class Request extends BodyMixin {
+  constructor (input: RequestInfo, init?: RequestInit)
+
+  readonly cache: RequestCache
+  readonly credentials: RequestCredentials
+  readonly destination: RequestDestination
+  readonly headers: Headers
+  readonly integrity: string
+  readonly method: string
+  readonly mode: RequestMode
+  readonly redirect: RequestRedirect
+  readonly referrer: string
+  readonly referrerPolicy: ReferrerPolicy
+  readonly url: string
+
+  readonly keepalive: boolean
+  readonly signal: AbortSignal
+  readonly duplex: RequestDuplex
+
+  public clone (): Request
+}
+
+export interface ResponseInit {
+  readonly status?: number
+  readonly statusText?: string
+  readonly headers?: HeadersInit
+}
+
+export type ResponseType =
+  | 'basic'
+  | 'cors'
+  | 'default'
+  | 'error'
+  | 'opaque'
+  | 'opaqueredirect'
+
+export type ResponseRedirectStatus = 301 | 302 | 303 | 307 | 308
+
+export declare class Response extends BodyMixin {
+  constructor (body?: BodyInit, init?: ResponseInit)
+
+  readonly headers: Headers
+  readonly ok: boolean
+  readonly status: number
+  readonly statusText: string
+  readonly type: ResponseType
+  readonly url: string
+  readonly redirected: boolean
+
+  public clone (): Response
+
+  static error (): Response
+  static json (data: any, init?: ResponseInit): Response
+  static redirect (url: string | URL, status?: ResponseRedirectStatus): Response
+}

package/node_modules/@larksuiteoapi/node-sdk/node_modules/undici-types/formdata.d.ts

@@ -0,0 +1,108 @@
+// Based on https://github.com/octet-stream/form-data/blob/2d0f0dc371517444ce1f22cdde13f51995d0953a/lib/FormData.ts (MIT)
+/// <reference types="node" />
+
+import { File } from 'node:buffer'
+import { SpecIterableIterator } from './fetch'
+
+/**
+ * A `string` or `File` that represents a single value from a set of `FormData` key-value pairs.
+ */
+declare type FormDataEntryValue = string | File
+
+/**
+ * Provides a way to easily construct a set of key/value pairs representing form fields and their values, which can then be easily sent using fetch().
+ */
+export declare class FormData {
+  /**
+   * Appends a new value onto an existing key inside a FormData object,
+   * or adds the key if it does not already exist.
+   *
+   * The difference between `set()` and `append()` is that if the specified key already exists, `set()` will overwrite all existing values with the new one, whereas `append()` will append the new value onto the end of the existing set of values.
+   *
+   * @param name The name of the field whose data is contained in `value`.
+   * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+    or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+   * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+   */
+  append (name: string, value: unknown, fileName?: string): void
+
+  /**
+   * Set a new value for an existing key inside FormData,
+   * or add the new field if it does not already exist.
+   *
+   * @param name The name of the field whose data is contained in `value`.
+   * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+    or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+   * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+   *
+   */
+  set (name: string, value: unknown, fileName?: string): void
+
+  /**
+   * Returns the first value associated with a given key from within a `FormData` object.
+   * If you expect multiple values and want all of them, use the `getAll()` method instead.
+   *
+   * @param {string} name A name of the value you want to retrieve.
+   *
+   * @returns A `FormDataEntryValue` containing the value. If the key doesn't exist, the method returns null.
+   */
+  get (name: string): FormDataEntryValue | null
+
+  /**
+   * Returns all the values associated with a given key from within a `FormData` object.
+   *
+   * @param {string} name A name of the value you want to retrieve.
+   *
+   * @returns An array of `FormDataEntryValue` whose key matches the value passed in the `name` parameter. If the key doesn't exist, the method returns an empty list.
+   */
+  getAll (name: string): FormDataEntryValue[]
+
+  /**
+   * Returns a boolean stating whether a `FormData` object contains a certain key.
+   *
+   * @param name A string representing the name of the key you want to test for.
+   *
+   * @return A boolean value.
+   */
+  has (name: string): boolean
+
+  /**
+   * Deletes a key and its value(s) from a `FormData` object.
+   *
+   * @param name The name of the key you want to delete.
+   */
+  delete (name: string): void
+
+  /**
+   * Executes given callback function for each field of the FormData instance
+   */
+  forEach: (
+    callbackfn: (value: FormDataEntryValue, key: string, iterable: FormData) => void,
+    thisArg?: unknown
+  ) => void
+
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all keys contained in this `FormData` object.
+   * Each key is a `string`.
+   */
+  keys: () => SpecIterableIterator<string>
+
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all values contained in this object `FormData` object.
+   * Each value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+   */
+  values: () => SpecIterableIterator<FormDataEntryValue>
+
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through the `FormData` key/value pairs.
+   * The key of each pair is a string; the value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+   */
+  entries: () => SpecIterableIterator<[string, FormDataEntryValue]>
+
+  /**
+   * An alias for FormData#entries()
+   */
+  [Symbol.iterator]: () => SpecIterableIterator<[string, FormDataEntryValue]>
+
+  readonly [Symbol.toStringTag]: string
+}

package/node_modules/@larksuiteoapi/node-sdk/node_modules/undici-types/global-dispatcher.d.ts

@@ -0,0 +1,9 @@
+import Dispatcher from './dispatcher'
+
+declare function setGlobalDispatcher<DispatcherImplementation extends Dispatcher> (dispatcher: DispatcherImplementation): void
+declare function getGlobalDispatcher (): Dispatcher
+
+export {
+  getGlobalDispatcher,
+  setGlobalDispatcher
+}

package/node_modules/@larksuiteoapi/node-sdk/node_modules/undici-types/global-origin.d.ts

@@ -0,0 +1,7 @@
+declare function setGlobalOrigin (origin: string | URL | undefined): void
+declare function getGlobalOrigin (): URL | undefined
+
+export {
+  setGlobalOrigin,
+  getGlobalOrigin
+}

package/node_modules/@larksuiteoapi/node-sdk/node_modules/undici-types/h2c-client.d.ts

@@ -0,0 +1,73 @@
+import { URL } from 'node:url'
+import Dispatcher from './dispatcher'
+import buildConnector from './connector'
+
+type H2ClientOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+
+/**
+ * A basic H2C client, mapped on top a single TCP connection. Pipelining is disabled by default.
+ */
+export class H2CClient extends Dispatcher {
+  constructor (url: string | URL, options?: H2CClient.Options)
+  /** Property to get and set the pipelining factor. */
+  pipelining: number
+  /** `true` after `client.close()` has been called. */
+  closed: boolean
+  /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
+  destroyed: boolean
+
+  // Override dispatcher APIs.
+  override connect (
+    options: H2ClientOptions
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
+    options: H2ClientOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void
+}
+
+export declare namespace H2CClient {
+  export interface Options {
+    /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
+    maxHeaderSize?: number;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
+    headersTimeout?: number;
+    /** The timeout for establishing a socket connection, in milliseconds. Use `0` to disable it entirely. Default: `10e3` milliseconds (10s). */
+    connectTimeout?: number;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
+    bodyTimeout?: number;
+    /** the timeout, in milliseconds, after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
+    keepAliveTimeout?: number;
+    /** the maximum allowed `idleTimeout`, in milliseconds, when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
+    keepAliveMaxTimeout?: number;
+    /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
+    keepAliveTimeoutThreshold?: number;
+    /** An IPC endpoint, either a Unix domain socket or Windows named pipe. Default: `null`. */
+    socketPath?: string;
+    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
+    pipelining?: number;
+    /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
+    strictContentLength?: boolean;
+    /** Maximum number of TLS cached sessions used by the built-in connector. Use `0` to disable TLS session caching. Default: `100`. */
+    maxCachedSessions?: number;
+    /** Connector options passed to `buildConnector`, or a custom connector function. Default: `null`. */
+    connect?: Omit<Partial<buildConnector.BuildOptions>, 'allowH2'> | buildConnector.connector;
+    /** The maximum number of requests to send over a single connection before it is reset. Use `0` to disable this limit. Default: `null`. */
+    maxRequestsPerClient?: number;
+    /** Local IP address the socket should connect from. */
+    localAddress?: string;
+    /** Max response body size in bytes, -1 is disabled */
+    maxResponseSize?: number;
+    /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
+    autoSelectFamily?: boolean;
+    /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
+    autoSelectFamilyAttemptTimeout?: number;
+    /**
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+     * @default 100
+    */
+    maxConcurrentStreams?: number
+  }
+}
+
+export default H2CClient

package/node_modules/@larksuiteoapi/node-sdk/node_modules/undici-types/handlers.d.ts

@@ -0,0 +1,14 @@
+import Dispatcher from './dispatcher'
+
+export declare class RedirectHandler implements Dispatcher.DispatchHandler {
+  constructor (
+    dispatch: Dispatcher.Dispatch,
+    maxRedirections: number,
+    opts: Dispatcher.DispatchOptions,
+    handler: Dispatcher.DispatchHandler
+  )
+}
+
+export declare class DecoratorHandler implements Dispatcher.DispatchHandler {
+  constructor (handler: Dispatcher.DispatchHandler)
+}