@humeai/audio-decisions 0.0.1 → 0.1.0

package/dist/cjs/audio-helpers/results.js

@@ -0,0 +1,187 @@
+"use strict";
+// Maintained by hand and listed in .fernignore, so SDK regeneration leaves it in place.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChunkedDecisionsResult = void 0;
+exports.sendChunks = sendChunks;
+exports.collectResults = collectResults;
+const BadRequestError_js_1 = require("../api/errors/BadRequestError.js");
+const index_js_1 = require("../core/schemas/index.js");
+const DecisionsError_js_1 = require("../errors/DecisionsError.js");
+const checks_js_1 = require("./checks.js");
+const chunks_js_1 = require("./chunks.js");
+/** The outcome of every chunk's request, in the order of the chunks. */
+class ChunkedDecisionsResult {
+    /**
+     * @param chunks The results of a job, such as those collected from `iterCreateChunked`, in order.
+     * @param startMs The `startMs` the job was given.
+     * @throws {TypeError} If `startMs` is not a safe integer.
+     */
+    constructor(chunks, startMs) {
+        this.startMs = startMs === undefined ? 0 : (0, checks_js_1.checkInteger)("startMs", startMs);
+        this.chunks = Object.freeze(Array.from(chunks));
+    }
+    /** Each chunk's response, or undefined for a chunk without one, in the order of the chunks. */
+    get responses() {
+        return this.chunks.map((chunk) => chunk.response);
+    }
+    /** Whether every chunk's request succeeded. */
+    get complete() {
+        return this.chunks.every((chunk) => chunk.status === "succeeded");
+    }
+    /**
+     * The `startMs` to give a new job, with the same `endMs`, so that it sends again the audio from
+     * the chunk that stopped this job to the end. Earlier chunks that failed because their audio could
+     * not be decoded are not sent again. A WAV chunk's `endMs` is rounded to the millisecond, so the
+     * new job can skip or repeat a few samples where it starts. Undefined when no chunk stopped the job.
+     */
+    get resumeMs() {
+        const rule = new StopRule();
+        for (let position = 0; position < this.chunks.length; position++) {
+            rule.record(this.chunks[position]);
+            if (rule.stopped) {
+                // An MP3 chunk's startMs includes frames repeated from before it, so resuming there
+                // would send those again as new audio.
+                return position > 0 ? this.chunks[position - 1].endMs : this.startMs;
+            }
+        }
+        return undefined;
+    }
+}
+exports.ChunkedDecisionsResult = ChunkedDecisionsResult;
+/**
+ * Sends each chunk of `upload.file` with `create`, as `iterCreateChunked` describes. The options are
+ * checked by this call, and the file when iteration starts.
+ */
+function sendChunks(create, _a, signal) {
+    var { request, file } = _a, options = __rest(_a, ["request", "file"]);
+    return send(create, request, (0, chunks_js_1.prepareChunks)(file, options), signal);
+}
+function send(create, request, planRecording, signal) {
+    return __asyncGenerator(this, arguments, function* send_1() {
+        // Planning reads and checks the whole file, so a file that cannot be split is rejected before
+        // any request is sent.
+        const { filename, contentType, chunks } = yield __await(planRecording(signal));
+        const rule = new StopRule();
+        // A chunk's data is copied only when it is sent, so the chunks after a stop cost nothing.
+        for (const chunk of chunks) {
+            const position = { index: chunk.index, startMs: chunk.startMs, endMs: chunk.endMs };
+            let result = Object.assign(Object.assign({}, position), { status: "not_attempted" });
+            if (!rule.stopped) {
+                try {
+                    const response = yield __await(create({
+                        request,
+                        file: { data: chunk.build(), filename, contentType },
+                        // The chunks were mixed down when they were planned.
+                        downmixStrategy: "none",
+                    }));
+                    result = Object.assign(Object.assign({}, position), { status: "succeeded", response });
+                }
+                catch (raised) {
+                    // An abort ends the job rather than failing one chunk. Anything other than a
+                    // DecisionsError did not come from the request, so it is not a chunk's outcome either,
+                    // except a ParseError: the generated client throws one when a response body is not the
+                    // JSON it expects for the status, such as a proxy's HTML error page, and the status is
+                    // lost with it.
+                    if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || !(raised instanceof DecisionsError_js_1.DecisionsError || raised instanceof index_js_1.ParseError)) {
+                        throw raised;
+                    }
+                    const error = raised instanceof index_js_1.ParseError
+                        ? new DecisionsError_js_1.DecisionsError({ message: "The API's response could not be read.", cause: raised })
+                        : raised;
+                    result = Object.assign(Object.assign({}, position), { status: "failed", error });
+                }
+            }
+            rule.record(result);
+            yield yield __await(result);
+        }
+    });
+}
+/** Collects the results of `iterCreateChunked` for `createChunked`. */
+function collectResults(results, startMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, results_1, results_1_1;
+        var _b, e_1, _c, _d;
+        const collected = [];
+        try {
+            for (_a = true, results_1 = __asyncValues(results); results_1_1 = yield results_1.next(), _b = results_1_1.done, !_b; _a = true) {
+                _d = results_1_1.value;
+                _a = false;
+                const result = _d;
+                collected.push(result);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_a && !_b && (_c = results_1.return)) yield _c.call(results_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return new ChunkedDecisionsResult(collected, startMs);
+    });
+}
+// Sending chunks and finding resumeMs in a finished result must agree on which chunk stopped the job,
+// so both feed the chunks through this in order.
+class StopRule {
+    constructor() {
+        this._stopped = false;
+        this.anySucceeded = false;
+    }
+    get stopped() {
+        return this._stopped;
+    }
+    record(chunk) {
+        // A decode failure can come from one damaged stretch of the recording, but until some chunk has
+        // decoded, the whole file is the likelier cause and every remaining chunk would fail the same
+        // way. Any other error, including codes the API adds later, is assumed to fail every remaining
+        // chunk, so sending them would only spend requests. The generated client has already retried
+        // rate limits and server errors before throwing.
+        const failsAlone = this.anySucceeded &&
+            chunk.error instanceof BadRequestError_js_1.BadRequestError &&
+            chunk.error.body.code === "audio_decode_failed";
+        if (chunk.status === "failed" && !failsAlone) {
+            this._stopped = true;
+        }
+        this.anySucceeded || (this.anySucceeded = chunk.status === "succeeded");
+    }
+}

package/dist/cjs/audio-helpers/wav.d.ts

@@ -0,0 +1,21 @@
+export interface WavAudio {
+    /** The fmt chunk body written into every chunk. */
+    readonly fmt: Uint8Array;
+    readonly channels: number;
+    /** The speaker of each channel, from an extensible header, or 0 when the header names none. */
+    readonly channelMask: number;
+    readonly sampleRate: number;
+    /** Bytes in one sample of one channel. */
+    readonly sampleWidth: number;
+    readonly isFloat: boolean;
+    readonly dataStart: number;
+    readonly sampleCount: number;
+    /** Bytes in one sample of every channel. */
+    readonly frameBytes: number;
+}
+export declare function isWav(data: Uint8Array): boolean;
+export declare function parseWav(data: Uint8Array): WavAudio;
+/** Describes samples that start at offset 0 of their own buffer. */
+export declare function samplesWav({ channels, sampleRate, sampleWidth, isFloat, sampleCount, }: Pick<WavAudio, "channels" | "sampleRate" | "sampleWidth" | "isFloat" | "sampleCount">): WavAudio;
+/** Builds a WAV file holding samples `start` to `end` and none of the source's other chunks. */
+export declare function wavChunk(data: Uint8Array, wav: WavAudio, start: number, end: number): Uint8Array;

package/dist/cjs/audio-helpers/wav.js

@@ -0,0 +1,167 @@
+"use strict";
+// Maintained by hand and listed in .fernignore, so SDK regeneration leaves it in place.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWav = isWav;
+exports.parseWav = parseWav;
+exports.samplesWav = samplesWav;
+exports.wavChunk = wavChunk;
+const bytes_js_1 = require("./bytes.js");
+const errors_js_1 = require("./errors.js");
+const CONVERT_COMMAND = "ffmpeg -i input.wav -c:a pcm_s16le output.wav";
+const PCM = 0x0001;
+const IEEE_FLOAT = 0x0003;
+const EXTENSIBLE = 0xfffe;
+// An extensible header's subformat GUID is the format tag it stands for followed by these bytes.
+const SUBFORMAT_GUID_SUFFIX = [0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71];
+// Writers that cannot seek back to fill in the size, such as ffmpeg writing to a pipe, leave this.
+const UNKNOWN_SIZE = 0xffffffff;
+const SAMPLE_WIDTHS = {
+    [PCM]: [1, 2, 3, 4],
+    [IEEE_FLOAT]: [4, 8],
+};
+const EXTENSIBLE_FMT_BYTES = 40;
+// Chunks are at least 1 ms long, so at this rate every chunk holds at least one sample.
+const MIN_SAMPLE_RATE = 1000;
+// The resampling filter grows with the sample rate, so without a limit a few bytes of header could
+// demand gigabytes. No recording format in common use goes above this rate.
+const MAX_SAMPLE_RATE = 768000;
+function isWav(data) {
+    return (0, bytes_js_1.hasBytes)(data, 0, "RIFF") || (0, bytes_js_1.hasBytes)(data, 0, "RF64");
+}
+function parseWav(data) {
+    if ((0, bytes_js_1.hasBytes)(data, 0, "RF64")) {
+        throw unsupported("RF64 files are not supported");
+    }
+    if (data.length < 12 || !(0, bytes_js_1.hasBytes)(data, 0, "RIFF") || !(0, bytes_js_1.hasBytes)(data, 8, "WAVE")) {
+        throw unsupported("no RIFF WAVE header");
+    }
+    const view = (0, bytes_js_1.dataView)(data);
+    const riffSize = view.getUint32(4, true);
+    let offset = 12;
+    let format;
+    for (;;) {
+        if (offset + 8 > data.length) {
+            throw unsupported("no data chunk");
+        }
+        const isData = (0, bytes_js_1.hasBytes)(data, offset, "data");
+        const isFmt = (0, bytes_js_1.hasBytes)(data, offset, "fmt ");
+        let size = view.getUint32(offset + 4, true);
+        offset += 8;
+        if (isData) {
+            if (format === undefined) {
+                throw unsupported("the data chunk comes before the fmt chunk");
+            }
+            const available = data.length - offset;
+            // Writers such as libsndfile fill in the sizes only when they close the file, so a recording
+            // that was never closed declares no audio in a RIFF chunk that ends before it. Any other file
+            // that declares no audio has none, including one whose RIFF size is unknown, because chunks
+            // such as metadata can follow the data.
+            const unclosed = size === 0 && 8 + riffSize <= offset;
+            // A file cut short is read as far as it goes, up to its last whole sample.
+            size = unclosed || size === UNKNOWN_SIZE ? available : Math.min(size, available);
+            return Object.assign(Object.assign({}, format), { dataStart: offset, sampleCount: Math.floor(size / format.frameBytes) });
+        }
+        if (isFmt) {
+            format = parseFormat(data.subarray(offset, offset + Math.min(size, EXTENSIBLE_FMT_BYTES)));
+        }
+        // Chunks with an odd size are followed by a padding byte.
+        offset += size + (size % 2);
+    }
+}
+/** Describes samples that start at offset 0 of their own buffer. */
+function samplesWav({ channels, sampleRate, sampleWidth, isFloat, sampleCount, }) {
+    const fmt = fmtBody(isFloat ? IEEE_FLOAT : PCM, channels, sampleRate, sampleWidth, sampleWidth * 8, new Uint8Array(0));
+    return {
+        fmt,
+        channels,
+        channelMask: 0,
+        sampleRate,
+        sampleWidth,
+        isFloat,
+        dataStart: 0,
+        sampleCount,
+        frameBytes: sampleWidth * channels,
+    };
+}
+/** Builds a WAV file holding samples `start` to `end` and none of the source's other chunks. */
+function wavChunk(data, wav, start, end) {
+    const first = wav.dataStart + start * wav.frameBytes;
+    const size = (end - start) * wav.frameBytes;
+    const padding = size % 2;
+    const headerBytes = 12 + 8 + wav.fmt.length + 8;
+    const chunk = new Uint8Array(headerBytes + size + padding);
+    const view = (0, bytes_js_1.dataView)(chunk);
+    (0, bytes_js_1.writeAscii)(chunk, 0, "RIFF");
+    view.setUint32(4, headerBytes - 8 + size + padding, true);
+    (0, bytes_js_1.writeAscii)(chunk, 8, "WAVEfmt ");
+    view.setUint32(16, wav.fmt.length, true);
+    chunk.set(wav.fmt, 20);
+    (0, bytes_js_1.writeAscii)(chunk, 20 + wav.fmt.length, "data");
+    view.setUint32(24 + wav.fmt.length, size, true);
+    chunk.set(data.subarray(first, first + size), headerBytes);
+    return chunk;
+}
+function parseFormat(body) {
+    if (body.length < 16) {
+        throw unsupported("the fmt chunk is too short");
+    }
+    const view = (0, bytes_js_1.dataView)(body);
+    const headerTag = view.getUint16(0, true);
+    const channels = view.getUint16(2, true);
+    const sampleRate = view.getUint32(4, true);
+    const blockAlign = view.getUint16(12, true);
+    const bits = view.getUint16(14, true);
+    let tag = headerTag;
+    if (tag === EXTENSIBLE) {
+        if (body.length < EXTENSIBLE_FMT_BYTES ||
+            SUBFORMAT_GUID_SUFFIX.some((byte, index) => body[26 + index] !== byte)) {
+            throw unsupported("unknown extensible subformat");
+        }
+        tag = view.getUint16(24, true);
+    }
+    const widths = SAMPLE_WIDTHS[tag];
+    if (widths === undefined) {
+        throw unsupported(`format tag 0x${tag.toString(16).toUpperCase().padStart(4, "0")} is compressed or unknown`);
+    }
+    const sampleWidth = (bits + 7) >> 3;
+    if (!widths.includes(sampleWidth) || (tag === IEEE_FLOAT && bits !== sampleWidth * 8)) {
+        throw unsupported(`${bits}-bit ${tag === PCM ? "PCM" : "floating point"}`);
+    }
+    // Some writers leave the block size at 0 or 1, so it is recomputed for the chunks. A block larger
+    // than one sample per channel means padded samples, which would be cut in the wrong places. The
+    // recomputed block size must fit the header's 16 bits, and the byte rate its 32 bits.
+    const frameBytes = sampleWidth * channels;
+    if (channels < 1 || blockAlign > frameBytes || frameBytes > 0xffff || sampleRate * frameBytes > 0xffffffff) {
+        throw unsupported("the fmt chunk is inconsistent");
+    }
+    if (sampleRate < MIN_SAMPLE_RATE) {
+        throw unsupported(`${sampleRate} Hz is below the minimum of ${MIN_SAMPLE_RATE} Hz`);
+    }
+    if (sampleRate > MAX_SAMPLE_RATE) {
+        throw unsupported(`${sampleRate} Hz is above the maximum of ${MAX_SAMPLE_RATE} Hz`);
+    }
+    const extension = headerTag === EXTENSIBLE ? body.subarray(16, EXTENSIBLE_FMT_BYTES) : new Uint8Array(0);
+    const fmt = fmtBody(headerTag, channels, sampleRate, sampleWidth, bits, extension);
+    const channelMask = headerTag === EXTENSIBLE ? view.getUint32(20, true) : 0;
+    return { fmt, channels, channelMask, sampleRate, sampleWidth, isFloat: tag === IEEE_FLOAT, frameBytes };
+}
+function fmtBody(headerTag, channels, sampleRate, sampleWidth, bits, extension) {
+    const frameBytes = sampleWidth * channels;
+    // Formats other than PCM declare the size of their header extension, which is empty here.
+    const extensionBytes = headerTag === EXTENSIBLE ? extension.length : headerTag === PCM ? 0 : 2;
+    const fmt = new Uint8Array(16 + extensionBytes);
+    const view = (0, bytes_js_1.dataView)(fmt);
+    view.setUint16(0, headerTag, true);
+    view.setUint16(2, channels, true);
+    view.setUint32(4, sampleRate, true);
+    view.setUint32(8, sampleRate * frameBytes, true);
+    view.setUint16(12, frameBytes, true);
+    view.setUint16(14, bits, true);
+    if (headerTag === EXTENSIBLE) {
+        fmt.set(extension, 16);
+    }
+    return fmt;
+}
+function unsupported(reason) {
+    return new errors_js_1.UnsupportedAudioError(`The audio is not a supported WAV file (${reason}). Convert it first, for example with: ${CONVERT_COMMAND}`);
+}

package/dist/cjs/auth/HeaderAuthProvider.d.ts

@@ -0,0 +1,20 @@
+import * as core from "../core/index.js";
+declare const PARAM_KEY: "apiKey";
+export declare class HeaderAuthProvider implements core.AuthProvider {
+    private readonly options;
+    constructor(options: HeaderAuthProvider.Options);
+    static canCreate(options: Partial<HeaderAuthProvider.Options>): boolean;
+    getAuthRequest({ endpointMetadata, }?: {
+        endpointMetadata?: core.EndpointMetadata;
+    }): Promise<core.AuthRequest>;
+}
+export declare namespace HeaderAuthProvider {
+    const AUTH_SCHEME: "ApiKey";
+    const AUTH_CONFIG_ERROR_MESSAGE: string;
+    type Options = AuthOptions;
+    type AuthOptions = {
+        [PARAM_KEY]?: core.Supplier<string> | undefined;
+    };
+    function createInstance(options: Options): core.AuthProvider;
+}
+export {};

package/dist/cjs/auth/HeaderAuthProvider.js

@@ -0,0 +1,83 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderAuthProvider = void 0;
+const core = __importStar(require("../core/index.js"));
+const errors = __importStar(require("../errors/index.js"));
+const PARAM_KEY = "apiKey";
+const ENV_HEADER_KEY = "HUME_API_KEY";
+const HEADER_NAME = "X-Hume-Api-Key";
+class HeaderAuthProvider {
+    constructor(options) {
+        this.options = options;
+    }
+    static canCreate(options) {
+        var _a;
+        return (options === null || options === void 0 ? void 0 : options[PARAM_KEY]) != null || ((_a = process.env) === null || _a === void 0 ? void 0 : _a[ENV_HEADER_KEY]) != null;
+    }
+    getAuthRequest() {
+        return __awaiter(this, arguments, void 0, function* ({ endpointMetadata, } = {}) {
+            var _a, _b;
+            const headerValue = (_a = (yield core.Supplier.get(this.options[PARAM_KEY]))) !== null && _a !== void 0 ? _a : (_b = process.env) === null || _b === void 0 ? void 0 : _b[ENV_HEADER_KEY];
+            if (headerValue == null) {
+                throw new errors.DecisionsError({
+                    message: HeaderAuthProvider.AUTH_CONFIG_ERROR_MESSAGE,
+                });
+            }
+            return {
+                headers: { [HEADER_NAME]: headerValue },
+            };
+        });
+    }
+}
+exports.HeaderAuthProvider = HeaderAuthProvider;
+(function (HeaderAuthProvider) {
+    HeaderAuthProvider.AUTH_SCHEME = "ApiKey";
+    HeaderAuthProvider.AUTH_CONFIG_ERROR_MESSAGE = `Please provide '${PARAM_KEY}' when initializing the client, or set the '${ENV_HEADER_KEY}' environment variable`;
+    function createInstance(options) {
+        return new HeaderAuthProvider(options);
+    }
+    HeaderAuthProvider.createInstance = createInstance;
+})(HeaderAuthProvider || (exports.HeaderAuthProvider = HeaderAuthProvider = {}));

package/dist/cjs/auth/index.d.ts

@@ -0,0 +1 @@
+export { HeaderAuthProvider } from "./HeaderAuthProvider.js";

package/dist/cjs/auth/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderAuthProvider = void 0;
+var HeaderAuthProvider_js_1 = require("./HeaderAuthProvider.js");
+Object.defineProperty(exports, "HeaderAuthProvider", { enumerable: true, get: function () { return HeaderAuthProvider_js_1.HeaderAuthProvider; } });

package/dist/cjs/core/auth/AuthProvider.d.ts

@@ -0,0 +1,8 @@
+import type { EndpointMetadata } from "../fetcher/EndpointMetadata.js";
+import type { AuthRequest } from "./AuthRequest.js";
+export interface AuthProvider {
+    getAuthRequest(arg?: {
+        endpointMetadata?: EndpointMetadata;
+    }): Promise<AuthRequest>;
+}
+export declare function isAuthProvider(value: unknown): value is AuthProvider;

package/dist/cjs/core/auth/AuthProvider.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAuthProvider = isAuthProvider;
+function isAuthProvider(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "getAuthRequest" in value &&
+        typeof value.getAuthRequest === "function");
+}

package/dist/cjs/core/auth/AuthRequest.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Request parameters for authentication requests.
+ */
+export interface AuthRequest {
+    /**
+     * The headers to be included in the request.
+     */
+    headers: Record<string, string>;
+}

package/dist/cjs/core/auth/AuthRequest.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/core/auth/BasicAuth.d.ts

@@ -0,0 +1,8 @@
+export interface BasicAuth {
+    username?: string;
+    password?: string;
+}
+export declare const BasicAuth: {
+    toAuthorizationHeader: (basicAuth: BasicAuth | undefined) => string | undefined;
+    fromAuthorizationHeader: (header: string) => BasicAuth;
+};

package/dist/cjs/core/auth/BasicAuth.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicAuth = void 0;
+const base64_js_1 = require("../base64.js");
+const BASIC_AUTH_HEADER_PREFIX = /^Basic /i;
+exports.BasicAuth = {
+    toAuthorizationHeader: (basicAuth) => {
+        var _a, _b;
+        if (basicAuth == null) {
+            return undefined;
+        }
+        const username = (_a = basicAuth.username) !== null && _a !== void 0 ? _a : "";
+        const password = (_b = basicAuth.password) !== null && _b !== void 0 ? _b : "";
+        if (username === "" && password === "") {
+            return undefined;
+        }
+        const token = (0, base64_js_1.base64Encode)(`${username}:${password}`);
+        return `Basic ${token}`;
+    },
+    fromAuthorizationHeader: (header) => {
+        const credentials = header.replace(BASIC_AUTH_HEADER_PREFIX, "");
+        const decoded = (0, base64_js_1.base64Decode)(credentials);
+        const [username, ...passwordParts] = decoded.split(":");
+        const password = passwordParts.length > 0 ? passwordParts.join(":") : undefined;
+        if (username == null || password == null) {
+            throw new Error("Invalid basic auth");
+        }
+        return {
+            username,
+            password,
+        };
+    },
+};

package/dist/cjs/core/auth/BearerToken.d.ts

@@ -0,0 +1,7 @@
+export type BearerToken = string;
+declare function toAuthorizationHeader(token: string | undefined): string | undefined;
+export declare const BearerToken: {
+    toAuthorizationHeader: typeof toAuthorizationHeader;
+    fromAuthorizationHeader: (header: string) => BearerToken;
+};
+export {};

package/dist/cjs/core/auth/BearerToken.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BearerToken = void 0;
+const BEARER_AUTH_HEADER_PREFIX = /^Bearer /i;
+function toAuthorizationHeader(token) {
+    if (token == null) {
+        return undefined;
+    }
+    return `Bearer ${token}`;
+}
+exports.BearerToken = {
+    toAuthorizationHeader: toAuthorizationHeader,
+    fromAuthorizationHeader: (header) => {
+        return header.replace(BEARER_AUTH_HEADER_PREFIX, "").trim();
+    },
+};

package/dist/cjs/core/auth/NoOpAuthProvider.d.ts

@@ -0,0 +1,5 @@
+import type { AuthProvider } from "./AuthProvider.js";
+import type { AuthRequest } from "./AuthRequest.js";
+export declare class NoOpAuthProvider implements AuthProvider {
+    getAuthRequest(): Promise<AuthRequest>;
+}

package/dist/cjs/core/auth/NoOpAuthProvider.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoOpAuthProvider = void 0;
+class NoOpAuthProvider {
+    getAuthRequest() {
+        return Promise.resolve({ headers: {} });
+    }
+}
+exports.NoOpAuthProvider = NoOpAuthProvider;

package/dist/cjs/core/auth/index.d.ts

@@ -0,0 +1,5 @@
+export { type AuthProvider, isAuthProvider } from "./AuthProvider.js";
+export type { AuthRequest } from "./AuthRequest.js";
+export { BasicAuth } from "./BasicAuth.js";
+export { BearerToken } from "./BearerToken.js";
+export { NoOpAuthProvider } from "./NoOpAuthProvider.js";

package/dist/cjs/core/auth/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoOpAuthProvider = exports.BearerToken = exports.BasicAuth = exports.isAuthProvider = void 0;
+var AuthProvider_js_1 = require("./AuthProvider.js");
+Object.defineProperty(exports, "isAuthProvider", { enumerable: true, get: function () { return AuthProvider_js_1.isAuthProvider; } });
+var BasicAuth_js_1 = require("./BasicAuth.js");
+Object.defineProperty(exports, "BasicAuth", { enumerable: true, get: function () { return BasicAuth_js_1.BasicAuth; } });
+var BearerToken_js_1 = require("./BearerToken.js");
+Object.defineProperty(exports, "BearerToken", { enumerable: true, get: function () { return BearerToken_js_1.BearerToken; } });
+var NoOpAuthProvider_js_1 = require("./NoOpAuthProvider.js");
+Object.defineProperty(exports, "NoOpAuthProvider", { enumerable: true, get: function () { return NoOpAuthProvider_js_1.NoOpAuthProvider; } });

package/dist/cjs/core/base64.d.ts

@@ -0,0 +1,2 @@
+export declare function base64Encode(input: string): string;
+export declare function base64Decode(input: string): string;