@tiendung-36/openrouter-cli 1.0.0

package/node_modules/openai/src/internal/decoders/line.ts

@@ -0,0 +1,176 @@
+import { OpenAIError } from '../../error';
+
+export type Bytes = string | ArrayBuffer | Uint8Array | Buffer | null | undefined;
+
+/**
+ * A re-implementation of httpx's `LineDecoder` in Python that handles incrementally
+ * reading lines from text.
+ *
+ * https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258
+ */
+export class LineDecoder {
+  // prettier-ignore
+  static NEWLINE_CHARS = new Set(['\n', '\r']);
+  static NEWLINE_REGEXP = /\r\n|[\n\r]/g;
+
+  buffer: Uint8Array;
+  #carriageReturnIndex: number | null;
+  textDecoder: any; // TextDecoder found in browsers; not typed to avoid pulling in either "dom" or "node" types.
+
+  constructor() {
+    this.buffer = new Uint8Array();
+    this.#carriageReturnIndex = null;
+  }
+
+  decode(chunk: Bytes): string[] {
+    if (chunk == null) {
+      return [];
+    }
+
+    const binaryChunk =
+      chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
+      : typeof chunk === 'string' ? new TextEncoder().encode(chunk)
+      : chunk;
+
+    let newData = new Uint8Array(this.buffer.length + binaryChunk.length);
+    newData.set(this.buffer);
+    newData.set(binaryChunk, this.buffer.length);
+    this.buffer = newData;
+
+    const lines: string[] = [];
+    let patternIndex;
+    while ((patternIndex = findNewlineIndex(this.buffer, this.#carriageReturnIndex)) != null) {
+      if (patternIndex.carriage && this.#carriageReturnIndex == null) {
+        // skip until we either get a corresponding `\n`, a new `\r` or nothing
+        this.#carriageReturnIndex = patternIndex.index;
+        continue;
+      }
+
+      // we got double \r or \rtext\n
+      if (
+        this.#carriageReturnIndex != null &&
+        (patternIndex.index !== this.#carriageReturnIndex + 1 || patternIndex.carriage)
+      ) {
+        lines.push(this.decodeText(this.buffer.slice(0, this.#carriageReturnIndex - 1)));
+        this.buffer = this.buffer.slice(this.#carriageReturnIndex);
+        this.#carriageReturnIndex = null;
+        continue;
+      }
+
+      const endIndex =
+        this.#carriageReturnIndex !== null ? patternIndex.preceding - 1 : patternIndex.preceding;
+
+      const line = this.decodeText(this.buffer.slice(0, endIndex));
+      lines.push(line);
+
+      this.buffer = this.buffer.slice(patternIndex.index);
+      this.#carriageReturnIndex = null;
+    }
+
+    return lines;
+  }
+
+  decodeText(bytes: Bytes): string {
+    if (bytes == null) return '';
+    if (typeof bytes === 'string') return bytes;
+
+    // Node:
+    if (typeof Buffer !== 'undefined') {
+      if (bytes instanceof Buffer) {
+        return bytes.toString();
+      }
+      if (bytes instanceof Uint8Array) {
+        return Buffer.from(bytes).toString();
+      }
+
+      throw new OpenAIError(
+        `Unexpected: received non-Uint8Array (${bytes.constructor.name}) stream chunk in an environment with a global "Buffer" defined, which this library assumes to be Node. Please report this error.`,
+      );
+    }
+
+    // Browser
+    if (typeof TextDecoder !== 'undefined') {
+      if (bytes instanceof Uint8Array || bytes instanceof ArrayBuffer) {
+        this.textDecoder ??= new TextDecoder('utf8');
+        return this.textDecoder.decode(bytes);
+      }
+
+      throw new OpenAIError(
+        `Unexpected: received non-Uint8Array/ArrayBuffer (${
+          (bytes as any).constructor.name
+        }) in a web platform. Please report this error.`,
+      );
+    }
+
+    throw new OpenAIError(
+      `Unexpected: neither Buffer nor TextDecoder are available as globals. Please report this error.`,
+    );
+  }
+
+  flush(): string[] {
+    if (!this.buffer.length) {
+      return [];
+    }
+    return this.decode('\n');
+  }
+}
+
+/**
+ * This function searches the buffer for the end patterns, (\r or \n)
+ * and returns an object with the index preceding the matched newline and the
+ * index after the newline char. `null` is returned if no new line is found.
+ *
+ * ```ts
+ * findNewLineIndex('abc\ndef') -> { preceding: 2, index: 3 }
+ * ```
+ */
+function findNewlineIndex(
+  buffer: Uint8Array,
+  startIndex: number | null,
+): { preceding: number; index: number; carriage: boolean } | null {
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  for (let i = startIndex ?? 0; i < buffer.length; i++) {
+    if (buffer[i] === newline) {
+      return { preceding: i, index: i + 1, carriage: false };
+    }
+
+    if (buffer[i] === carriage) {
+      return { preceding: i, index: i + 1, carriage: true };
+    }
+  }
+
+  return null;
+}
+
+export function findDoubleNewlineIndex(buffer: Uint8Array): number {
+  // This function searches the buffer for the end patterns (\r\r, \n\n, \r\n\r\n)
+  // and returns the index right after the first occurrence of any pattern,
+  // or -1 if none of the patterns are found.
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  for (let i = 0; i < buffer.length - 1; i++) {
+    if (buffer[i] === newline && buffer[i + 1] === newline) {
+      // \n\n
+      return i + 2;
+    }
+    if (buffer[i] === carriage && buffer[i + 1] === carriage) {
+      // \r\r
+      return i + 2;
+    }
+    if (
+      buffer[i] === carriage &&
+      buffer[i + 1] === newline &&
+      i + 3 < buffer.length &&
+      buffer[i + 2] === carriage &&
+      buffer[i + 3] === newline
+    ) {
+      // \r\n\r\n
+      return i + 4;
+    }
+  }
+
+  return -1;
+}

package/node_modules/openai/src/internal/qs/LICENSE.md

@@ -0,0 +1,13 @@
+BSD 3-Clause License
+
+Copyright (c) 2014, Nathan LaFreniere and other [contributors](https://github.com/puruvj/neoqs/graphs/contributors) All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/node_modules/openai/src/internal/qs/README.md

@@ -0,0 +1,3 @@
+# qs
+
+This is a vendored version of [neoqs](https://github.com/PuruVJ/neoqs) which is a TypeScript rewrite of [qs](https://github.com/ljharb/qs), a query string library.

package/node_modules/openai/src/internal/qs/formats.ts

@@ -0,0 +1,9 @@
+import type { Format } from './types';
+
+export const default_format: Format = 'RFC3986';
+export const formatters: Record<Format, (str: PropertyKey) => string> = {
+  RFC1738: (v: PropertyKey) => String(v).replace(/%20/g, '+'),
+  RFC3986: (v: PropertyKey) => String(v),
+};
+export const RFC1738 = 'RFC1738';
+export const RFC3986 = 'RFC3986';

package/node_modules/openai/src/internal/qs/index.ts

@@ -0,0 +1,13 @@
+import { default_format, formatters, RFC1738, RFC3986 } from './formats';
+
+const formats = {
+  formatters,
+  RFC1738,
+  RFC3986,
+  default: default_format,
+};
+
+export { stringify } from './stringify';
+export { formats };
+
+export type { DefaultDecoder, DefaultEncoder, Format, ParseOptions, StringifyOptions } from './types';

package/node_modules/openai/src/internal/qs/stringify.ts

@@ -0,0 +1,388 @@
+import { encode, is_buffer, maybe_map } from './utils';
+import { default_format, formatters } from './formats';
+import type { NonNullableProperties, StringifyOptions } from './types';
+
+const has = Object.prototype.hasOwnProperty;
+
+const array_prefix_generators = {
+  brackets(prefix: PropertyKey) {
+    return String(prefix) + '[]';
+  },
+  comma: 'comma',
+  indices(prefix: PropertyKey, key: string) {
+    return String(prefix) + '[' + key + ']';
+  },
+  repeat(prefix: PropertyKey) {
+    return String(prefix);
+  },
+};
+
+const is_array = Array.isArray;
+const push = Array.prototype.push;
+const push_to_array = function (arr: any[], value_or_array: any) {
+  push.apply(arr, is_array(value_or_array) ? value_or_array : [value_or_array]);
+};
+
+const to_ISO = Date.prototype.toISOString;
+
+const defaults = {
+  addQueryPrefix: false,
+  allowDots: false,
+  allowEmptyArrays: false,
+  arrayFormat: 'indices',
+  charset: 'utf-8',
+  charsetSentinel: false,
+  delimiter: '&',
+  encode: true,
+  encodeDotInKeys: false,
+  encoder: encode,
+  encodeValuesOnly: false,
+  format: default_format,
+  formatter: formatters[default_format],
+  /** @deprecated */
+  indices: false,
+  serializeDate(date) {
+    return to_ISO.call(date);
+  },
+  skipNulls: false,
+  strictNullHandling: false,
+} as NonNullableProperties<StringifyOptions & { formatter: (typeof formatters)['RFC1738'] }>;
+
+function is_non_nullish_primitive(v: unknown): v is string | number | boolean | symbol | bigint {
+  return (
+    typeof v === 'string' ||
+    typeof v === 'number' ||
+    typeof v === 'boolean' ||
+    typeof v === 'symbol' ||
+    typeof v === 'bigint'
+  );
+}
+
+const sentinel = {};
+
+function inner_stringify(
+  object: any,
+  prefix: PropertyKey,
+  generateArrayPrefix: StringifyOptions['arrayFormat'] | ((prefix: string, key: string) => string),
+  commaRoundTrip: boolean,
+  allowEmptyArrays: boolean,
+  strictNullHandling: boolean,
+  skipNulls: boolean,
+  encodeDotInKeys: boolean,
+  encoder: StringifyOptions['encoder'],
+  filter: StringifyOptions['filter'],
+  sort: StringifyOptions['sort'],
+  allowDots: StringifyOptions['allowDots'],
+  serializeDate: StringifyOptions['serializeDate'],
+  format: StringifyOptions['format'],
+  formatter: StringifyOptions['formatter'],
+  encodeValuesOnly: boolean,
+  charset: StringifyOptions['charset'],
+  sideChannel: WeakMap<any, any>,
+) {
+  let obj = object;
+
+  let tmp_sc = sideChannel;
+  let step = 0;
+  let find_flag = false;
+  while ((tmp_sc = tmp_sc.get(sentinel)) !== void undefined && !find_flag) {
+    // Where object last appeared in the ref tree
+    const pos = tmp_sc.get(object);
+    step += 1;
+    if (typeof pos !== 'undefined') {
+      if (pos === step) {
+        throw new RangeError('Cyclic object value');
+      } else {
+        find_flag = true; // Break while
+      }
+    }
+    if (typeof tmp_sc.get(sentinel) === 'undefined') {
+      step = 0;
+    }
+  }
+
+  if (typeof filter === 'function') {
+    obj = filter(prefix, obj);
+  } else if (obj instanceof Date) {
+    obj = serializeDate?.(obj);
+  } else if (generateArrayPrefix === 'comma' && is_array(obj)) {
+    obj = maybe_map(obj, function (value) {
+      if (value instanceof Date) {
+        return serializeDate?.(value);
+      }
+      return value;
+    });
+  }
+
+  if (obj === null) {
+    if (strictNullHandling) {
+      return encoder && !encodeValuesOnly ?
+          // @ts-expect-error
+          encoder(prefix, defaults.encoder, charset, 'key', format)
+        : prefix;
+    }
+
+    obj = '';
+  }
+
+  if (is_non_nullish_primitive(obj) || is_buffer(obj)) {
+    if (encoder) {
+      const key_value =
+        encodeValuesOnly ? prefix
+          // @ts-expect-error
+        : encoder(prefix, defaults.encoder, charset, 'key', format);
+      return [
+        formatter?.(key_value) +
+          '=' +
+          // @ts-expect-error
+          formatter?.(encoder(obj, defaults.encoder, charset, 'value', format)),
+      ];
+    }
+    return [formatter?.(prefix) + '=' + formatter?.(String(obj))];
+  }
+
+  const values: string[] = [];
+
+  if (typeof obj === 'undefined') {
+    return values;
+  }
+
+  let obj_keys;
+  if (generateArrayPrefix === 'comma' && is_array(obj)) {
+    // we need to join elements in
+    if (encodeValuesOnly && encoder) {
+      // @ts-expect-error values only
+      obj = maybe_map(obj, encoder);
+    }
+    obj_keys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
+  } else if (is_array(filter)) {
+    obj_keys = filter;
+  } else {
+    const keys = Object.keys(obj);
+    obj_keys = sort ? keys.sort(sort) : keys;
+  }
+
+  const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, '%2E') : String(prefix);
+
+  const adjusted_prefix =
+    commaRoundTrip && is_array(obj) && obj.length === 1 ? encoded_prefix + '[]' : encoded_prefix;
+
+  if (allowEmptyArrays && is_array(obj) && obj.length === 0) {
+    return adjusted_prefix + '[]';
+  }
+
+  for (let j = 0; j < obj_keys.length; ++j) {
+    const key = obj_keys[j];
+    const value =
+      // @ts-ignore
+      typeof key === 'object' && typeof key.value !== 'undefined' ? key.value : obj[key as any];
+
+    if (skipNulls && value === null) {
+      continue;
+    }
+
+    // @ts-ignore
+    const encoded_key = allowDots && encodeDotInKeys ? (key as any).replace(/\./g, '%2E') : key;
+    const key_prefix =
+      is_array(obj) ?
+        typeof generateArrayPrefix === 'function' ?
+          generateArrayPrefix(adjusted_prefix, encoded_key)
+        : adjusted_prefix
+      : adjusted_prefix + (allowDots ? '.' + encoded_key : '[' + encoded_key + ']');
+
+    sideChannel.set(object, step);
+    const valueSideChannel = new WeakMap();
+    valueSideChannel.set(sentinel, sideChannel);
+    push_to_array(
+      values,
+      inner_stringify(
+        value,
+        key_prefix,
+        generateArrayPrefix,
+        commaRoundTrip,
+        allowEmptyArrays,
+        strictNullHandling,
+        skipNulls,
+        encodeDotInKeys,
+        // @ts-ignore
+        generateArrayPrefix === 'comma' && encodeValuesOnly && is_array(obj) ? null : encoder,
+        filter,
+        sort,
+        allowDots,
+        serializeDate,
+        format,
+        formatter,
+        encodeValuesOnly,
+        charset,
+        valueSideChannel,
+      ),
+    );
+  }
+
+  return values;
+}
+
+function normalize_stringify_options(
+  opts: StringifyOptions = defaults,
+): NonNullableProperties<Omit<StringifyOptions, 'indices'>> & { indices?: boolean } {
+  if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {
+    throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');
+  }
+
+  if (typeof opts.encodeDotInKeys !== 'undefined' && typeof opts.encodeDotInKeys !== 'boolean') {
+    throw new TypeError('`encodeDotInKeys` option can only be `true` or `false`, when provided');
+  }
+
+  if (opts.encoder !== null && typeof opts.encoder !== 'undefined' && typeof opts.encoder !== 'function') {
+    throw new TypeError('Encoder has to be a function.');
+  }
+
+  const charset = opts.charset || defaults.charset;
+  if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
+    throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
+  }
+
+  let format = default_format;
+  if (typeof opts.format !== 'undefined') {
+    if (!has.call(formatters, opts.format)) {
+      throw new TypeError('Unknown format option provided.');
+    }
+    format = opts.format;
+  }
+  const formatter = formatters[format];
+
+  let filter = defaults.filter;
+  if (typeof opts.filter === 'function' || is_array(opts.filter)) {
+    filter = opts.filter;
+  }
+
+  let arrayFormat: StringifyOptions['arrayFormat'];
+  if (opts.arrayFormat && opts.arrayFormat in array_prefix_generators) {
+    arrayFormat = opts.arrayFormat;
+  } else if ('indices' in opts) {
+    arrayFormat = opts.indices ? 'indices' : 'repeat';
+  } else {
+    arrayFormat = defaults.arrayFormat;
+  }
+
+  if ('commaRoundTrip' in opts && typeof opts.commaRoundTrip !== 'boolean') {
+    throw new TypeError('`commaRoundTrip` must be a boolean, or absent');
+  }
+
+  const allowDots =
+    typeof opts.allowDots === 'undefined' ?
+      !!opts.encodeDotInKeys === true ?
+        true
+      : defaults.allowDots
+    : !!opts.allowDots;
+
+  return {
+    addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix,
+    // @ts-ignore
+    allowDots: allowDots,
+    allowEmptyArrays:
+      typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
+    arrayFormat: arrayFormat,
+    charset: charset,
+    charsetSentinel:
+      typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
+    commaRoundTrip: !!opts.commaRoundTrip,
+    delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,
+    encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,
+    encodeDotInKeys:
+      typeof opts.encodeDotInKeys === 'boolean' ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
+    encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,
+    encodeValuesOnly:
+      typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
+    filter: filter,
+    format: format,
+    formatter: formatter,
+    serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate,
+    skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls,
+    // @ts-ignore
+    sort: typeof opts.sort === 'function' ? opts.sort : null,
+    strictNullHandling:
+      typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling,
+  };
+}
+
+export function stringify(object: any, opts: StringifyOptions = {}) {
+  let obj = object;
+  const options = normalize_stringify_options(opts);
+
+  let obj_keys: PropertyKey[] | undefined;
+  let filter;
+
+  if (typeof options.filter === 'function') {
+    filter = options.filter;
+    obj = filter('', obj);
+  } else if (is_array(options.filter)) {
+    filter = options.filter;
+    obj_keys = filter;
+  }
+
+  const keys: string[] = [];
+
+  if (typeof obj !== 'object' || obj === null) {
+    return '';
+  }
+
+  const generateArrayPrefix = array_prefix_generators[options.arrayFormat];
+  const commaRoundTrip = generateArrayPrefix === 'comma' && options.commaRoundTrip;
+
+  if (!obj_keys) {
+    obj_keys = Object.keys(obj);
+  }
+
+  if (options.sort) {
+    obj_keys.sort(options.sort);
+  }
+
+  const sideChannel = new WeakMap();
+  for (let i = 0; i < obj_keys.length; ++i) {
+    const key = obj_keys[i]!;
+
+    if (options.skipNulls && obj[key] === null) {
+      continue;
+    }
+    push_to_array(
+      keys,
+      inner_stringify(
+        obj[key],
+        key,
+        // @ts-expect-error
+        generateArrayPrefix,
+        commaRoundTrip,
+        options.allowEmptyArrays,
+        options.strictNullHandling,
+        options.skipNulls,
+        options.encodeDotInKeys,
+        options.encode ? options.encoder : null,
+        options.filter,
+        options.sort,
+        options.allowDots,
+        options.serializeDate,
+        options.format,
+        options.formatter,
+        options.encodeValuesOnly,
+        options.charset,
+        sideChannel,
+      ),
+    );
+  }
+
+  const joined = keys.join(options.delimiter);
+  let prefix = options.addQueryPrefix === true ? '?' : '';
+
+  if (options.charsetSentinel) {
+    if (options.charset === 'iso-8859-1') {
+      // encodeURIComponent('&#10003;'), the "numeric entity" representation of a checkmark
+      prefix += 'utf8=%26%2310003%3B&';
+    } else {
+      // encodeURIComponent('✓')
+      prefix += 'utf8=%E2%9C%93&';
+    }
+  }
+
+  return joined.length > 0 ? prefix + joined : '';
+}

package/node_modules/openai/src/internal/qs/types.ts

@@ -0,0 +1,71 @@
+export type Format = 'RFC1738' | 'RFC3986';
+
+export type DefaultEncoder = (str: any, defaultEncoder?: any, charset?: string) => string;
+export type DefaultDecoder = (str: string, decoder?: any, charset?: string) => string;
+
+export type BooleanOptional = boolean | undefined;
+
+export type StringifyBaseOptions = {
+  delimiter?: string;
+  allowDots?: boolean;
+  encodeDotInKeys?: boolean;
+  strictNullHandling?: boolean;
+  skipNulls?: boolean;
+  encode?: boolean;
+  encoder?: (
+    str: any,
+    defaultEncoder: DefaultEncoder,
+    charset: string,
+    type: 'key' | 'value',
+    format?: Format,
+  ) => string;
+  filter?: Array<PropertyKey> | ((prefix: PropertyKey, value: any) => any);
+  arrayFormat?: 'indices' | 'brackets' | 'repeat' | 'comma';
+  indices?: boolean;
+  sort?: ((a: PropertyKey, b: PropertyKey) => number) | null;
+  serializeDate?: (d: Date) => string;
+  format?: 'RFC1738' | 'RFC3986';
+  formatter?: (str: PropertyKey) => string;
+  encodeValuesOnly?: boolean;
+  addQueryPrefix?: boolean;
+  charset?: 'utf-8' | 'iso-8859-1';
+  charsetSentinel?: boolean;
+  allowEmptyArrays?: boolean;
+  commaRoundTrip?: boolean;
+};
+
+export type StringifyOptions = StringifyBaseOptions;
+
+export type ParseBaseOptions = {
+  comma?: boolean;
+  delimiter?: string | RegExp;
+  depth?: number | false;
+  decoder?: (str: string, defaultDecoder: DefaultDecoder, charset: string, type: 'key' | 'value') => any;
+  arrayLimit?: number;
+  parseArrays?: boolean;
+  plainObjects?: boolean;
+  allowPrototypes?: boolean;
+  allowSparse?: boolean;
+  parameterLimit?: number;
+  strictDepth?: boolean;
+  strictNullHandling?: boolean;
+  ignoreQueryPrefix?: boolean;
+  charset?: 'utf-8' | 'iso-8859-1';
+  charsetSentinel?: boolean;
+  interpretNumericEntities?: boolean;
+  allowEmptyArrays?: boolean;
+  duplicates?: 'combine' | 'first' | 'last';
+  allowDots?: boolean;
+  decodeDotInKeys?: boolean;
+};
+
+export type ParseOptions = ParseBaseOptions;
+
+export type ParsedQs = {
+  [key: string]: undefined | string | string[] | ParsedQs | ParsedQs[];
+};
+
+// Type to remove null or undefined union from each property
+export type NonNullableProperties<T> = {
+  [K in keyof T]-?: Exclude<T[K], undefined | null>;
+};