Request Processing Policies

/**
 * A policy that processes multipart request bodies by setting appropriate headers and formatting
 * @returns PipelinePolicy that processes multipart requests
 */
function multipartPolicy(): PipelinePolicy;

/**
 * The programmatic identifier of the multipartPolicy
 */
const multipartPolicyName: string;

/**
 * A request body consisting of multiple parts
 */
interface MultipartRequestBody {
  /**
   * The parts of the request body
   */
  parts: BodyPart[];

  /**
   * The boundary separating each part of the request body.
   * If not specified, a random boundary will be generated.
   * When specified, '--' will be prepended to the boundary in the request.
   */
  boundary?: string;
}

/**
 * A part of the request body in a multipart request
 */
interface BodyPart {
  /**
   * The headers for this part of the multipart request
   */
  headers: HttpHeaders;

  /**
   * The body of this part of the multipart request
   */
  body:
    | ((() => ReadableStream<Uint8Array>) | (() => NodeJS.ReadableStream))
    | ReadableStream<Uint8Array>
    | NodeJS.ReadableStream
    | Uint8Array
    | Blob;
}

import { 
  multipartPolicy,
  createPipelineRequest,
  createHttpHeaders,
  type MultipartRequestBody,
  type BodyPart
} from "@azure/core-rest-pipeline";

// Add multipart policy to pipeline
pipeline.addPolicy(multipartPolicy());

// Create multipart request
const parts: BodyPart[] = [
  {
    headers: createHttpHeaders({
      "Content-Disposition": 'form-data; name="field1"'
    }),
    body: "value1"
  },
  {
    headers: createHttpHeaders({
      "Content-Disposition": 'form-data; name="file"; filename="document.txt"',
      "Content-Type": "text/plain"
    }),
    body: new Uint8Array([72, 101, 108, 108, 111]) // "Hello" in bytes
  }
];

const multipartBody: MultipartRequestBody = {
  parts,
  boundary: "custom-boundary-123"
};

const request = createPipelineRequest({
  url: "https://api.example.com/upload",
  method: "POST",
  multipartBody
});

/**
 * A policy that processes FormData request bodies by setting appropriate headers
 * @returns PipelinePolicy that processes form data requests
 */
function formDataPolicy(): PipelinePolicy;

/**
 * The programmatic identifier of the formDataPolicy
 */
const formDataPolicyName: string;

/**
 * A simple object that provides form data, as if from a browser form
 */
type FormDataMap = { [key: string]: FormDataValue | FormDataValue[] };

/**
 * Each form data entry can be a string, Blob, or a File
 */
type FormDataValue = string | Blob | File;

import { 
  formDataPolicy,
  createPipelineRequest,
  type FormDataMap
} from "@azure/core-rest-pipeline";

// Add form data policy to pipeline
pipeline.addPolicy(formDataPolicy(), { 
  beforePolicies: [multipartPolicyName] 
});

// Create form data request using FormDataMap
const formData: FormDataMap = {
  name: "John Doe",
  email: "john@example.com",
  tags: ["user", "active"], // Array of values
  avatar: new File(["avatar data"], "avatar.jpg", { type: "image/jpeg" })
};

const request = createPipelineRequest({
  url: "https://api.example.com/users",
  method: "POST",
  formData
});

// Or use browser FormData directly
const browserFormData = new FormData();
browserFormData.append("name", "Jane Doe");
browserFormData.append("file", new Blob(["file content"], { type: "text/plain" }));

const formRequest = createPipelineRequest({
  url: "https://api.example.com/submit",
  method: "POST",
  body: browserFormData
});

/**
 * A policy that processes newline-delimited JSON request bodies
 * @returns PipelinePolicy that processes NDJSON requests
 */
function ndJsonPolicy(): PipelinePolicy;

/**
 * The programmatic identifier of the ndJsonPolicy
 */
const ndJsonPolicyName: string;

import { ndJsonPolicy, createPipelineRequest } from "@azure/core-rest-pipeline";

// Add NDJSON policy to pipeline
pipeline.addPolicy(ndJsonPolicy());

// Create NDJSON request
const ndjsonData = [
  { id: 1, name: "Alice" },
  { id: 2, name: "Bob" },
  { id: 3, name: "Charlie" }
];

const ndjsonBody = ndjsonData.map(obj => JSON.stringify(obj)).join('\n');

const request = createPipelineRequest({
  url: "https://api.example.com/bulk-data",
  method: "POST",
  body: ndjsonBody,
  headers: {
    "Content-Type": "application/x-ndjson"
  }
});

/**
 * A policy that decompresses response bodies automatically based on Content-Encoding header
 * Only active in Node.js environments - browsers handle decompression automatically
 * @returns PipelinePolicy that decompresses responses
 */
function decompressResponsePolicy(): PipelinePolicy;

/**
 * The programmatic identifier of the decompressResponsePolicy
 */
const decompressResponsePolicyName: string;

import { decompressResponsePolicy } from "@azure/core-rest-pipeline";
import { isNodeLike } from "@azure/core-util";

// Add decompression policy (Node.js only)
if (isNodeLike) {
  pipeline.addPolicy(decompressResponsePolicy());
}

// The policy automatically handles compressed responses
const request = createPipelineRequest({
  url: "https://api.example.com/large-data",
  method: "GET",
  headers: {
    "Accept-Encoding": "gzip, deflate, br"
  }
});

// Response will be automatically decompressed if compressed
const response = await pipeline.sendRequest(client, request);
console.log(response.bodyAsText); // Decompressed content

import { 
  createPipelineFromOptions,
  formDataPolicy,
  multipartPolicy,
  ndJsonPolicy,
  decompressResponsePolicy,
  multipartPolicyName
} from "@azure/core-rest-pipeline";

const pipeline = createPipelineFromOptions({});

// Add policies in correct order
pipeline.addPolicy(formDataPolicy(), { 
  beforePolicies: [multipartPolicyName] 
});
pipeline.addPolicy(multipartPolicy());
pipeline.addPolicy(ndJsonPolicy());

// Decompression policy for Node.js
if (typeof process !== "undefined") {
  pipeline.addPolicy(decompressResponsePolicy());
}

/**
 * Policy name constants for use in pipeline configuration
 */
const multipartPolicyName: string;
const formDataPolicyName: string;
const ndJsonPolicyName: string;
const decompressResponsePolicyName: string;