adspecs 0.1.41 → 0.2.0

package/skills/adspecs-export-word/references/node_modules/undici-types/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "undici-types",
+  "version": "7.24.6",
+  "description": "A stand-alone types package for Undici",
+  "homepage": "https://undici.nodejs.org",
+  "bugs": {
+    "url": "https://github.com/nodejs/undici/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nodejs/undici.git"
+  },
+  "license": "MIT",
+  "types": "index.d.ts",
+  "files": [
+    "*.d.ts"
+  ],
+  "contributors": [
+    {
+      "name": "Daniele Belardi",
+      "url": "https://github.com/dnlup",
+      "author": true
+    },
+    {
+      "name": "Ethan Arrowood",
+      "url": "https://github.com/ethan-arrowood",
+      "author": true
+    },
+    {
+      "name": "Matteo Collina",
+      "url": "https://github.com/mcollina",
+      "author": true
+    },
+    {
+      "name": "Matthew Aitken",
+      "url": "https://github.com/KhafraDev",
+      "author": true
+    },
+    {
+      "name": "Robert Nagy",
+      "url": "https://github.com/ronag",
+      "author": true
+    },
+    {
+      "name": "Szymon Marczak",
+      "url": "https://github.com/szmarczak",
+      "author": true
+    },
+    {
+      "name": "Tomas Della Vedova",
+      "url": "https://github.com/delvedor",
+      "author": true
+    }
+  ]
+}

package/skills/adspecs-export-word/references/node_modules/undici-types/patch.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+
+// See https://github.com/nodejs/undici/issues/1740
+
+export interface EventInit {
+  bubbles?: boolean
+  cancelable?: boolean
+  composed?: boolean
+}
+
+export interface EventListenerOptions {
+  capture?: boolean
+}
+
+export interface AddEventListenerOptions extends EventListenerOptions {
+  once?: boolean
+  passive?: boolean
+  signal?: AbortSignal
+}
+
+export type EventListenerOrEventListenerObject = EventListener | EventListenerObject
+
+export interface EventListenerObject {
+  handleEvent (object: Event): void
+}
+
+export interface EventListener {
+  (evt: Event): void
+}

package/skills/adspecs-export-word/references/node_modules/undici-types/pool-stats.d.ts

@@ -0,0 +1,19 @@
+import Pool from './pool'
+
+export default PoolStats
+
+declare class PoolStats {
+  constructor (pool: Pool)
+  /** Number of open socket connections in this pool. */
+  connected: number
+  /** Number of open socket connections in this pool that do not have an active request. */
+  free: number
+  /** Number of pending requests across all clients in this pool. */
+  pending: number
+  /** Number of queued requests across all clients in this pool. */
+  queued: number
+  /** Number of currently active requests across all clients in this pool. */
+  running: number
+  /** Number of active, pending, or queued requests across all clients in this pool. */
+  size: number
+}

package/skills/adspecs-export-word/references/node_modules/undici-types/pool.d.ts

@@ -0,0 +1,41 @@
+import Client from './client'
+import TPoolStats from './pool-stats'
+import { URL } from 'node:url'
+import Dispatcher from './dispatcher'
+
+export default Pool
+
+type PoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+
+declare class Pool extends Dispatcher {
+  constructor (url: string | URL, options?: Pool.Options)
+  /** `true` after `pool.close()` has been called. */
+  closed: boolean
+  /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
+  destroyed: boolean
+  /** Aggregate stats for a Pool. */
+  readonly stats: TPoolStats
+
+  // Override dispatcher APIs.
+  override connect (
+    options: PoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
+    options: PoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void
+}
+
+declare namespace Pool {
+  export type PoolStats = TPoolStats
+  export interface Options extends Client.Options {
+    /** Default: `(origin, opts) => new Client(origin, opts)`. */
+    factory?(origin: URL, opts: object): Dispatcher;
+    /** The max number of clients to create. `null` if no limit. Default `null`. */
+    connections?: number | null;
+    /** The amount of time before a client is removed from the pool and closed. `null` if no time limit. Default `null` */
+    clientTtl?: number | null;
+
+    interceptors?: { Pool?: readonly Dispatcher.DispatchInterceptor[] } & Client.Options['interceptors']
+  }
+}

package/skills/adspecs-export-word/references/node_modules/undici-types/proxy-agent.d.ts

@@ -0,0 +1,29 @@
+import Agent from './agent'
+import buildConnector from './connector'
+import Dispatcher from './dispatcher'
+import { IncomingHttpHeaders } from './header'
+
+export default ProxyAgent
+
+declare class ProxyAgent extends Dispatcher {
+  constructor (options: ProxyAgent.Options | string)
+
+  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
+  close (): Promise<void>
+}
+
+declare namespace ProxyAgent {
+  export interface Options extends Agent.Options {
+    uri: string;
+    /**
+     * @deprecated use opts.token
+     */
+    auth?: string;
+    token?: string;
+    headers?: IncomingHttpHeaders;
+    requestTls?: buildConnector.BuildOptions;
+    proxyTls?: buildConnector.BuildOptions;
+    clientFactory?(origin: URL, opts: object): Dispatcher;
+    proxyTunnel?: boolean;
+  }
+}

package/skills/adspecs-export-word/references/node_modules/undici-types/readable.d.ts

@@ -0,0 +1,68 @@
+import { Readable } from 'node:stream'
+import { Blob } from 'node:buffer'
+
+export default BodyReadable
+
+declare class BodyReadable extends Readable {
+  constructor (opts: {
+    resume: (this: Readable, size: number) => void | null;
+    abort: () => void | null;
+    contentType?: string;
+    contentLength?: number;
+    highWaterMark?: number;
+  })
+
+  /** Consumes and returns the body as a string
+   *  https://fetch.spec.whatwg.org/#dom-body-text
+   */
+  text (): Promise<string>
+
+  /** Consumes and returns the body as a JavaScript Object
+   *  https://fetch.spec.whatwg.org/#dom-body-json
+   */
+  json (): Promise<unknown>
+
+  /** Consumes and returns the body as a Blob
+   *  https://fetch.spec.whatwg.org/#dom-body-blob
+   */
+  blob (): Promise<Blob>
+
+  /** Consumes and returns the body as an Uint8Array
+   *  https://fetch.spec.whatwg.org/#dom-body-bytes
+   */
+  bytes (): Promise<Uint8Array>
+
+  /** Consumes and returns the body as an ArrayBuffer
+   *  https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+   */
+  arrayBuffer (): Promise<ArrayBuffer>
+
+  /** Not implemented
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-formdata
+   */
+  formData (): Promise<never>
+
+  /** Returns true if the body is not null and the body has been consumed
+   *
+   *  Otherwise, returns false
+   *
+   * https://fetch.spec.whatwg.org/#dom-body-bodyused
+   */
+  readonly bodyUsed: boolean
+
+  /**
+   * If body is null, it should return null as the body
+   *
+   *  If body is not null, should return the body as a ReadableStream
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-body
+   */
+  readonly body: never | undefined
+
+  /** Dumps the response body by reading `limit` number of bytes.
+   * @param opts.limit Number of bytes to read (optional) - Default: 131072
+   * @param opts.signal AbortSignal to cancel the operation (optional)
+   */
+  dump (opts?: { limit: number; signal?: AbortSignal }): Promise<void>
+}

package/skills/adspecs-export-word/references/node_modules/undici-types/retry-agent.d.ts

@@ -0,0 +1,8 @@
+import Dispatcher from './dispatcher'
+import RetryHandler from './retry-handler'
+
+export default RetryAgent
+
+declare class RetryAgent extends Dispatcher {
+  constructor (dispatcher: Dispatcher, options?: RetryHandler.RetryOptions)
+}

package/skills/adspecs-export-word/references/node_modules/undici-types/retry-handler.d.ts

@@ -0,0 +1,125 @@
+import Dispatcher from './dispatcher'
+
+export default RetryHandler
+
+declare class RetryHandler implements Dispatcher.DispatchHandler {
+  constructor (
+    options: Dispatcher.DispatchOptions & {
+      retryOptions?: RetryHandler.RetryOptions;
+    },
+    retryHandlers: RetryHandler.RetryHandlers
+  )
+}
+
+declare namespace RetryHandler {
+  export type RetryState = { counter: number; }
+
+  export type RetryContext = {
+    state: RetryState;
+    opts: Dispatcher.DispatchOptions & {
+      retryOptions?: RetryHandler.RetryOptions;
+    };
+  }
+
+  export type OnRetryCallback = (result?: Error | null) => void
+
+  export type RetryCallback = (
+    err: Error,
+    context: {
+      state: RetryState;
+      opts: Dispatcher.DispatchOptions & {
+        retryOptions?: RetryHandler.RetryOptions;
+      };
+    },
+    callback: OnRetryCallback
+  ) => void
+
+  export interface RetryOptions {
+    /**
+     * If true, the retry handler will throw an error if the request fails,
+     * this will prevent the folling handlers from being called, and will destroy the socket.
+     *
+     * @type {boolean}
+     * @memberof RetryOptions
+     * @default true
+     */
+    throwOnError?: boolean;
+    /**
+     * Callback to be invoked on every retry iteration.
+     * It receives the error, current state of the retry object and the options object
+     * passed when instantiating the retry handler.
+     *
+     * @type {RetryCallback}
+     * @memberof RetryOptions
+     */
+    retry?: RetryCallback;
+    /**
+     * Maximum number of retries to allow.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 5
+     */
+    maxRetries?: number;
+    /**
+     * Max number of milliseconds allow between retries
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 30000
+     */
+    maxTimeout?: number;
+    /**
+     * Initial number of milliseconds to wait before retrying for the first time.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 500
+     */
+    minTimeout?: number;
+    /**
+     * Factior to multiply the timeout factor between retries.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 2
+     */
+    timeoutFactor?: number;
+    /**
+     * It enables to automatically infer timeout between retries based on the `Retry-After` header.
+     *
+     * @type {boolean}
+     * @memberof RetryOptions
+     * @default true
+     */
+    retryAfter?: boolean;
+    /**
+     * HTTP methods to retry.
+     *
+     * @type {Dispatcher.HttpMethod[]}
+     * @memberof RetryOptions
+     * @default ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE'],
+     */
+    methods?: Dispatcher.HttpMethod[];
+    /**
+     * Error codes to be retried. e.g. `ECONNRESET`, `ENOTFOUND`, `ETIMEDOUT`, `ECONNREFUSED`, etc.
+     *
+     * @type {string[]}
+     * @default ['ECONNRESET','ECONNREFUSED','ENOTFOUND','ENETDOWN','ENETUNREACH','EHOSTDOWN','EHOSTUNREACH','EPIPE']
+     */
+    errorCodes?: string[];
+    /**
+     * HTTP status codes to be retried.
+     *
+     * @type {number[]}
+     * @memberof RetryOptions
+     * @default [500, 502, 503, 504, 429],
+     */
+    statusCodes?: number[];
+  }
+
+  export interface RetryHandlers {
+    dispatch: Dispatcher['dispatch'];
+    handler: Dispatcher.DispatchHandler;
+  }
+}

package/skills/adspecs-export-word/references/node_modules/undici-types/round-robin-pool.d.ts

@@ -0,0 +1,41 @@
+import Client from './client'
+import TPoolStats from './pool-stats'
+import { URL } from 'node:url'
+import Dispatcher from './dispatcher'
+
+export default RoundRobinPool
+
+type RoundRobinPoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+
+declare class RoundRobinPool extends Dispatcher {
+  constructor (url: string | URL, options?: RoundRobinPool.Options)
+  /** `true` after `pool.close()` has been called. */
+  closed: boolean
+  /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
+  destroyed: boolean
+  /** Aggregate stats for a RoundRobinPool. */
+  readonly stats: TPoolStats
+
+  // Override dispatcher APIs.
+  override connect (
+    options: RoundRobinPoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
+    options: RoundRobinPoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void
+}
+
+declare namespace RoundRobinPool {
+  export type RoundRobinPoolStats = TPoolStats
+  export interface Options extends Client.Options {
+    /** Default: `(origin, opts) => new Client(origin, opts)`. */
+    factory?(origin: URL, opts: object): Dispatcher;
+    /** The max number of clients to create. `null` if no limit. Default `null`. */
+    connections?: number | null;
+    /** The amount of time before a client is removed from the pool and closed. `null` if no time limit. Default `null` */
+    clientTtl?: number | null;
+
+    interceptors?: { RoundRobinPool?: readonly Dispatcher.DispatchInterceptor[] } & Client.Options['interceptors']
+  }
+}

package/skills/adspecs-export-word/references/node_modules/undici-types/snapshot-agent.d.ts

@@ -0,0 +1,109 @@
+import MockAgent from './mock-agent'
+
+declare class SnapshotRecorder {
+  constructor (options?: SnapshotRecorder.Options)
+
+  record (requestOpts: any, response: any): Promise<void>
+  findSnapshot (requestOpts: any): SnapshotRecorder.Snapshot | undefined
+  loadSnapshots (filePath?: string): Promise<void>
+  saveSnapshots (filePath?: string): Promise<void>
+  clear (): void
+  getSnapshots (): SnapshotRecorder.Snapshot[]
+  size (): number
+  resetCallCounts (): void
+  deleteSnapshot (requestOpts: any): boolean
+  getSnapshotInfo (requestOpts: any): SnapshotRecorder.SnapshotInfo | null
+  replaceSnapshots (snapshotData: SnapshotRecorder.SnapshotData[]): void
+  destroy (): void
+}
+
+declare namespace SnapshotRecorder {
+  type SnapshotRecorderMode = 'record' | 'playback' | 'update'
+
+  export interface Options {
+    snapshotPath?: string
+    mode?: SnapshotRecorderMode
+    maxSnapshots?: number
+    autoFlush?: boolean
+    flushInterval?: number
+    matchHeaders?: string[]
+    ignoreHeaders?: string[]
+    excludeHeaders?: string[]
+    matchBody?: boolean
+    matchQuery?: boolean
+    caseSensitive?: boolean
+    shouldRecord?: (requestOpts: any) => boolean
+    shouldPlayback?: (requestOpts: any) => boolean
+    excludeUrls?: (string | RegExp)[]
+  }
+
+  export interface Snapshot {
+    request: {
+      method: string
+      url: string
+      headers: Record<string, string>
+      body?: string
+    }
+    responses: {
+      statusCode: number
+      headers: Record<string, string>
+      body: string
+      trailers: Record<string, string>
+    }[]
+    callCount: number
+    timestamp: string
+  }
+
+  export interface SnapshotInfo {
+    hash: string
+    request: {
+      method: string
+      url: string
+      headers: Record<string, string>
+      body?: string
+    }
+    responseCount: number
+    callCount: number
+    timestamp: string
+  }
+
+  export interface SnapshotData {
+    hash: string
+    snapshot: Snapshot
+  }
+}
+
+declare class SnapshotAgent extends MockAgent {
+  constructor (options?: SnapshotAgent.Options)
+
+  saveSnapshots (filePath?: string): Promise<void>
+  loadSnapshots (filePath?: string): Promise<void>
+  getRecorder (): SnapshotRecorder
+  getMode (): SnapshotRecorder.SnapshotRecorderMode
+  clearSnapshots (): void
+  resetCallCounts (): void
+  deleteSnapshot (requestOpts: any): boolean
+  getSnapshotInfo (requestOpts: any): SnapshotRecorder.SnapshotInfo | null
+  replaceSnapshots (snapshotData: SnapshotRecorder.SnapshotData[]): void
+}
+
+declare namespace SnapshotAgent {
+  export interface Options extends MockAgent.Options {
+    mode?: SnapshotRecorder.SnapshotRecorderMode
+    snapshotPath?: string
+    maxSnapshots?: number
+    autoFlush?: boolean
+    flushInterval?: number
+    matchHeaders?: string[]
+    ignoreHeaders?: string[]
+    excludeHeaders?: string[]
+    matchBody?: boolean
+    matchQuery?: boolean
+    caseSensitive?: boolean
+    shouldRecord?: (requestOpts: any) => boolean
+    shouldPlayback?: (requestOpts: any) => boolean
+    excludeUrls?: (string | RegExp)[]
+  }
+}
+
+export { SnapshotAgent, SnapshotRecorder }

package/skills/adspecs-export-word/references/node_modules/undici-types/socks5-proxy-agent.d.ts

@@ -0,0 +1,25 @@
+import Dispatcher from './dispatcher'
+import buildConnector from './connector'
+import { IncomingHttpHeaders } from './header'
+import Pool from './pool'
+
+export default Socks5ProxyAgent
+
+declare class Socks5ProxyAgent extends Dispatcher {
+  constructor (proxyUrl: string | URL, options?: Socks5ProxyAgent.Options)
+}
+
+declare namespace Socks5ProxyAgent {
+  export interface Options extends Pool.Options {
+    /** Additional headers to send with the proxy connection */
+    headers?: IncomingHttpHeaders;
+    /** SOCKS5 proxy username for authentication */
+    username?: string;
+    /** SOCKS5 proxy password for authentication */
+    password?: string;
+    /** Custom connector function for proxy connection */
+    connect?: buildConnector.connector;
+    /** TLS options for the proxy connection (for SOCKS5 over TLS) */
+    proxyTls?: buildConnector.BuildOptions;
+  }
+}

package/skills/adspecs-export-word/references/node_modules/undici-types/util.d.ts

@@ -0,0 +1,18 @@
+export namespace util {
+  /**
+   * Retrieves a header name and returns its lowercase value.
+   * @param value Header name
+   */
+  export function headerNameToString (value: string | Buffer): string
+
+  /**
+   * Receives a header object and returns the parsed value.
+   * @param headers Header object
+   * @param obj Object to specify a proxy object. Used to assign parsed values.
+   * @returns If `obj` is specified, it is equivalent to `obj`.
+   */
+  export function parseHeaders (
+    headers: (Buffer | string | (Buffer | string)[])[],
+    obj?: Record<string, string | string[]>
+  ): Record<string, string | string[]>
+}

package/skills/adspecs-export-word/references/node_modules/undici-types/utility.d.ts

@@ -0,0 +1,7 @@
+type AutocompletePrimitiveBaseType<T> =
+  T extends string ? string :
+    T extends number ? number :
+      T extends boolean ? boolean :
+        never
+
+export type Autocomplete<T> = T | (AutocompletePrimitiveBaseType<T> & Record<never, never>)