@psnext/slingcli 3.5.20261007-2 → 3.5.20261019-1

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/codec-v1/JsonShapeSerializer.d.ts

@@ -0,0 +1,29 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import { Schema, ShapeSerializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { JsonSettings } from "./JsonSettings";
+/**
+ * @deprecated prefer byte-targeting JsonShapeSerializer or its string adapter StringJsonShapeSerializer in codec-v2.
+ * @public
+ */
+export declare class JsonShapeSerializer extends SerdeContextConfig implements ShapeSerializer<string> {
+    readonly settings: JsonSettings;
+    /**
+     * Write buffer. Reused per value serialization pass.
+     * In the initial implementation, this is not an incremental buffer.
+     */
+    protected buffer: any;
+    protected useReplacer: boolean;
+    protected rootSchema: NormalizedSchema | undefined;
+    constructor(settings: JsonSettings);
+    write(schema: Schema, value: unknown): void;
+    flush(): string;
+    /**
+     * @internal
+     */
+    writeDiscriminatedDocument(schema: Schema, value: unknown): void;
+    /**
+     * Order if-statements by likelihood.
+     */
+    protected _write(schema: Schema, value: unknown, container?: NormalizedSchema): any;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/codec-v2/JsonBytesStringAdapter.d.ts

@@ -0,0 +1,51 @@
+/**
+ * A Uint8Array subclass holding serialized JSON bytes that provides
+ * string method compatibility for customer middleware.
+ *
+ * Middleware historically observed `request.body` as a string for JSON
+ * protocol services. This class preserves that contract: string methods
+ * and coercion (template literals, `+` operator) lazily decode the bytes
+ * to a cached string. The HTTP transport layer still sees a Uint8Array
+ * and sends raw bytes without conversion.
+ *
+ * @internal
+ * @deprecated this adapter will be removed in a future version.
+ */
+export declare class JsonBytesStringAdapter extends Uint8Array {
+    private string;
+    static allocUnsafe(bytes: number): JsonBytesStringAdapter;
+    /**
+     * Enables string coercion via template literals and `+` operator.
+     */
+    toString(): string;
+    /**
+     * Enables string coercion in comparison and arithmetic contexts.
+     * @returns a string. The signature is set to avoid incompatibility with extending Uint8Array.
+     */
+    valueOf(): any;
+    includes(searchString: string | number, position?: number): boolean;
+    indexOf(searchString: string | number, position?: number): number;
+    lastIndexOf(searchString: string | number, position?: number): number;
+    startsWith(searchString: string, position?: number): boolean;
+    endsWith(searchString: string, endPosition?: number): boolean;
+    match(regexp: string | RegExp): RegExpMatchArray | null;
+    replace(searchValue: string | RegExp, replaceValue: string): string;
+    search(regexp: string | RegExp): number;
+    split(separator: string | RegExp, limit?: number): string[];
+    substring(start: number, end?: number): string;
+    trim(): string;
+    trimStart(): string;
+    trimEnd(): string;
+    charAt(pos: number): string;
+    charCodeAt(index: number): number;
+    padStart(maxLength: number, fillString?: string): string;
+    padEnd(maxLength: number, fillString?: string): string;
+    repeat(count: number): string;
+    toUpperCase(): string;
+    toLowerCase(): string;
+    /**
+     * Decodes the bytes to a UTF-8 string on first access, then caches.
+     * Subsequent calls return the cached string with zero cost.
+     */
+    private s;
+}

package/node_modules/{@aws-sdk → @smithy}/core/dist-types/ts3.4/submodules/protocols/json/codec-v2/JsonCodec2.d.ts

@@ -1,9 +1,13 @@
-import { $ShapeSerializer, $Codec, $ShapeDeserializer } from "@smithy/types";
-import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
-import { JsonSettings } from "../JsonSettings";
-export declare class JsonCodec2 extends SerdeContextConfig implements $Codec<Uint8Array, string> {
-  readonly settings: JsonSettings;
-  constructor(settings: JsonSettings);
-  createSerializer(): $ShapeSerializer<Uint8Array>;
-  createDeserializer(): $ShapeDeserializer<string>;
-}
+import { $ShapeSerializer, $Codec, $ShapeDeserializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { JsonSettings } from "../JsonSettings";
+/**
+ * Codec grouping the v2 serializer and deserializer.
+ * @public
+ */
+export declare class JsonCodec2 extends SerdeContextConfig implements $Codec<Uint8Array, string> {
+    readonly settings: JsonSettings;
+    constructor(settings: JsonSettings);
+    createSerializer(): $ShapeSerializer<Uint8Array>;
+    createDeserializer(): $ShapeDeserializer<string>;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/codec-v2/JsonShapeDeserializer2.d.ts

@@ -0,0 +1,30 @@
+import { DocumentType, Schema, ShapeDeserializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { JsonSettings } from "../JsonSettings";
+/**
+ * Performance-optimized JSON deserializer.
+ *
+ * Skips UTF-8 decoding when the runtime supports JSON.parse(Buffer) (Node 22+).
+ *
+ * After JSON.parse, lists, maps, and document containers are mutated in place
+ * (element values are overwritten with their deserialized form) rather than
+ * copied into new arrays/objects. Structs allocate a fresh object because
+ * jsonName traits require key renaming, and building the output object
+ * incrementally lets V8 assign a stable hidden class rather than
+ * deoptimizing from repeated property deletion/addition on an existing shape.
+ *
+ * In-place mutation is safe here because the parsed tree is locally owned
+ * after JSON.parse with no external references, so rewriting values avoids
+ * redundant allocation and GC pressure.
+ *
+ * @public
+ */
+export declare class JsonShapeDeserializer2 extends SerdeContextConfig implements ShapeDeserializer<string> {
+    readonly settings: JsonSettings;
+    constructor(settings: JsonSettings);
+    read(schema: Schema, data: string | Uint8Array | unknown): Promise<any>;
+    readObject(schema: Schema, data: DocumentType): any;
+    protected _read(schema: Schema, value: unknown): any;
+    private _readStruct;
+    private needsTransform;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/codec-v2/JsonShapeSerializer2.d.ts

@@ -0,0 +1,60 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import { Schema, ShapeSerializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { JsonSettings } from "../JsonSettings";
+/**
+ * Single-pass JSON serializer that writes directly to a Uint8Array buffer.
+ * Fewer intermediate states as when compared to the initial multi-pass implementation.
+ *
+ * @public
+ */
+export declare class JsonShapeSerializer2 extends SerdeContextConfig implements ShapeSerializer<Uint8Array> {
+    readonly settings: JsonSettings;
+    private json;
+    private i;
+    private rootSchema;
+    private rawValue;
+    private passthrough;
+    constructor(settings: JsonSettings);
+    write(schema: Schema, value: unknown): void;
+    /**
+     * @internal
+     */
+    writeDiscriminatedDocument(schema: Schema, value: unknown): void;
+    /**
+     * Returns the serialized JSON as a Uint8Array (UTF-8 bytes).
+     * This is the primary output — pass directly to request.body.
+     */
+    flush(): Uint8Array;
+    protected ensure(byteCount: number): void;
+    /**
+     * Write a raw ASCII string (no JSON escaping). Used for pre-validated content
+     * like numeric literals and pre-encoded base64.
+     */
+    protected writeAscii(s: string): void;
+    /**
+     * Write a quoted ASCII string with no escape checking.
+     * Used for struct member keys (jsonName or model names) which are
+     * guaranteed to be safe ASCII identifiers. No control chars, quotes,
+     * backslashes, or non-ASCII.
+     * Ensures extra room for surrounding structural chars (comma, colon).
+     */
+    protected writeAsciiQuoted(s: string): void;
+    /**
+     * Write a JSON-escaped string including the surrounding quotes.
+     * Fast-path for ASCII, falls back to TextEncoder for multi-byte.
+     */
+    protected writeJsonString(s: string): void;
+    protected writeUnicodeEscape(code: number): void;
+    protected static readonly B64: Uint8Array;
+    /**
+     * Write a Uint8Array as a quoted base64 string directly into the buffer.
+     * No intermediate JS string, no escape checking (base64 alphabet is safe ASCII).
+     */
+    protected writeBase64(data: Uint8Array): void;
+    protected writeValue(schema: Schema, value: unknown, container: NormalizedSchema | undefined): void;
+    protected writeStruct(ns: NormalizedSchema, value: Record<string, unknown>): void;
+    protected writeList(ns: NormalizedSchema, value: unknown[], isDocument?: boolean): void;
+    protected writeMap(ns: NormalizedSchema, value: Record<string, unknown>, isDocument?: boolean): void;
+    protected writeTimestamp(ns: NormalizedSchema, value: Date): void;
+}

package/node_modules/{@aws-sdk → @smithy}/core/dist-types/ts3.4/submodules/protocols/json/detectBufferParsing.d.ts

@@ -1 +1 @@
-export declare function detectBufferParsing(): boolean;
+export declare function detectBufferParsing(): boolean;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/jsonReplacer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Serializes BigInt and NumericValue to JSON-number.
+ * @internal
+ */
+export declare class JsonReplacer {
+    /**
+     * Stores placeholder key to true serialized value lookup.
+     */
+    private readonly values;
+    private counter;
+    private stage;
+    /**
+     * Creates a jsonReplacer function that reserves big integer and big decimal values
+     * for later replacement.
+     */
+    createReplacer(): (key: string, value: unknown) => unknown;
+    /**
+     * Replaces placeholder keys with their true values.
+     */
+    replaceInJson(json: string): string;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/jsonReviver.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param key - JSON object key.
+ * @param value - parsed value.
+ * @param context - original JSON string for reference. Not available until Node.js 21 and unavailable in Safari as
+ * of April 2025.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#browser_compatibility
+ *
+ * @internal
+ *
+ * @returns transformed value.
+ */
+export declare function jsonReviver(key: string, value: any, context?: {
+    source?: string;
+}): any;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/needsReviver.d.ts

@@ -0,0 +1,11 @@
+import { Schema } from "@smithy/types";
+/**
+ * Determines whether a schema tree contains BigInteger or BigDecimal members,
+ * which require a JSON.parse reviver to preserve numeric precision.
+ *
+ * The result is cached on the root static schema array (struct schemas) via a Symbol key,
+ * so subsequent calls for the same schema are O(1).
+ *
+ * @internal
+ */
+export declare function needsReviver(schema: Schema): boolean;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/parseJsonBody.d.ts

@@ -0,0 +1,38 @@
+import { HttpResponse, Schema, SerdeFunctions } from "@smithy/types";
+/**
+ * @deprecated new calls to parseJsonBody must pass schema.
+ * @internal
+ */
+export declare function parseJsonBody(streamBody: any, context: SerdeFunctions): Promise<any>;
+/**
+ * @internal
+ */
+export declare function parseJsonBody(streamBody: any, context: SerdeFunctions, schema: Schema): Promise<any>;
+/**
+ * @internal
+ */
+export declare const parseJsonErrorBody: (errorBody: any, context: SerdeFunctions) => Promise<any>;
+/**
+ * @internal
+ */
+export declare const loadRestJsonErrorCode: (output: HttpResponse, data: any) => string | undefined;
+/**
+ * @internal
+ */
+export declare const loadJsonRpcErrorCode: (output: HttpResponse, data: any, queryCompat?: boolean) => string | undefined;
+/**
+ * Smithy RPCv2 JSON error identifier loader.
+ *
+ * Unlike {@link loadJsonRpcErrorCode} (used by AWS JSON 1.0/1.1 and restJson1),
+ * this preserves the ABSOLUTE shape id carried in `__type`. The RPCv2 JSON SEP
+ * requires `__type` to contain the fully-qualified shape id, and the protocol
+ * resolves errors by that absolute id to avoid ambiguous resolution when the
+ * same shape name exists in more than one namespace.
+ *
+ * It trims the Smithy-specific `,` fault/tag suffix and the `:` suffix, but does
+ * NOT strip the `#` namespace separator:
+ *   "com.a.b#Error:Sender,tag" -> "com.a.b#Error"
+ *
+ * @internal
+ */
+export declare const loadSmithyRpcV2JsonErrorCode: (output: HttpResponse, data: any) => string | undefined;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/writeKey.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Makes __proto__ writable on a given object.
+ */
+export declare function writeKey(obj: object | Record<string, unknown> | any): void;

package/node_modules/@smithy/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/core",
-  "version": "3.35.1",
+  "version": "3.36.0",
   "homepage": "https://github.com/smithy-lang/smithy-typescript/tree/main/packages/core",
   "license": "Apache-2.0",
   "author": {
@@ -226,6 +226,7 @@
   "scripts": {
     "benchmark:cbor": "node ./scripts/cbor-perf.mjs",
     "benchmark:checksum": "node ./scripts/checksum-perf.mjs",
+    "benchmark:json": "npx tsx ./scripts/benchmark-json-serializer.ts",
     "benchmark:schema:cbor": "node ./scripts/cbor-shape-perf.mjs",
     "build": "concurrently 'yarn:build:types' 'yarn:build:es:cjs'",
     "build:es:cjs": "node ../../scripts/compilation/es_cjs.js",

package/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Thu, 01 Oct 2026 22:35:12 GMT
+ * Last updated: Fri, 09 Oct 2026 18:42:20 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "26.6.4",
+    "version": "26.6.5",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -135,6 +135,6 @@
         "undici-types": "~8.9.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "6c3e6bb0de9116746132571c03cd320ed541b2c7576c42dd3c7fa509e3440b61",
+    "typesPublisherContentHash": "3196021f34db9bcb68a729bd29ff60434d3b4c5f49619270db25e7dbd6dc651c",
     "typeScriptVersion": "5.6"
 }

package/node_modules/@types/node/util.d.ts

@@ -1260,16 +1260,19 @@ declare module "node:util" {
      *
      * // 3-digit hex color (shorthand)
      * console.log(styleText('#f00', 'Red text'));
+     *
+     * // Hex color combined with other modifiers
+     * console.log(styleText(['#00f', 'bold'], 'Bold blue text'));
      * ```
      *
      * The full list of formats can be found in [modifiers](https://nodejs.org/docs/latest-v26.x/api/util.html#modifiers).
-     * @param format A text format or an Array of text formats defined in `util.inspect.colors`, or a hex color in `#RGB`
-     * or `#RRGGBB` form.
+     * @param format A text format defined in `util.inspect.colors`, a hex color in `#RGB` or `#RRGGBB` form,
+     * or an Array of text formats and/or hex colors.
      * @param text The text to to be formatted.
      * @since v20.12.0
      */
     export function styleText(
-        format: InspectColor | readonly InspectColor[] | `#${string}`,
+        format: InspectColor | `#${string}` | readonly (InspectColor | `#${string}`)[],
         text: string,
         options?: StyleTextOptions,
     ): string;

package/node_modules/content-disposition/README.md

@@ -17,17 +17,17 @@ $ npm install content-disposition
 ## API
 
 ```js
-const contentDisposition = require('content-disposition')
+import { create, parse, format } from 'content-disposition';
 ```
 
-### contentDisposition(filename, options)
+### create(filename, options)
 
 Create an attachment `Content-Disposition` header value using the given file name,
 if supplied. The `filename` is optional and if no file name is desired, but you
 want to specify `options`, set `filename` to `undefined`.
 
 ```js
-res.setHeader('Content-Disposition', contentDisposition('∫ maths.pdf'))
+res.setHeader('Content-Disposition', create('∫ maths.pdf'));
 ```
 
 **note** HTTP headers are of the ISO-8859-1 character set. If you are writing this
@@ -40,73 +40,139 @@ the `'binary'` encoding in Node.js.
 
 ##### fallback
 
-If the `filename` option is outside ISO-8859-1, then the file name is actually
+If the `filename` option is outside US-ASCII, then the file name is actually
 stored in a supplemental field for clients that support Unicode file names and
-a ISO-8859-1 version of the file name is automatically generated.
+a US-ASCII version of the file name is automatically generated.
 
-This specifies the ISO-8859-1 file name to override the automatic generation or
+This specifies the US-ASCII file name to override the automatic generation or
 disables the generation all together, defaults to `true`.
 
-  - A string will specify the ISO-8859-1 file name to use in place of automatic
-    generation.
-  - `false` will disable including a ISO-8859-1 file name and only include the
-    Unicode version (unless the file name is already ISO-8859-1).
-  - `true` will enable automatic generation if the file name is outside ISO-8859-1.
+- A string will specify the US-ASCII file name to use in place of automatic
+  generation.
+- `false` will disable including a US-ASCII file name and only include the
+  Unicode version (unless the file name is already US-ASCII).
+- `true` will enable automatic generation if the file name is outside US-ASCII.
 
-If the `filename` option is ISO-8859-1 and this option is specified and has a
+If the `filename` option is US-ASCII and this option is specified and has a
 different value, then the `filename` option is encoded in the extended field
-and this set as the fallback field, even though they are both ISO-8859-1.
+and this set as the fallback field, even though they are both US-ASCII.
 
 ##### type
 
 Specifies the disposition type, defaults to `"attachment"`. This can also be
 `"inline"`, or any other value (all values except inline are treated like
 `attachment`, but can convey additional information if both parties agree to
-it). The type is normalized to lower-case.
+it).
 
-### contentDisposition.parse(string)
+### parse(string, options)
 
 ```js
-const disposition = contentDisposition.parse('attachment; filename="EURO rates.txt"; filename*=UTF-8\'\'%e2%82%ac%20rates.txt')
+const disposition = parse(
+  'attachment; filename="EURO rates.txt"; filename*=UTF-8\'\'%e2%82%ac%20rates.txt',
+);
 ```
 
 Parse a `Content-Disposition` header string. This automatically handles extended
 ("Unicode") parameters by decoding them and providing them under the standard
-parameter name. This will return an object with the following properties (examples
-are shown for the string `'attachment; filename="EURO rates.txt"; filename*=UTF-8\'\'%e2%82%ac%20rates.txt'`):
+parameter name. This will return an object with the following properties:
 
- - `type`: The disposition type (always lower case). Example: `'attachment'`
+- `type`: The disposition type (always lower case). Example: `'attachment'`
 
- - `parameters`: An object of the parameters in the disposition (name of parameter
-   always lower case and extended versions replace non-extended versions). Example:
-   `{filename: "€ rates.txt"}`
+- `parameters`: An object of the parameters in the disposition (name of parameter
+  always lower case and extended versions replace non-extended versions). Example:
+  `{filename: "€ rates.txt"}`
+
+#### Options
+
+##### multipart
+
+Parse parameters using browser `multipart/form-data` behavior.
+
+```js
+parse('form-data; name="file"; filename="the %22plans%22.pdf"', {
+  multipart: true,
+});
+```
+
+##### extended
+
+Parse RFC 5987 extended header parameters automatically when decoding
+parameters, defaults to `true`.
+
+### format(obj, options)
+
+```js
+const disposition = format({
+  type: 'attachment',
+  parameters: {
+    filename: '€ rates.txt',
+  },
+});
+```
+
+Formats an object to a `Content-Disposition` header string. This automatically
+handles extended ("Unicode") parameters and returns a string. Example:
+`'attachment; filename*=UTF-8''%E2%82%AC%20rates.txt'`
+
+#### Options
+
+##### multipart
+
+Format parameters using browser `multipart/form-data` behavior. This quotes
+parameter values, escapes `"` as `%22`, and writes Unicode values directly
+instead of using extended parameters.
+
+```js
+format(
+  {
+    type: 'form-data',
+    parameters: { name: 'file', filename: '€ rates.txt' },
+  },
+  { multipart: true },
+);
+```
+
+##### extended
+
+Encode Unicode parameter values using RFC 5987 extended header parameters,
+e.g. `filename*=`, defaults to `true`.
 
 ## Examples
 
 ### Send a file for download
 
 ```js
-const contentDisposition = require('content-disposition')
-const fs = require('fs')
-const http = require('http')
-const onFinished = require('on-finished')
+const contentDisposition = require('content-disposition');
+const fs = require('fs');
+const http = require('http');
+const onFinished = require('on-finished');
 
-const filePath = '/path/to/public/plans.pdf'
+const filePath = '/path/to/public/plans.pdf';
 
-http.createServer(function onRequest (req, res) {
+http.createServer(function onRequest(req, res) {
   // set headers
-  res.setHeader('Content-Type', 'application/pdf')
-  res.setHeader('Content-Disposition', contentDisposition(filePath))
+  res.setHeader('Content-Type', 'application/pdf');
+  res.setHeader('Content-Disposition', contentDisposition(filePath));
 
   // send file
-  const stream = fs.createReadStream(filePath)
-  stream.pipe(res)
+  const stream = fs.createReadStream(filePath);
+  stream.pipe(res);
   onFinished(res, function () {
-    stream.destroy()
-  })
-})
+    stream.destroy();
+  });
+});
 ```
 
+## Local demo
+
+Run the upload inspector locally:
+
+```sh
+npm run demo
+```
+
+Then open `http://127.0.0.1:3000` in your browser. The demo lets you upload files, inspect the multipart upload part headers sent by the browser, and compare them with the download `Content-Disposition` header generated by this package.
+
 ## Testing
 
 ```sh
@@ -118,11 +184,15 @@ $ npm test
 - [RFC 2616: Hypertext Transfer Protocol -- HTTP/1.1][rfc-2616]
 - [RFC 5987: Character Set and Language Encoding for Hypertext Transfer Protocol (HTTP) Header Field Parameters][rfc-5987]
 - [RFC 6266: Use of the Content-Disposition Header Field in the Hypertext Transfer Protocol (HTTP)][rfc-6266]
+- [RFC 8187: Indicating Character Encoding and Language for HTTP Header Field Parameters][rfc-8187]
+- [HTML Living Standard: Multipart form data][html-form]
 - [Test Cases for HTTP Content-Disposition header field (RFC 6266) and the Encodings defined in RFCs 2047, 2231 and 5987][tc-2231]
 
 [rfc-2616]: https://datatracker.ietf.org/doc/html/rfc2616
 [rfc-5987]: https://datatracker.ietf.org/doc/html/rfc5987
 [rfc-6266]: https://datatracker.ietf.org/doc/html/rfc6266
+[rfc-8187]: https://datatracker.ietf.org/doc/html/rfc8187
+[html-form]: https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data
 [tc-2231]: http://greenbytes.de/tech/tc2231/
 
 ## License

package/node_modules/content-disposition/dist/index.d.ts

@@ -0,0 +1,72 @@
+/*!
+ * content-disposition
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+export interface ContentDisposition {
+    /**
+     * Content-Disposition type, such as "attachment" or "inline"
+     */
+    type: string;
+    /**
+     * Content-Disposition parameters, such as "filename"
+     */
+    parameters: Record<string, string>;
+}
+export interface CreateOptions {
+    /**
+     * Content-Disposition type, defaults to "attachment"
+     * @default "attachment"
+     */
+    type?: string;
+    /**
+     * Fallback filename for non-US-ASCII strings. If true, a fallback will be generated by replacing non-US-ASCII characters with "?". If false, no fallback will be generated.
+     * @default true
+     */
+    fallback?: string | boolean;
+}
+/**
+ * Create an attachment Content-Disposition header.
+ */
+export declare function create(filename?: string, options?: CreateOptions): string;
+export interface ParseOptions {
+    /**
+     * Whether to decode RFC 8187 encoded parameters.
+     * @default true
+     */
+    extended?: boolean;
+    /**
+     * Parse parameters as sent by browsers in `multipart/form-data`.
+     * @default false
+     */
+    multipart?: boolean;
+}
+/**
+ * Parse Content-Disposition header string.
+ */
+export declare function parse(header: string, options?: ParseOptions): ContentDisposition;
+/**
+ * Decode a RFC 8187 field value (gracefully).
+ */
+export declare function decodeExtended(str: string): string | undefined;
+export interface FormatOptions {
+    /**
+     * Whether to use extended parameter encoding for non-ISO-8859-1 strings.
+     * If false, an error will be thrown when formatting such strings.
+     * @default true
+     */
+    extended?: boolean;
+    /**
+     * Format parameters as sent by browsers in `multipart/form-data`.
+     * @default false
+     */
+    multipart?: boolean;
+}
+/**
+ * Format object to Content-Disposition header.
+ */
+export declare function format(obj: Partial<ContentDisposition>, options?: FormatOptions): string;
+/**
+ * Encode a Unicode string for HTTP (RFC 8187).
+ */
+export declare function encodeExtended(str: string): string;