@karmaniverous/get-dotenv 6.2.2 → 6.2.4

package/dist/chunks/index-Bc3h0a95.mjs

@@ -0,0 +1,374 @@
+import { l as redactTriple, m as maybeWarnEntropy, r as readMergedOptions, c as getDotenvCliOptions2Options, d as definePlugin } from './readMergedOptions-Nt0TR7dX.mjs';
+import 'execa';
+import 'fs-extra';
+import 'crypto';
+import 'path';
+import 'url';
+import '@commander-js/extra-typings';
+import 'nanoid';
+import 'dotenv';
+import './loader-DnhPeGfq.mjs';
+import 'package-directory';
+import 'yaml';
+import { z } from 'zod';
+import { c as resolveCommand, d as resolveShell, t as tokenize, s as shouldCapture, r as runCommand, b as buildSpawnEnv } from './spawnEnv-CN8a7cNR.mjs';
+import { m as maybePreserveNodeEvalArgv, c as composeNestedEnv, s as stripOne } from './invoke-DuRPU1oC.mjs';
+import { b as dotenvExpandFromProcessEnv } from './overlayEnv-Bs2kVayG.mjs';
+import { r as resolveCliOptions, b as baseGetDotenvCliOptions } from './resolveCliOptions-TFRzhB2c.mjs';
+
+/**
+ * Trace child env composition with redaction and entropy warnings.
+ * Presentation-only: does not mutate env; writes lines via the provided sink.
+ */
+function traceChildEnv(opts) {
+    const { parentEnv, dotenv, keys, redact, redactPatterns, warnEntropy, entropyThreshold, entropyMinLength, entropyWhitelist, write, } = opts;
+    const parentKeys = Object.keys(parentEnv);
+    const dotenvKeys = Object.keys(dotenv);
+    const allKeys = Array.from(new Set([...parentKeys, ...dotenvKeys])).sort();
+    const effectiveKeys = Array.isArray(keys) && keys.length > 0 ? keys : allKeys;
+    // Redaction options for display
+    const redOpts = {};
+    if (redact) {
+        redOpts.redact = true;
+        if (Array.isArray(redactPatterns))
+            redOpts.redactPatterns = redactPatterns;
+    }
+    // Entropy warning options
+    const entOpts = {};
+    if (typeof warnEntropy === 'boolean')
+        entOpts.warnEntropy = warnEntropy;
+    if (typeof entropyThreshold === 'number')
+        entOpts.entropyThreshold = entropyThreshold;
+    if (typeof entropyMinLength === 'number')
+        entOpts.entropyMinLength = entropyMinLength;
+    if (Array.isArray(entropyWhitelist))
+        entOpts.entropyWhitelist = entropyWhitelist;
+    for (const k of effectiveKeys) {
+        const parentVal = parentEnv[k];
+        const dot = dotenv[k];
+        const final = dot !== undefined ? dot : parentVal;
+        const origin = dot !== undefined
+            ? 'dotenv'
+            : parentVal !== undefined
+                ? 'parent'
+                : 'unset';
+        const tripleIn = {};
+        if (parentVal !== undefined)
+            tripleIn.parent = parentVal;
+        if (dot !== undefined)
+            tripleIn.dotenv = dot;
+        if (final !== undefined)
+            tripleIn.final = final;
+        const triple = redactTriple(k, tripleIn, redOpts);
+        write(`[trace] key=${k} origin=${origin} parent=${triple.parent ?? ''} dotenv=${triple.dotenv ?? ''} final=${triple.final ?? ''}`);
+        maybeWarnEntropy(k, final, origin, entOpts, (line) => {
+            write(line);
+        });
+    }
+}
+
+/** src/plugins/cmd/actions/runner.ts
+ * Unified runner for cmd subcommand and parent alias.
+ * - Resolves command via scripts
+ * - Emits --trace diagnostics (centralized helper with redaction/entropy)
+ * - Preserves Node -e argv under shell-off
+ * - Normalizes child env and honors capture
+ */
+/**
+ * Execute a command using the current CLI context.
+ * Resolves command/shell via scripts, emits traces, and handles execution.
+ *
+ * @param cli - The CLI instance.
+ * @param merged - Merged CLI options.
+ * @param command - Command string or array of args.
+ * @param _opts - Execution options (e.g. origin label).
+ */
+async function runCmdWithContext(cli, merged, command, _opts) {
+    const { logger, debug, capture, scripts: scriptsCfg, shell: shellPref, trace, redact, redactPatterns, warnEntropy, entropyThreshold, entropyMinLength, entropyWhitelist, } = merged;
+    const dotenv = cli.getCtx().dotenv;
+    // Build input string and note original argv (when available).
+    const parts = Array.isArray(command) ? command.map(String) : [];
+    const inputStr = Array.isArray(command) ? parts.join(' ') : command;
+    // Resolve command and shell from scripts/global.
+    const resolved = resolveCommand(scriptsCfg, inputStr);
+    if (debug)
+        logger.debug('\n*** command ***\n', `'${resolved}'`);
+    const shellSetting = resolveShell(scriptsCfg, inputStr, shellPref);
+    // Diagnostics: --trace [keys...]
+    const traceOpt = trace;
+    if (traceOpt) {
+        traceChildEnv({
+            parentEnv: process.env,
+            dotenv,
+            ...(Array.isArray(traceOpt) ? { keys: traceOpt } : {}),
+            ...(redact ? { redact: true } : {}),
+            ...(redact && Array.isArray(redactPatterns) ? { redactPatterns } : {}),
+            ...(typeof warnEntropy === 'boolean' ? { warnEntropy } : {}),
+            ...(typeof entropyThreshold === 'number' ? { entropyThreshold } : {}),
+            ...(typeof entropyMinLength === 'number' ? { entropyMinLength } : {}),
+            ...(Array.isArray(entropyWhitelist) ? { entropyWhitelist } : {}),
+            write: (line) => {
+                try {
+                    process.stderr.write(line + '\n');
+                }
+                catch {
+                    /* ignore */
+                }
+            },
+        });
+    }
+    // Preserve Node -e argv under shell-off when the script did not remap input.
+    let commandArg = resolved;
+    if (shellSetting === false && resolved === inputStr) {
+        if (Array.isArray(command)) {
+            commandArg = maybePreserveNodeEvalArgv(parts);
+        }
+        else {
+            const toks = tokenize(inputStr, { preserveDoubledQuotes: true });
+            if (toks.length >= 3 &&
+                (toks[0] ?? '').toLowerCase() === 'node' &&
+                (toks[1] === '-e' || toks[1] === '--eval')) {
+                toks[2] = stripOne(toks[2] ?? '');
+                commandArg = toks;
+            }
+        }
+    }
+    // Child env: compose nested bag and sanitize.
+    const childOverlay = composeNestedEnv(merged, dotenv);
+    const captureFlag = shouldCapture(capture);
+    let exit;
+    try {
+        exit = await runCommand(commandArg, shellSetting, {
+            env: buildSpawnEnv(process.env, childOverlay),
+            stdio: captureFlag ? 'pipe' : 'inherit',
+        });
+    }
+    catch (e) {
+        // Under unit tests, execa may be mocked to return undefined which causes
+        // pickResult access to throw. Treat as success to allow call-count assertions.
+        if (process.env.VITEST_WORKER_ID)
+            return 0;
+        throw e;
+    }
+    return typeof exit === 'number' ? exit : 0;
+}
+
+/**
+ * Attach the default "cmd" subcommand action.
+ * Mirrors the prior inline implementation in cmd/index.ts.
+ */
+const attachCmdDefaultAction = (cli, cmd, aliasKey) => {
+    cmd.action(async function (...allArgs) {
+        // Commander passes: [...positionals, options, thisCommand]
+        const thisCommand = allArgs[allArgs.length - 1];
+        const commandParts = allArgs[0];
+        const args = Array.isArray(commandParts)
+            ? commandParts.map(String)
+            : [];
+        // No-op when invoked as the default command with no args.
+        if (args.length === 0)
+            return;
+        const merged = readMergedOptions(thisCommand);
+        const parent = thisCommand.parent;
+        if (!parent)
+            throw new Error('parent command not found');
+        // Conflict detection: if an alias option is present on parent, do not
+        // also accept positional cmd args.
+        if (aliasKey) {
+            const p = parent;
+            const pv = typeof p.optsWithGlobals === 'function'
+                ? p.optsWithGlobals()
+                : typeof p.opts === 'function'
+                    ? p.opts()
+                    : {};
+            const ov = pv[aliasKey];
+            if (ov !== undefined) {
+                merged.logger.error(`--${aliasKey} option conflicts with cmd subcommand.`);
+                process.exit(0);
+            }
+        }
+        await runCmdWithContext(cli, merged, args);
+    });
+};
+
+/**
+ * Attach options/arguments for the cmd plugin mount.
+ *
+ * Note: the plugin description is owned by `src/plugins/cmd/index.ts` and must
+ * not be set here.
+ *
+ * @param cli - The `cmd` command mount.
+ * @returns The same `cli` instance for chaining.
+ *
+ * @internal
+ */
+function attachCmdOptions(cli) {
+    return cli
+        .enablePositionalOptions()
+        .passThroughOptions()
+        .argument('[command...]');
+}
+
+/**
+ * Install the parent-level invoker (alias) for the cmd plugin.
+ * Unifies naming with batch attachParentInvoker; behavior unchanged.
+ */
+const attachCmdParentInvoker = (cli, options, plugin) => {
+    const dbg = (...args) => {
+        if (process.env.GETDOTENV_DEBUG) {
+            try {
+                const line = args
+                    .map((a) => (typeof a === 'string' ? a : JSON.stringify(a)))
+                    .join(' ');
+                process.stderr.write(`[getdotenv:alias] ${line}\n`);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    };
+    const aliasSpec = typeof options.optionAlias === 'string'
+        ? { flags: options.optionAlias, description: undefined}
+        : options.optionAlias;
+    if (!aliasSpec)
+        return;
+    const deriveKey = (flags) => {
+        // install alias option
+        if (process.env.GETDOTENV_DEBUG) {
+            console.error('[getdotenv:alias] install alias option', flags);
+        }
+        const long = flags.split(/[ ,|]+/).find((f) => f.startsWith('--')) ?? '--cmd';
+        const name = long.replace(/^--/, '');
+        return name.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
+    };
+    const aliasKey = deriveKey(aliasSpec.flags);
+    // Expose the option on the parent (root) command.
+    const parentCmd = cli.parent ??
+        cli;
+    const desc = aliasSpec.description ??
+        'alias of cmd subcommand; provide command tokens (variadic)';
+    parentCmd.option(aliasSpec.flags, desc);
+    // Tag the just-added parent option for grouped help rendering at the root.
+    const optsArr = parentCmd.options;
+    if (optsArr.length > 0) {
+        const last = optsArr[optsArr.length - 1];
+        if (last)
+            parentCmd.setOptionGroup(last, 'plugin:cmd');
+    }
+    // Shared alias executor for either preAction or preSubcommand hooks.
+    // Ensure we only execute once even if both hooks fire in a single parse.
+    const aliasState = { handled: false };
+    const maybeRun = async (thisCommand) => {
+        dbg('maybeRun:start');
+        // Read plugin config expand default; fall back to undefined (handled in maybeRunAlias)
+        let expandDefault = undefined;
+        try {
+            const cfg = plugin.readConfig(cli);
+            if (typeof cfg.expand === 'boolean')
+                expandDefault = cfg.expand;
+        }
+        catch {
+            /* config may be unavailable before resolve; default handled downstream */
+        }
+        // Inspect parent options and rawArgs to detect alias-only invocation.
+        if (aliasState.handled)
+            return;
+        const cmd = thisCommand;
+        dbg('maybeRun:rawArgs', cmd.rawArgs ?? []);
+        const raw = typeof cmd.opts === 'function' ? cmd.opts() : {};
+        const val = raw[aliasKey];
+        const provided = typeof val === 'string'
+            ? val.length > 0
+            : Array.isArray(val)
+                ? val.length > 0
+                : false;
+        dbg('maybeRun:aliasKey', aliasKey, 'provided', provided, 'value', val);
+        if (!provided)
+            return;
+        const childNames = cmd.commands.flatMap((c) => [c.name(), ...c.aliases()]);
+        dbg('maybeRun:childNames', childNames);
+        const hasSub = (cmd.rawArgs ?? []).some((t) => childNames.includes(t));
+        dbg('maybeRun:hasSub', hasSub);
+        if (hasSub)
+            return; // do not run alias when an explicit subcommand is present
+        aliasState.handled = true;
+        // Merge CLI options and resolve dotenv context for this invocation.
+        const { merged } = resolveCliOptions(raw, baseGetDotenvCliOptions, process.env.getDotenvCliOptions);
+        const serviceOptions = getDotenvCliOptions2Options(merged);
+        await cli.resolveAndLoad(serviceOptions);
+        // Build input string and apply optional expansion (by config default).
+        const joined = typeof val === 'string'
+            ? val
+            : Array.isArray(val)
+                ? val.map(String).join(' ')
+                : '';
+        const effectiveExpand = expandDefault !== false;
+        const expanded = dotenvExpandFromProcessEnv(joined);
+        const input = effectiveExpand && expanded !== undefined ? expanded : joined;
+        // Hand off to shared runner and terminate (except under tests).
+        const exitCode = await runCmdWithContext(cli, merged, input);
+        const underTests = process.env.GETDOTENV_TEST === '1' ||
+            typeof process.env.VITEST_WORKER_ID === 'string';
+        if (!underTests) {
+            process.exit(typeof exitCode === 'number' ? exitCode : 0);
+        }
+    };
+    parentCmd.hook('preAction', async (thisCommand) => {
+        await maybeRun(thisCommand);
+    });
+    parentCmd.hook('preSubcommand', async (thisCommand) => {
+        await maybeRun(thisCommand);
+    });
+};
+
+/**
+ * Zod schema for cmd plugin configuration.
+ */
+const cmdPluginConfigSchema = z
+    .object({
+    /** When true, expand the alias value before execution (default behavior when omitted). */
+    expand: z.boolean().optional(),
+})
+    .strict();
+
+/**
+ * @packageDocumentation
+ * Cmd plugin subpath. Provides the `cmd` subcommand and an optional parent‑level
+ * alias to execute a command within the resolved dotenv context.
+ */
+/**
+ * Cmd plugin: executes a command using the current getdotenv CLI context.
+ * Registers the `cmd` subcommand and optionally attaches a parent-level alias (e.g. `-c`).
+ *
+ * @param options - Plugin configuration options.
+ */
+const cmdPlugin = (options = {}) => {
+    const plugin = definePlugin({
+        ns: 'cmd',
+        configSchema: cmdPluginConfigSchema,
+        setup(cli) {
+            const aliasSpec = typeof options.optionAlias === 'string'
+                ? { flags: options.optionAlias}
+                : options.optionAlias;
+            const deriveKey = (flags) => {
+                const long = flags.split(/[ ,|]+/).find((f) => f.startsWith('--')) ?? '--cmd';
+                const name = long.replace(/^--/, '');
+                return name.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
+            };
+            const aliasKey = aliasSpec ? deriveKey(aliasSpec.flags) : undefined;
+            // Mount is the command ('cmd'); attach default action.
+            cli.description('Execute command according to the --shell option, conflicts with --command option (default subcommand)');
+            // Options/arguments (positional payload, argv routing) are attached separately.
+            attachCmdOptions(cli);
+            attachCmdDefaultAction(cli, cli, aliasKey);
+            // Parent-attached option alias (optional, unified naming).
+            if (aliasSpec !== undefined) {
+                attachCmdParentInvoker(cli, options, plugin);
+            }
+            return undefined;
+        },
+    });
+    return plugin;
+};
+
+export { cmdPlugin as c, traceChildEnv as t };

package/dist/chunks/index-BpCF5UKx.mjs

@@ -0,0 +1,272 @@
+import { t as toUtf8, i as fromUtf8 } from './index-CeCufHlm.mjs';
+import './readMergedOptions-Nt0TR7dX.mjs';
+import 'zod';
+import '@commander-js/extra-typings';
+import './overlayEnv-Bs2kVayG.mjs';
+import 'fs-extra';
+import './loadModuleDefault-Dj8B3Stt.mjs';
+import 'crypto';
+import 'path';
+import 'url';
+import 'nanoid';
+import 'dotenv';
+import './loader-DnhPeGfq.mjs';
+import 'package-directory';
+import 'yaml';
+import 'execa';
+import 'buffer';
+import 'os';
+import 'node:fs/promises';
+import 'http';
+import 'https';
+import 'stream';
+import 'process';
+import 'node:fs';
+
+class EventStreamSerde {
+    marshaller;
+    serializer;
+    deserializer;
+    serdeContext;
+    defaultContentType;
+    constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, }) {
+        this.marshaller = marshaller;
+        this.serializer = serializer;
+        this.deserializer = deserializer;
+        this.serdeContext = serdeContext;
+        this.defaultContentType = defaultContentType;
+    }
+    async serializeEventStream({ eventStream, requestSchema, initialRequest, }) {
+        const marshaller = this.marshaller;
+        const eventStreamMember = requestSchema.getEventStreamMember();
+        const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
+        const serializer = this.serializer;
+        const defaultContentType = this.defaultContentType;
+        const initialRequestMarker = Symbol("initialRequestMarker");
+        const eventStreamIterable = {
+            async *[Symbol.asyncIterator]() {
+                if (initialRequest) {
+                    const headers = {
+                        ":event-type": { type: "string", value: "initial-request" },
+                        ":message-type": { type: "string", value: "event" },
+                        ":content-type": { type: "string", value: defaultContentType },
+                    };
+                    serializer.write(requestSchema, initialRequest);
+                    const body = serializer.flush();
+                    yield {
+                        [initialRequestMarker]: true,
+                        headers,
+                        body,
+                    };
+                }
+                for await (const page of eventStream) {
+                    yield page;
+                }
+            },
+        };
+        return marshaller.serialize(eventStreamIterable, (event) => {
+            if (event[initialRequestMarker]) {
+                return {
+                    headers: event.headers,
+                    body: event.body,
+                };
+            }
+            const unionMember = Object.keys(event).find((key) => {
+                return key !== "__type";
+            }) ?? "";
+            const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
+            const headers = {
+                ":event-type": { type: "string", value: eventType },
+                ":message-type": { type: "string", value: "event" },
+                ":content-type": { type: "string", value: explicitPayloadContentType ?? defaultContentType },
+                ...additionalHeaders,
+            };
+            return {
+                headers,
+                body,
+            };
+        });
+    }
+    async deserializeEventStream({ response, responseSchema, initialResponseContainer, }) {
+        const marshaller = this.marshaller;
+        const eventStreamMember = responseSchema.getEventStreamMember();
+        const unionSchema = responseSchema.getMemberSchema(eventStreamMember);
+        const memberSchemas = unionSchema.getMemberSchemas();
+        const initialResponseMarker = Symbol("initialResponseMarker");
+        const asyncIterable = marshaller.deserialize(response.body, async (event) => {
+            const unionMember = Object.keys(event).find((key) => {
+                return key !== "__type";
+            }) ?? "";
+            const body = event[unionMember].body;
+            if (unionMember === "initial-response") {
+                const dataObject = await this.deserializer.read(responseSchema, body);
+                delete dataObject[eventStreamMember];
+                return {
+                    [initialResponseMarker]: true,
+                    ...dataObject,
+                };
+            }
+            else if (unionMember in memberSchemas) {
+                const eventStreamSchema = memberSchemas[unionMember];
+                if (eventStreamSchema.isStructSchema()) {
+                    const out = {};
+                    let hasBindings = false;
+                    for (const [name, member] of eventStreamSchema.structIterator()) {
+                        const { eventHeader, eventPayload } = member.getMergedTraits();
+                        hasBindings = hasBindings || Boolean(eventHeader || eventPayload);
+                        if (eventPayload) {
+                            if (member.isBlobSchema()) {
+                                out[name] = body;
+                            }
+                            else if (member.isStringSchema()) {
+                                out[name] = (this.serdeContext?.utf8Encoder ?? toUtf8)(body);
+                            }
+                            else if (member.isStructSchema()) {
+                                out[name] = await this.deserializer.read(member, body);
+                            }
+                        }
+                        else if (eventHeader) {
+                            const value = event[unionMember].headers[name]?.value;
+                            if (value != null) {
+                                if (member.isNumericSchema()) {
+                                    if (value && typeof value === "object" && "bytes" in value) {
+                                        out[name] = BigInt(value.toString());
+                                    }
+                                    else {
+                                        out[name] = Number(value);
+                                    }
+                                }
+                                else {
+                                    out[name] = value;
+                                }
+                            }
+                        }
+                    }
+                    if (hasBindings) {
+                        return {
+                            [unionMember]: out,
+                        };
+                    }
+                }
+                return {
+                    [unionMember]: await this.deserializer.read(eventStreamSchema, body),
+                };
+            }
+            else {
+                return {
+                    $unknown: event,
+                };
+            }
+        });
+        const asyncIterator = asyncIterable[Symbol.asyncIterator]();
+        const firstEvent = await asyncIterator.next();
+        if (firstEvent.done) {
+            return asyncIterable;
+        }
+        if (firstEvent.value?.[initialResponseMarker]) {
+            if (!responseSchema) {
+                throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
+            }
+            for (const [key, value] of Object.entries(firstEvent.value)) {
+                initialResponseContainer[key] = value;
+            }
+        }
+        return {
+            async *[Symbol.asyncIterator]() {
+                if (!firstEvent?.value?.[initialResponseMarker]) {
+                    yield firstEvent.value;
+                }
+                while (true) {
+                    const { done, value } = await asyncIterator.next();
+                    if (done) {
+                        break;
+                    }
+                    yield value;
+                }
+            },
+        };
+    }
+    writeEventBody(unionMember, unionSchema, event) {
+        const serializer = this.serializer;
+        let eventType = unionMember;
+        let explicitPayloadMember = null;
+        let explicitPayloadContentType;
+        const isKnownSchema = (() => {
+            const struct = unionSchema.getSchema();
+            return struct[4].includes(unionMember);
+        })();
+        const additionalHeaders = {};
+        if (!isKnownSchema) {
+            const [type, value] = event[unionMember];
+            eventType = type;
+            serializer.write(15, value);
+        }
+        else {
+            const eventSchema = unionSchema.getMemberSchema(unionMember);
+            if (eventSchema.isStructSchema()) {
+                for (const [memberName, memberSchema] of eventSchema.structIterator()) {
+                    const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
+                    if (eventPayload) {
+                        explicitPayloadMember = memberName;
+                    }
+                    else if (eventHeader) {
+                        const value = event[unionMember][memberName];
+                        let type = "binary";
+                        if (memberSchema.isNumericSchema()) {
+                            if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) {
+                                type = "integer";
+                            }
+                            else {
+                                type = "long";
+                            }
+                        }
+                        else if (memberSchema.isTimestampSchema()) {
+                            type = "timestamp";
+                        }
+                        else if (memberSchema.isStringSchema()) {
+                            type = "string";
+                        }
+                        else if (memberSchema.isBooleanSchema()) {
+                            type = "boolean";
+                        }
+                        if (value != null) {
+                            additionalHeaders[memberName] = {
+                                type,
+                                value,
+                            };
+                            delete event[unionMember][memberName];
+                        }
+                    }
+                }
+                if (explicitPayloadMember !== null) {
+                    const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
+                    if (payloadSchema.isBlobSchema()) {
+                        explicitPayloadContentType = "application/octet-stream";
+                    }
+                    else if (payloadSchema.isStringSchema()) {
+                        explicitPayloadContentType = "text/plain";
+                    }
+                    serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
+                }
+                else {
+                    serializer.write(eventSchema, event[unionMember]);
+                }
+            }
+            else {
+                throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
+            }
+        }
+        const messageSerialization = serializer.flush();
+        const body = typeof messageSerialization === "string"
+            ? (this.serdeContext?.utf8Decoder ?? fromUtf8)(messageSerialization)
+            : messageSerialization;
+        return {
+            body,
+            eventType,
+            explicitPayloadContentType,
+            additionalHeaders,
+        };
+    }
+}
+
+export { EventStreamSerde };