@useairfoil/effect-vcr 0.4.3 → 0.4.5

package/src/sanitize.ts

@@ -1,7 +1,8 @@
-import { Effect, Option } from "effect";
+import { Effect, Option, Record } from "effect";
+import { UrlParams } from "effect/unstable/http";
 import stableStringify from "json-stable-stringify";
 
-import type { VcrRequest, VcrResponse } from "./types";
+import type { VcrRedactedValue, VcrRequest, VcrResponse } from "./types";
 
 /**
  * Normalize header names to match HttpClient's lowercase behavior.
@@ -13,15 +14,8 @@ const normalizeHeaderKey = (key: string) => key.toLowerCase();
  */
 const toHeaderRecord = (headers?: Record<string, string>) => {
   if (!headers) return undefined;
-  const entries = Object.entries(headers).map(
-    ([key, value]) => [normalizeHeaderKey(key), value] as const,
-  );
-  entries.sort(([a], [b]) => a.localeCompare(b));
-  const record: Record<string, string> = {};
-  for (const [key, value] of entries) {
-    record[key] = value;
-  }
-  return record;
+  const lowered = Record.mapKeys(headers, normalizeHeaderKey);
+  return Record.fromEntries(Record.toEntries(lowered).sort(([a], [b]) => a.localeCompare(b)));
 };
 
 /**
@@ -34,13 +28,7 @@ const omitHeaderKeys = (
   if (!headers) return Option.none();
   if (!ignore || ignore.length === 0) return Option.some(headers);
   const ignoreSet = new Set(ignore.map(normalizeHeaderKey));
-  const filtered: Record<string, string> = {};
-  for (const [key, value] of Object.entries(headers)) {
-    if (!ignoreSet.has(normalizeHeaderKey(key))) {
-      filtered[key] = value;
-    }
-  }
-  return Option.some(filtered);
+  return Option.some(Record.filter(headers, (_, key) => !ignoreSet.has(normalizeHeaderKey(key))));
 };
 
 /**
@@ -48,44 +36,126 @@ const omitHeaderKeys = (
  */
 const tryParseJson = Option.liftThrowable((input: string) => JSON.parse(input));
 
+type BodyOptions = {
+  readonly omit?: ReadonlyArray<string>;
+  readonly replacements?: Readonly<Record<string, VcrRedactedValue>>;
+};
+
+type BodyTransformation<A> = {
+  readonly value: A;
+  readonly redacted: boolean;
+};
+
 /**
- * Recursively drop keys from JSON objects to build stable request keys.
+ * Recursively remove or replace keys in JSON values.
  */
-const stripKeys = (value: unknown, ignore: Set<string>): unknown => {
+const transformJsonKeys = (
+  value: unknown,
+  omit: ReadonlySet<string>,
+  replacements: Readonly<Record<string, VcrRedactedValue>>,
+): BodyTransformation<unknown> => {
   if (Array.isArray(value)) {
-    return value.map((item) => stripKeys(item, ignore));
+    let redacted = false;
+    const values = value.map((item) => {
+      const transformed = transformJsonKeys(item, omit, replacements);
+      redacted ||= transformed.redacted;
+      return transformed.value;
+    });
+    return { value: values, redacted };
   }
   if (value && typeof value === "object") {
     const record = value as Record<string, unknown>;
     const next: Record<string, unknown> = {};
+    let redacted = false;
     for (const [key, entry] of Object.entries(record)) {
-      if (!ignore.has(key)) {
-        next[key] = stripKeys(entry, ignore);
+      if (omit.has(key)) {
+        redacted = true;
+        continue;
+      }
+      if (Record.has(replacements, key)) {
+        next[key] = replacements[key];
+        redacted = true;
+        continue;
       }
+      const transformed = transformJsonKeys(entry, omit, replacements);
+      next[key] = transformed.value;
+      redacted ||= transformed.redacted;
     }
-    return next;
+    return { value: next, redacted };
   }
-  return value;
+  return { value, redacted: false };
+};
+
+const headerValue = (
+  headers: Readonly<Record<string, string>> | undefined,
+  name: string,
+): string | undefined => {
+  if (!headers) return undefined;
+  const normalizedName = normalizeHeaderKey(name);
+  return Object.entries(headers).find(([key]) => normalizeHeaderKey(key) === normalizedName)?.[1];
+};
+
+const isUrlEncoded = (headers: Readonly<Record<string, string>> | undefined): boolean =>
+  headerValue(headers, "content-type")?.split(";", 1)[0]?.trim().toLowerCase() ===
+  "application/x-www-form-urlencoded";
+
+const transformUrlParams = (
+  body: string,
+  omit: ReadonlySet<string>,
+  replacements: Readonly<Record<string, VcrRedactedValue>>,
+): BodyTransformation<string> => {
+  let redacted = false;
+  const value = UrlParams.fromInput(new URLSearchParams(body)).pipe(
+    UrlParams.transform((params) =>
+      params.flatMap(([key, value]) => {
+        if (omit.has(key)) {
+          redacted = true;
+          return [];
+        }
+        if (Record.has(replacements, key)) {
+          redacted = true;
+          return [[key, String(replacements[key])] as const];
+        }
+        return [[key, value] as const];
+      }),
+    ),
+    UrlParams.toString,
+  );
+  return { value, redacted };
 };
 
 /**
- * Remove JSON keys from a string body when possible.
+ * Remove or replace JSON and URL-encoded body fields when possible.
  */
-const omitBodyKeys = (
+const transformBody = (
   body: string | undefined,
-  ignore: ReadonlyArray<string> | undefined,
-): Option.Option<string> => {
+  headers: Readonly<Record<string, string>> | undefined,
+  options: BodyOptions,
+): Option.Option<BodyTransformation<string>> => {
   if (!body) return Option.none();
+  const omit = new Set(options.omit);
+  const replacements = options.replacements ?? {};
+  if (isUrlEncoded(headers)) {
+    const hasMatch = Array.from(new URLSearchParams(body).keys()).some(
+      (key) => omit.has(key) || Record.has(replacements, key),
+    );
+    if (!hasMatch) {
+      return Option.some({ value: body, redacted: false });
+    }
+    return Option.some(transformUrlParams(body, omit, replacements));
+  }
   return Option.some(
     tryParseJson(body).pipe(
       Option.match({
-        onNone: () => body,
+        onNone: () => ({ value: body, redacted: false }),
         onSome: (parsed) => {
-          if (!ignore || ignore.length === 0) {
-            return stableStringify(parsed) ?? body;
-          }
-          const ignoreSet = new Set(ignore);
-          return stableStringify(stripKeys(parsed, ignoreSet)) ?? body;
+          const transformed = transformJsonKeys(parsed, omit, replacements);
+          return {
+            // stableStringify's return type is `string | undefined` for cyclic input;
+            // parsed JSON is never cyclic, but the fallback keeps the types honest.
+            value: stableStringify(transformed.value) ?? body,
+            redacted: transformed.redacted,
+          };
         },
       }),
     ),
@@ -93,7 +163,7 @@ const omitBodyKeys = (
 };
 
 /**
- * Normalize request for matching: header canonicalization + JSON body filtering.
+ * Normalize request for matching: header canonicalization and structured body filtering.
  */
 export const sanitizeRequest = (
   request: VcrRequest,
@@ -102,11 +172,22 @@ export const sanitizeRequest = (
     readonly ignoreBodyKeys?: ReadonlyArray<string>;
   },
 ): VcrRequest => {
-  const filteredHeaders = omitHeaderKeys(request.headers, options.ignoreHeaders);
+  const transformedBody = transformBody(request.body, request.headers, {
+    omit: options.ignoreBodyKeys,
+  });
+  const body = Option.getOrUndefined(
+    transformedBody.pipe(Option.map((transformed) => transformed.value)),
+  );
+  const filteredHeaders = omitHeaderKeys(
+    request.headers,
+    transformedBody.pipe(Option.exists((transformed) => transformed.redacted))
+      ? [...(options.ignoreHeaders ?? []), "content-length"]
+      : options.ignoreHeaders,
+  );
   return {
     ...request,
     headers: toHeaderRecord(Option.getOrUndefined(filteredHeaders)),
-    body: Option.getOrUndefined(omitBodyKeys(request.body, options.ignoreBodyKeys)),
+    body,
   };
 };
 
@@ -125,6 +206,8 @@ export const buildRequestKey = (
       ignoreHeaders: options.ignoreHeaders,
       ignoreBodyKeys: options.ignoreBodyKeys,
     });
+    // stableStringify only returns undefined for cyclic input; this literal never is,
+    // but its declared type is `string | undefined`, so keep the fallback for TS.
     return (
       stableStringify({
         method: sanitized.method.toUpperCase(),
@@ -149,12 +232,29 @@ export const redactRequest = (
   options: {
     readonly redactHeaders?: ReadonlyArray<string>;
     readonly redactBodyKeys?: ReadonlyArray<string>;
+    readonly bodyReplacements?: Readonly<Record<string, VcrRedactedValue>>;
   },
-): VcrRequest => ({
-  ...request,
-  headers: Option.getOrUndefined(omitHeaderKeys(request.headers, options.redactHeaders)),
-  body: Option.getOrUndefined(omitBodyKeys(request.body, options.redactBodyKeys)),
-});
+): VcrRequest => {
+  const transformedBody = transformBody(request.body, request.headers, {
+    omit: options.redactBodyKeys,
+    replacements: options.bodyReplacements,
+  });
+  const body = Option.getOrUndefined(
+    transformedBody.pipe(Option.map((transformed) => transformed.value)),
+  );
+  return {
+    ...request,
+    headers: Option.getOrUndefined(
+      omitHeaderKeys(
+        request.headers,
+        transformedBody.pipe(Option.exists((transformed) => transformed.redacted))
+          ? [...(options.redactHeaders ?? []), "content-length"]
+          : options.redactHeaders,
+      ),
+    ),
+    body,
+  };
+};
 
 /**
  * Remove sensitive response data before persisting to a cassette.
@@ -164,9 +264,27 @@ export const redactResponse = (
   options: {
     readonly redactHeaders?: ReadonlyArray<string>;
     readonly redactBodyKeys?: ReadonlyArray<string>;
+    readonly bodyReplacements?: Readonly<Record<string, VcrRedactedValue>>;
   },
-): VcrResponse => ({
-  ...response,
-  headers: Option.getOrUndefined(omitHeaderKeys(response.headers, options.redactHeaders)),
-  body: Option.getOrElse(omitBodyKeys(response.body, options.redactBodyKeys), () => response.body),
-});
+): VcrResponse => {
+  const transformedBody = transformBody(response.body, response.headers, {
+    omit: options.redactBodyKeys,
+    replacements: options.bodyReplacements,
+  });
+  const body = Option.getOrElse(
+    transformedBody.pipe(Option.map((transformed) => transformed.value)),
+    () => response.body,
+  );
+  return {
+    ...response,
+    headers: Option.getOrUndefined(
+      omitHeaderKeys(
+        response.headers,
+        transformedBody.pipe(Option.exists((transformed) => transformed.redacted))
+          ? [...(options.redactHeaders ?? []), "content-length"]
+          : options.redactHeaders,
+      ),
+    ),
+    body,
+  };
+};

package/src/types.ts

@@ -1,3 +1,5 @@
+import { Schema } from "effect";
+
 /**
  * VCR operating mode.
  * - record: always call the live client and persist.
@@ -6,50 +8,60 @@
  */
 export type VcrMode = "record" | "replay" | "auto";
 
+/**
+ * Safe scalar value written in place of a sensitive body field.
+ */
+export type VcrRedactedValue = string | number | boolean | null;
+
 /**
  * Serialized request shape stored in a cassette.
  */
-export type VcrRequest = {
-  readonly method: string;
-  readonly url: string;
-  readonly headers?: Record<string, string>;
-  readonly body?: string;
-};
+export const VcrRequestSchema = Schema.Struct({
+  method: Schema.String,
+  url: Schema.String,
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  body: Schema.optional(Schema.String),
+});
+export type VcrRequest = Schema.Schema.Type<typeof VcrRequestSchema>;
 
 /**
  * Serialized response shape stored in a cassette.
  */
-export type VcrResponse = {
-  readonly status: number;
-  readonly body: string;
-  readonly headers?: Record<string, string>;
-};
+export const VcrResponseSchema = Schema.Struct({
+  status: Schema.Number,
+  body: Schema.String,
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+});
+export type VcrResponse = Schema.Schema.Type<typeof VcrResponseSchema>;
 
 /**
  * A single request/response pair keyed in the cassette.
  */
-export type VcrEntry = {
-  readonly request: VcrRequest;
-  readonly response: VcrResponse;
-};
+export const VcrEntrySchema = Schema.Struct({
+  request: VcrRequestSchema,
+  response: VcrResponseSchema,
+});
+export type VcrEntry = Schema.Schema.Type<typeof VcrEntrySchema>;
 
 /**
  * Cassette file format.
  */
-export type Cassette = {
-  readonly meta: {
-    readonly createdAt: string;
-    readonly version: string;
-  };
-  readonly entries: Record<string, VcrEntry>;
-};
+export const CassetteSchema = Schema.Struct({
+  meta: Schema.Struct({
+    createdAt: Schema.String,
+    version: Schema.String,
+  }),
+  entries: Schema.Record(Schema.String, VcrEntrySchema),
+});
+export type Cassette = Schema.Schema.Type<typeof CassetteSchema>;
 
 /**
  * Cassette file format with multiple exports.
  */
-export type CassetteFile = {
-  readonly exports: Record<string, Cassette>;
-};
+export const CassetteFileSchema = Schema.Struct({
+  exports: Schema.Record(Schema.String, CassetteSchema),
+});
+export type CassetteFile = Schema.Schema.Type<typeof CassetteFileSchema>;
 
 /**
  * VCR configuration.
@@ -65,13 +77,15 @@ export type VcrConfig = {
   readonly cassetteName?: string;
   readonly mode?: VcrMode;
   /**
-   * Remove sensitive data before writing to disk.
+   * Remove or replace sensitive data before writing to disk.
    */
   readonly redact?: {
     readonly requestHeaders?: ReadonlyArray<string>;
     readonly responseHeaders?: ReadonlyArray<string>;
     readonly requestBodyKeys?: ReadonlyArray<string>;
     readonly responseBodyKeys?: ReadonlyArray<string>;
+    readonly requestBodyReplacements?: Readonly<Record<string, VcrRedactedValue>>;
+    readonly responseBodyReplacements?: Readonly<Record<string, VcrRedactedValue>>;
   };
   /**
    * Ignore fields when computing the request key for replay matching.

package/src/vcr-http-client.ts

@@ -1,4 +1,4 @@
-import { Config, Data, Effect, Option, Path } from "effect";
+import { Array as Arr, Config, Data, Effect, Option, Path } from "effect";
 import {
   HttpClient,
   HttpClientError,
@@ -64,20 +64,31 @@ const resolveCassetteLocation = Effect.fnUntraced(function* (config: VcrConfig)
 /**
  * Apply defaults for common VCR behavior while preserving explicit overrides.
  */
-const normalizeConfig = (config: VcrConfig): VcrConfig => ({
-  vcrName: config.vcrName,
-  cassetteName: config.cassetteName,
-  mode: config.mode ?? "auto",
-  matchIgnore: {
-    requestHeaders: ["authorization"],
-    ...config.matchIgnore,
-  },
-  redact: {
-    requestHeaders: ["authorization"],
-    ...config.redact,
-  },
-  match: config.match,
-});
+const normalizeConfig = (config: VcrConfig): VcrConfig => {
+  const redactedRequestBodyKeys = Arr.union(
+    config.redact?.requestBodyKeys ?? [],
+    Object.keys(config.redact?.requestBodyReplacements ?? {}),
+  );
+  const redactedRequestHeaders = Arr.union(["authorization"], config.redact?.requestHeaders ?? []);
+
+  return {
+    vcrName: config.vcrName,
+    cassetteName: config.cassetteName,
+    mode: config.mode ?? "auto",
+    matchIgnore: {
+      requestHeaders: Arr.union(redactedRequestHeaders, config.matchIgnore?.requestHeaders ?? []),
+      requestBodyKeys: Arr.union(
+        redactedRequestBodyKeys,
+        config.matchIgnore?.requestBodyKeys ?? [],
+      ),
+    },
+    redact: {
+      ...config.redact,
+      requestHeaders: redactedRequestHeaders,
+    },
+    match: config.match,
+  };
+};
 
 const AckDisableVcrConfig = Config.option(Config.string("ACK_DISABLE_VCR")).pipe(
   Config.map((value) =>
@@ -120,15 +131,9 @@ const toRequestError = (
   });
 
 /**
- * Convert header map to a plain record for JSON persistence.
+ * Best-effort JSON serialization for opaque raw bodies.
  */
-const recordFromHeaders = (headers: Record<string, string>) => {
-  const record: Record<string, string> = {};
-  for (const [key, value] of Object.entries(headers)) {
-    record[key] = value;
-  }
-  return record;
-};
+const tryStringify = Option.liftThrowable((value: unknown) => JSON.stringify(value));
 
 /**
  * Serialize an Effect HttpClientRequest into a cassette request shape.
@@ -138,7 +143,7 @@ const recordFromHeaders = (headers: Record<string, string>) => {
  * live requests.
  */
 const toVcrRequest = (request: HttpClientRequest.HttpClientRequest): VcrRequest => {
-  const headers = recordFromHeaders(request.headers as Record<string, string>);
+  const headers: Record<string, string> = { ...request.headers };
   const body = (() => {
     switch (request.body._tag) {
       case "Empty":
@@ -149,11 +154,7 @@ const toVcrRequest = (request: HttpClientRequest.HttpClientRequest): VcrRequest
         const raw = request.body.body as unknown;
         if (typeof raw === "string") return raw;
         if (raw instanceof Uint8Array) return decoder.decode(raw);
-        try {
-          return JSON.stringify(raw);
-        } catch {
-          return "[raw]";
-        }
+        return tryStringify(raw).pipe(Option.getOrElse(() => "[raw]"));
       }
       case "FormData":
         return "[form-data]";
@@ -179,7 +180,7 @@ const toVcrResponse = (
 ): VcrResponse => ({
   status: response.status,
   body,
-  headers: recordFromHeaders(response.headers as Record<string, string>),
+  headers: { ...response.headers },
 });
 
 /**
@@ -309,12 +310,14 @@ const record = Effect.fnUntraced(function* (
     ? redactRequest(vcrRequest, {
         redactHeaders: config.redact.requestHeaders,
         redactBodyKeys: config.redact.requestBodyKeys,
+        bodyReplacements: config.redact.requestBodyReplacements,
       })
     : vcrRequest;
   const sanitizedResponse = config.redact
     ? redactResponse(vcrResponse, {
         redactHeaders: config.redact.responseHeaders,
         redactBodyKeys: config.redact.responseBodyKeys,
+        bodyReplacements: config.redact.responseBodyReplacements,
       })
     : vcrResponse;
 

package/dist/cassette-store-CnXX5OLB.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cassette-store-CnXX5OLB.js","names":[],"sources":["../src/cassette-store.ts"],"sourcesContent":["import { Context, Data, DateTime, Effect } from \"effect\";\n\nimport type { Cassette, CassetteFile } from \"./types\";\n\nexport type CassetteStoreOperation = \"exists\" | \"load\" | \"save\" | \"loadOrInit\" | \"resolveRoot\";\n\n/**\n * Storage contract for VCR cassettes.\n *\n */\nexport interface CassetteStoreService {\n  /** Returns true if a cassette with the given name exists. */\n  readonly exists: (name: string) => Effect.Effect<boolean, CassetteStoreError>;\n\n  /** Loads a cassette by name, returning a `CassetteFile` if found. */\n  readonly load: (name: string) => Effect.Effect<CassetteFile, CassetteStoreError>;\n\n  /** Saves a cassette by name, overwriting any existing cassette with the same name. */\n  readonly save: (name: string, content: CassetteFile) => Effect.Effect<void, CassetteStoreError>;\n\n  /** Loads a cassette by name, initializing a new empty cassette if not found. */\n  readonly loadOrInit: (name: string) => Effect.Effect<CassetteFile, CassetteStoreError>;\n}\n\n/**\n * Effect service tag for the cassette store.\n */\nexport class CassetteStore extends Context.Service<CassetteStore, CassetteStoreService>()(\n  \"@useairfoil/effect-vcr/CassetteStore\",\n) {}\n\n/**\n * Creates a new empty cassette with a timestamp and format version.\n */\nexport const createEmptyCassette = Effect.fnUntraced(function* (): Effect.fn.Return<Cassette> {\n  const now = yield* DateTime.now;\n  return {\n    meta: {\n      createdAt: DateTime.formatIso(now),\n      version: \"1\",\n    },\n    entries: {},\n  };\n});\n\nexport const createEmptyCassetteFile = (): Effect.Effect<CassetteFile> =>\n  Effect.map(createEmptyCassette(), (cassette) => ({\n    exports: { default: cassette },\n  }));\n\n/**\n * Structured error for cassette persistence operations.\n *\n * `operation` indicates which store function failed.\n * `path` is the file or directory path that was targeted.\n */\nexport class CassetteStoreError extends Data.TaggedError(\"CassetteStoreError\")<{\n  readonly operation: CassetteStoreOperation;\n  readonly path: string;\n  readonly message?: string;\n  readonly cause?: unknown;\n}> {}\n\nexport const toStoreError = (\n  operation: CassetteStoreOperation,\n  path: string,\n  cause?: unknown,\n  message?: string,\n) =>\n  new CassetteStoreError({\n    operation,\n    path,\n    cause,\n    message,\n  });\n\n/**\n * Parses cassette JSON and maps invalid JSON to a store error.\n */\nexport const parseCassette = (content: string, path: string) =>\n  Effect.try({\n    try: () => JSON.parse(content) as CassetteFile,\n    catch: (error) => toStoreError(\"load\", path, error, \"Invalid JSON\"),\n  }).pipe(\n    Effect.flatMap((parsed) => {\n      if (!parsed || typeof parsed !== \"object\" || !(\"exports\" in parsed)) {\n        return Effect.fail(toStoreError(\"load\", path, undefined, \"Invalid cassette file format\"));\n      }\n      return Effect.succeed(parsed);\n    }),\n  );\n\n/** Creates a `CassetteStore` implementation that uses the given `impl` object. */\nexport const make = (impl: CassetteStoreService): CassetteStoreService =>\n  CassetteStore.of({ ...impl });\n"],"mappings":";;;;;;;;;;;;;;;;AA2BA,IAAa,gBAAb,cAAmC,QAAQ,SAA8C,CACvF,uCACD,CAAC;;;;AAKF,MAAa,sBAAsB,OAAO,WAAW,aAAyC;CAC5F,MAAM,MAAM,OAAO,SAAS;AAC5B,QAAO;EACL,MAAM;GACJ,WAAW,SAAS,UAAU,IAAI;GAClC,SAAS;GACV;EACD,SAAS,EAAE;EACZ;EACD;AAEF,MAAa,gCACX,OAAO,IAAI,qBAAqB,GAAG,cAAc,EAC/C,SAAS,EAAE,SAAS,UAAU,EAC/B,EAAE;;;;;;;AAQL,IAAa,qBAAb,cAAwC,KAAK,YAAY,qBAAqB,CAK3E;AAEH,MAAa,gBACX,WACA,MACA,OACA,YAEA,IAAI,mBAAmB;CACrB;CACA;CACA;CACA;CACD,CAAC;;;;AAKJ,MAAa,iBAAiB,SAAiB,SAC7C,OAAO,IAAI;CACT,WAAW,KAAK,MAAM,QAAQ;CAC9B,QAAQ,UAAU,aAAa,QAAQ,MAAM,OAAO,eAAe;CACpE,CAAC,CAAC,KACD,OAAO,SAAS,WAAW;AACzB,KAAI,CAAC,UAAU,OAAO,WAAW,YAAY,EAAE,aAAa,QAC1D,QAAO,OAAO,KAAK,aAAa,QAAQ,MAAM,QAAW,+BAA+B,CAAC;AAE3F,QAAO,OAAO,QAAQ,OAAO;EAC7B,CACH;;AAGH,MAAa,QAAQ,SACnB,cAAc,GAAG,EAAE,GAAG,MAAM,CAAC"}

package/dist/types-BsuPrIpu.js

@@ -1 +0,0 @@
-export {  };

package/dist/types-DWwkMzxG.d.ts

@@ -1,85 +0,0 @@
-//#region src/types.d.ts
-/**
- * VCR operating mode.
- * - record: always call the live client and persist.
- * - replay: serve only from cassette, fail if missing.
- * - auto: replay if cassette exists, otherwise record (fail in CI).
- */
-type VcrMode = "record" | "replay" | "auto";
-/**
- * Serialized request shape stored in a cassette.
- */
-type VcrRequest = {
-  readonly method: string;
-  readonly url: string;
-  readonly headers?: Record<string, string>;
-  readonly body?: string;
-};
-/**
- * Serialized response shape stored in a cassette.
- */
-type VcrResponse = {
-  readonly status: number;
-  readonly body: string;
-  readonly headers?: Record<string, string>;
-};
-/**
- * A single request/response pair keyed in the cassette.
- */
-type VcrEntry = {
-  readonly request: VcrRequest;
-  readonly response: VcrResponse;
-};
-/**
- * Cassette file format.
- */
-type Cassette = {
-  readonly meta: {
-    readonly createdAt: string;
-    readonly version: string;
-  };
-  readonly entries: Record<string, VcrEntry>;
-};
-/**
- * Cassette file format with multiple exports.
- */
-type CassetteFile = {
-  readonly exports: Record<string, Cassette>;
-};
-/**
- * VCR configuration.
- */
-type VcrConfig = {
-  readonly vcrName?: string;
-  /**
-   * Cassette file name or basename.
-   *
-   * `users` resolves to `users.cassette`.
-   * `users.cassette` is preserved as-is.
-   */
-  readonly cassetteName?: string;
-  readonly mode?: VcrMode;
-  /**
-   * Remove sensitive data before writing to disk.
-   */
-  readonly redact?: {
-    readonly requestHeaders?: ReadonlyArray<string>;
-    readonly responseHeaders?: ReadonlyArray<string>;
-    readonly requestBodyKeys?: ReadonlyArray<string>;
-    readonly responseBodyKeys?: ReadonlyArray<string>;
-  };
-  /**
-   * Ignore fields when computing the request key for replay matching.
-   */
-  readonly matchIgnore?: {
-    readonly requestHeaders?: ReadonlyArray<string>;
-    readonly requestBodyKeys?: ReadonlyArray<string>;
-  };
-  /**
-   * Custom matcher to override key-based lookup.
-   */
-  readonly match?: (request: VcrRequest, entry: VcrEntry) => boolean;
-};
-//#endregion
-export { VcrMode as a, VcrEntry as i, CassetteFile as n, VcrRequest as o, VcrConfig as r, VcrResponse as s, Cassette as t };
-//# sourceMappingURL=types-DWwkMzxG.d.ts.map