auth0 7.5.0-beta.0 → 7.6.0

package/dist/esm/management/core/requestBody.d.mts

@@ -0,0 +1,12 @@
+/**
+ * Spreads caller-supplied `additionalBodyParameters` (from `requestOptions.additionalBodyParameters`)
+ * on top of the request body. Caller-supplied properties win over the endpoint body. When no
+ * additional body parameters are provided, the original body is returned unchanged so serialization
+ * is unaffected.
+ *
+ * The merge only applies to plain-object (JSON object) bodies. When the body is `null`/`undefined`
+ * the additional parameters become the body; when the body is an array or a primitive JSON value it
+ * is returned unchanged, since object properties cannot be spread into it. This mirrors the Python
+ * SDK, which only merges additional body parameters into mapping bodies.
+ */
+export declare function mergeAdditionalBodyParameters(body: unknown, additionalBodyParameters: Record<string, unknown> | undefined): unknown;

package/dist/esm/management/core/requestBody.mjs

@@ -0,0 +1,23 @@
+/**
+ * Spreads caller-supplied `additionalBodyParameters` (from `requestOptions.additionalBodyParameters`)
+ * on top of the request body. Caller-supplied properties win over the endpoint body. When no
+ * additional body parameters are provided, the original body is returned unchanged so serialization
+ * is unaffected.
+ *
+ * The merge only applies to plain-object (JSON object) bodies. When the body is `null`/`undefined`
+ * the additional parameters become the body; when the body is an array or a primitive JSON value it
+ * is returned unchanged, since object properties cannot be spread into it. This mirrors the Python
+ * SDK, which only merges additional body parameters into mapping bodies.
+ */
+export function mergeAdditionalBodyParameters(body, additionalBodyParameters) {
+    if (additionalBodyParameters == null) {
+        return body;
+    }
+    if (body == null) {
+        return Object.assign({}, additionalBodyParameters);
+    }
+    if (typeof body === "object" && !Array.isArray(body)) {
+        return Object.assign(Object.assign({}, body), additionalBodyParameters);
+    }
+    return body;
+}

package/dist/esm/management/core/runtime/index.d.mts

@@ -1 +1 @@
-export { RUNTIME } from "./runtime.mjs";
+export { RUNTIME, getUserAgent } from "./runtime.mjs";

package/dist/esm/management/core/runtime/index.mjs

@@ -1 +1 @@
-export { RUNTIME } from "./runtime.mjs";
+export { RUNTIME, getUserAgent } from "./runtime.mjs";

package/dist/esm/management/core/runtime/runtime.d.mts

@@ -6,4 +6,23 @@ export interface Runtime {
     type: "browser" | "web-worker" | "deno" | "bun" | "node" | "react-native" | "unknown" | "workerd" | "edge-runtime";
     version?: string;
     parsedVersion?: number;
+    /**
+     * The operating system the SDK is running on, when it can be determined
+     * (e.g. "linux", "darwin", "win32" on server runtimes). Undefined in
+     * environments where the OS is not observable (e.g. browsers).
+     */
+    os?: string;
+    /**
+     * The CPU architecture the SDK is running on, when it can be determined
+     * (e.g. "x64", "arm64" on server runtimes). Undefined in environments where
+     * the architecture is not observable (e.g. browsers).
+     */
+    arch?: string;
 }
+/**
+ * Builds a structured User-Agent string of the form
+ *   `{sdkName}/{sdkVersion} ({os}; {arch}) {runtime}/{runtimeVersion}`
+ * where the platform group and runtime segment are omitted gracefully when the
+ * underlying values cannot be determined (e.g. in a browser).
+ */
+export declare function getUserAgent(sdkName: string, sdkVersion: string): string;

package/dist/esm/management/core/runtime/runtime.mjs

@@ -3,7 +3,7 @@
  */
 export const RUNTIME = evaluateRuntime();
 function evaluateRuntime() {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g;
     /**
      * A constant that indicates whether the environment the code is running is a Web Browser.
      */
@@ -56,6 +56,8 @@ function evaluateRuntime() {
         return {
             type: "deno",
             version: Deno.version.deno,
+            os: (_e = Deno.build) === null || _e === void 0 ? void 0 : _e.os,
+            arch: (_f = Deno.build) === null || _f === void 0 ? void 0 : _f.arch,
         };
     }
     /**
@@ -66,6 +68,8 @@ function evaluateRuntime() {
         return {
             type: "bun",
             version: Bun.version,
+            os: typeof process !== "undefined" ? process.platform : undefined,
+            arch: typeof process !== "undefined" ? process.arch : undefined,
         };
     }
     /**
@@ -87,15 +91,82 @@ function evaluateRuntime() {
      * Edge Runtime warns about Node.js APIs even when they are guarded).
      */
     const _process = typeof process !== "undefined" ? process : undefined;
-    const isNode = typeof _process !== "undefined" && typeof ((_e = _process.versions) === null || _e === void 0 ? void 0 : _e.node) === "string";
+    const isNode = typeof _process !== "undefined" && typeof ((_g = _process.versions) === null || _g === void 0 ? void 0 : _g.node) === "string";
     if (isNode) {
         return {
             type: "node",
             version: _process.versions.node,
             parsedVersion: Number(_process.versions.node.split(".")[0]),
+            os: _process.platform,
+            arch: _process.arch,
         };
     }
     return {
         type: "unknown",
     };
 }
+/**
+ * Display names for the language runtimes whose version is meaningful to encode
+ * in a User-Agent. Environments where a version string is not useful (e.g.
+ * browsers, where `version` is the full navigator UA) are intentionally mapped
+ * to `undefined` so they are omitted from the User-Agent.
+ */
+const RUNTIME_DISPLAY_NAMES = {
+    node: "Node",
+    deno: "Deno",
+    bun: "Bun",
+    browser: undefined,
+    "web-worker": undefined,
+    "react-native": undefined,
+    workerd: undefined,
+    "edge-runtime": undefined,
+    unknown: undefined,
+};
+/**
+ * CPU architecture aliases that all refer to 64-bit x86. They are normalized to
+ * the single canonical token `x86_64` so the User-Agent architecture label is
+ * consistent regardless of which runtime reports it (Node reports `x64`, others
+ * report `amd64` or `x86_64`).
+ */
+const X86_64_ARCH_ALIASES = new Set(["x64", "amd64", "x86_64"]);
+/**
+ * Normalizes a CPU architecture token, collapsing the 64-bit x86 aliases
+ * (`x64`, `amd64`, `x86_64`) to `x86_64`. Other architectures are returned
+ * unchanged.
+ */
+function normalizeArch(arch) {
+    if (arch == null) {
+        return arch;
+    }
+    return X86_64_ARCH_ALIASES.has(arch.toLowerCase()) ? "x86_64" : arch;
+}
+/**
+ * Percent-encodes the `@` and `/` characters in an npm package name so the
+ * User-Agent product token stays within the RFC 7230 token grammar. The
+ * original scoped package name can be recovered by URL-decoding (e.g.
+ * `@dummy/sdk` becomes `%40dummy%2Fsdk`).
+ */
+function encodeProductName(sdkName) {
+    return sdkName.replace(/@/g, "%40").replace(/\//g, "%2F");
+}
+/**
+ * Builds a structured User-Agent string of the form
+ *   `{sdkName}/{sdkVersion} ({os}; {arch}) {runtime}/{runtimeVersion}`
+ * where the platform group and runtime segment are omitted gracefully when the
+ * underlying values cannot be determined (e.g. in a browser).
+ */
+export function getUserAgent(sdkName, sdkVersion) {
+    let userAgent = `${encodeProductName(sdkName)}/${sdkVersion}`;
+    const platform = [RUNTIME.os, normalizeArch(RUNTIME.arch)].filter((part) => part != null && part.length > 0);
+    if (platform.length > 0) {
+        userAgent += ` (${platform.join("; ")})`;
+    }
+    const runtimeName = RUNTIME_DISPLAY_NAMES[RUNTIME.type];
+    if (runtimeName != null) {
+        userAgent += ` ${runtimeName}`;
+        if (RUNTIME.version != null && RUNTIME.version.length > 0) {
+            userAgent += `/${RUNTIME.version}`;
+        }
+    }
+    return userAgent;
+}

package/dist/esm/management/core/stream/Stream.d.mts

@@ -12,6 +12,23 @@ export declare namespace Stream {
          * An abort signal to stop the stream.
          */
         signal?: AbortSignal;
+        /**
+         * Whether transparent mid-stream reconnection is enabled on resumable
+         * SSE endpoints. Defaults to true. Has no effect on non-resumable endpoints.
+         */
+        reconnectionEnabled?: boolean;
+        /**
+         * Maximum number of consecutive failed reconnect attempts on resumable SSE
+         * endpoints before giving up. The counter resets to zero each time a
+         * reconnected stream successfully yields at least one event (i.e. makes
+         * progress). Has no effect on non-resumable endpoints.
+         */
+        maxReconnectionAttempts?: number;
+        /**
+         * A function that re-issues the HTTP request with the Last-Event-ID header
+         * and returns the new response body stream. Required for reconnection to work.
+         */
+        reconnect?: (lastEventId: string) => Promise<ReadableStream>;
     }
     interface JsonEvent {
         type: "json";
@@ -21,8 +38,17 @@ export declare namespace Stream {
         type: "sse";
         streamTerminator?: string;
         eventDiscriminator?: string;
+        /** Event names whose union variant wraps the `data:` payload as `{ <eventDiscriminator>, data }`. */
+        envelopeEvents?: string[];
+        resumable?: boolean;
     }
 }
+export interface ServerSentEvent<T> {
+    data: T;
+    id?: string;
+    retry?: number;
+    event?: string;
+}
 export declare class Stream<T> implements AsyncIterable<T> {
     private stream;
     private parse;
@@ -34,9 +60,16 @@ export declare class Stream<T> implements AsyncIterable<T> {
     private messageTerminator;
     private streamTerminator;
     private eventDiscriminator;
+    private envelopeEvents;
+    private resumable;
+    private reconnectionEnabled;
+    private maxReconnectionAttempts;
+    private reconnect;
     private controller;
     private decoder;
-    constructor({ stream, parse, eventShape, signal }: Stream.Args & {
+    private externalSignal;
+    private onExternalAbort;
+    constructor({ stream, parse, eventShape, signal, reconnectionEnabled, maxReconnectionAttempts, reconnect, }: Stream.Args & {
         parse: (val: unknown) => Promise<T>;
     });
     private iterMessages;
@@ -46,6 +79,20 @@ export declare class Stream<T> implements AsyncIterable<T> {
      * Parses and returns a single SSE event, or returns null if the event is a stream terminator.
      */
     private dispatchSseEvent;
+    /**
+     * Determines whether a reconnection attempt should be made.
+     */
+    private shouldReconnect;
+    /**
+     * Delays before reconnecting, using a server-sent retry directive if provided
+     * (clamped to MAX_RECONNECT_DELAY_MS), otherwise falling back to
+     * DEFAULT_RECONNECT_DELAY_MS. The delay is abortable: if the stream's abort
+     * signal fires during the wait, the promise resolves immediately.
+     */
+    private delayReconnect;
+    private createEmptyStream;
+    private removeAbortListener;
+    withMetadata(): AsyncIterable<ServerSentEvent<T>>;
     private injectDiscriminator;
     [Symbol.asyncIterator](): AsyncIterator<T, void, unknown>;
     private decodeChunk;