auth0 5.3.0 → 5.4.0

package/dist/esm/management/auth/BearerAuthProvider.d.mts

@@ -1,16 +1,20 @@
 import * as core from "../core/index.mjs";
-export declare namespace BearerAuthProvider {
-    interface AuthOptions {
-        token: core.Supplier<core.BearerToken>;
-    }
-    interface Options extends AuthOptions {
-    }
-}
+declare const TOKEN_PARAM: "token";
 export declare class BearerAuthProvider implements core.AuthProvider {
-    private readonly token;
+    private readonly options;
     constructor(options: BearerAuthProvider.Options);
-    static canCreate(options: BearerAuthProvider.Options): boolean;
-    getAuthRequest(arg?: {
+    static canCreate(options: Partial<BearerAuthProvider.Options>): boolean;
+    getAuthRequest({ endpointMetadata, }?: {
         endpointMetadata?: core.EndpointMetadata;
     }): Promise<core.AuthRequest>;
 }
+export declare namespace BearerAuthProvider {
+    const AUTH_SCHEME: "bearerAuth";
+    const AUTH_CONFIG_ERROR_MESSAGE: string;
+    type Options = AuthOptions;
+    type AuthOptions = {
+        [TOKEN_PARAM]: core.Supplier<core.BearerToken>;
+    };
+    function createInstance(options: Options): core.AuthProvider;
+}
+export {};

package/dist/esm/management/auth/BearerAuthProvider.mjs

@@ -10,19 +10,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import * as core from "../core/index.mjs";
 import * as errors from "../errors/index.mjs";
+const TOKEN_PARAM = "token";
 export class BearerAuthProvider {
     constructor(options) {
-        this.token = options.token;
+        this.options = options;
     }
     static canCreate(options) {
-        return options.token != null;
+        return (options === null || options === void 0 ? void 0 : options[TOKEN_PARAM]) != null;
     }
-    getAuthRequest(arg) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const token = yield core.Supplier.get(this.token);
+    getAuthRequest() {
+        return __awaiter(this, arguments, void 0, function* ({ endpointMetadata, } = {}) {
+            const token = yield core.Supplier.get(this.options[TOKEN_PARAM]);
             if (token == null) {
                 throw new errors.ManagementError({
-                    message: "Please specify a token by passing it in to the constructor",
+                    message: BearerAuthProvider.AUTH_CONFIG_ERROR_MESSAGE,
                 });
             }
             return {
@@ -31,3 +32,11 @@ export class BearerAuthProvider {
         });
     }
 }
+(function (BearerAuthProvider) {
+    BearerAuthProvider.AUTH_SCHEME = "bearerAuth";
+    BearerAuthProvider.AUTH_CONFIG_ERROR_MESSAGE = `Please provide '${TOKEN_PARAM}' when initializing the client`;
+    function createInstance(options) {
+        return new BearerAuthProvider(options);
+    }
+    BearerAuthProvider.createInstance = createInstance;
+})(BearerAuthProvider || (BearerAuthProvider = {}));

package/dist/esm/management/core/fetcher/EndpointSupplier.d.mts

@@ -1,12 +1,12 @@
 import type { EndpointMetadata } from "./EndpointMetadata.mjs";
 import type { Supplier } from "./Supplier.mjs";
 type EndpointSupplierFn<T> = (arg: {
-    endpointMetadata: EndpointMetadata;
+    endpointMetadata?: EndpointMetadata;
 }) => T | Promise<T>;
 export type EndpointSupplier<T> = Supplier<T> | EndpointSupplierFn<T>;
 export declare const EndpointSupplier: {
     get: <T>(supplier: EndpointSupplier<T>, arg: {
-        endpointMetadata: EndpointMetadata;
+        endpointMetadata?: EndpointMetadata;
     }) => Promise<T>;
 };
 export {};

package/dist/esm/management/core/fetcher/Fetcher.d.mts

@@ -1,14 +1,13 @@
 import { type LogConfig, type Logger } from "../logging/logger.mjs";
 import type { APIResponse } from "./APIResponse.mjs";
 import type { EndpointMetadata } from "./EndpointMetadata.mjs";
-import { EndpointSupplier } from "./EndpointSupplier.mjs";
 export type FetchFunction = <R = unknown>(args: Fetcher.Args) => Promise<APIResponse<R, Fetcher.Error>>;
 export declare namespace Fetcher {
     interface Args {
         url: string;
         method: string;
         contentType?: string;
-        headers?: Record<string, string | EndpointSupplier<string | null | undefined> | null | undefined>;
+        headers?: Record<string, unknown>;
         queryParameters?: Record<string, unknown>;
         body?: unknown;
         timeoutMs?: number;

package/dist/esm/management/core/fetcher/Fetcher.mjs

@@ -152,7 +152,13 @@ function getHeaders(args) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         const newHeaders = new Headers();
-        newHeaders.set("Accept", args.responseType === "json" ? "application/json" : args.responseType === "text" ? "text/plain" : "*/*");
+        newHeaders.set("Accept", args.responseType === "json"
+            ? "application/json"
+            : args.responseType === "text"
+                ? "text/plain"
+                : args.responseType === "sse"
+                    ? "text/event-stream"
+                    : "*/*");
         if (args.body !== undefined && args.contentType != null) {
             newHeaders.set("Content-Type", args.contentType);
         }

package/dist/esm/management/core/form-data-utils/FormDataWrapper.mjs

@@ -115,7 +115,7 @@ function streamToBuffer(stream) {
             }
             return Buffer.from(result);
         }
-        throw new Error("Unsupported stream type: " + typeof stream + ". Expected Node.js Readable stream or Web ReadableStream.");
+        throw new Error(`Unsupported stream type: ${typeof stream}. Expected Node.js Readable stream or Web ReadableStream.`);
     });
 }
 function convertToBlob(value, contentType) {

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

@@ -1,2 +1,2 @@
-export declare function mergeHeaders<THeaderValue>(...headersArray: (Record<string, THeaderValue> | null | undefined)[]): Record<string, string | THeaderValue>;
-export declare function mergeOnlyDefinedHeaders<THeaderValue>(...headersArray: (Record<string, THeaderValue> | null | undefined)[]): Record<string, THeaderValue>;
+export declare function mergeHeaders(...headersArray: (Record<string, unknown> | null | undefined)[]): Record<string, unknown>;
+export declare function mergeOnlyDefinedHeaders(...headersArray: (Record<string, unknown> | null | undefined)[]): Record<string, unknown>;

package/dist/esm/management/core/pagination/CustomPager.d.mts

@@ -1,49 +1,34 @@
-import { HttpResponsePromise, type RawResponse, type WithRawResponse } from "../fetcher/index.mjs";
+import type { BaseRequestOptions, NormalizedClientOptions } from "../../BaseClient.mjs";
+import type { APIResponse } from "../fetcher/APIResponse.mjs";
+import type { Fetcher } from "../fetcher/Fetcher.mjs";
+import type { RawResponse } from "../fetcher/index.mjs";
 /**
- * Parser function type for custom pagination.
- * SDK authors implement this to define how to extract items and determine pagination state.
- *
- * @template TItem The type of items in the paginated response.
- * @template TRequest The type of the request object.
- * @template TResponse The type of the API response.
- */
-export type CustomPagerParser<TItem, TRequest, TResponse> = (request: TRequest, response: WithRawResponse<TResponse>) => Promise<{
-    /** The request to use for fetching the next page, if any */
-    nextRequest?: TRequest;
-    /** Whether there is a next page available */
-    hasNextPage: boolean;
-    /** The request to use for fetching the previous page, if any */
-    previousRequest?: TRequest;
-    /** Whether there is a previous page available */
-    hasPreviousPage: boolean;
-    /** The items extracted from the current response */
-    items: TItem[];
-}>;
-/**
- * A custom pager for paginated API responses where the pagination logic
- * must be implemented by the SDK author.
- *
- * SDK authors provide a parser callback to extract items and determine
- * pagination state from responses.
  *
  * @template TItem The type of the items in the page.
- * @template TRequest The type of the request object.
  * @template TResponse The type of the API response.
  */
-export declare class CustomPager<TItem, TRequest, TResponse> implements AsyncIterable<TItem> {
+export declare class CustomPager<TItem, TResponse> implements AsyncIterable<TItem> {
     /** The items from the current page */
     data: TItem[];
     /** The raw HTTP response */
     rawResponse: RawResponse;
     /** The parsed response object */
     response: TResponse;
-    private context;
-    private parser;
+    private sendRequest;
     private nextRequest?;
     private previousRequest?;
     private _hasNextPage;
     private _hasPreviousPage;
-    private constructor();
+    constructor(args: {
+        response: TResponse;
+        rawResponse: RawResponse;
+        items: TItem[];
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+        nextRequest?: Fetcher.Args;
+        previousRequest?: Fetcher.Args;
+        sendRequest: (request: Fetcher.Args) => Promise<APIResponse<TResponse, Fetcher.Error>>;
+    });
     /**
      * @returns whether there is a next page to load
      */
@@ -52,6 +37,13 @@ export declare class CustomPager<TItem, TRequest, TResponse> implements AsyncIte
      * @returns whether there is a previous page to load
      */
     hasPreviousPage(): boolean;
+    /**
+     * Returns the current page data.
+     * This is an alias for the `data` property for consistency with other pagination APIs.
+     *
+     * @returns the items from the current page
+     */
+    getCurrentPage(): TItem[];
     /**
      * Retrieves the next page of results.
      * @returns this pager with updated data
@@ -66,17 +58,10 @@ export declare class CustomPager<TItem, TRequest, TResponse> implements AsyncIte
     getPreviousPage(): Promise<this>;
     private iterMessages;
     [Symbol.asyncIterator](): AsyncIterator<TItem, void, unknown>;
-    /**
-     * Creates a CustomPager by making the initial request and parsing the response.
-     *
-     * @param args.sendRequest Function to send a request and get a response
-     * @param args.initialRequest The initial request to start pagination
-     * @param args.parse The parser function to extract items and pagination state
-     * @returns A new CustomPager instance
-     */
-    static create<TItem, TRequest, TResponse>(args: {
-        sendRequest: (request: TRequest) => HttpResponsePromise<TResponse>;
-        initialRequest: TRequest;
-        parse: CustomPagerParser<TItem, TRequest, TResponse>;
-    }): Promise<CustomPager<TItem, TRequest, TResponse>>;
 }
+export declare function createCustomPager<TItem, TResponse>({ sendRequest, initialHttpRequest, clientOptions, }: {
+    sendRequest: (request: Fetcher.Args) => Promise<APIResponse<TResponse, Fetcher.Error>>;
+    initialHttpRequest: Fetcher.Args;
+    clientOptions: NormalizedClientOptions;
+    requestOptions?: BaseRequestOptions;
+}): Promise<CustomPager<TItem, TResponse>>;

package/dist/esm/management/core/pagination/CustomPager.mjs

@@ -28,14 +28,8 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
 /**
- * A custom pager for paginated API responses where the pagination logic
- * must be implemented by the SDK author.
- *
- * SDK authors provide a parser callback to extract items and determine
- * pagination state from responses.
  *
  * @template TItem The type of the items in the page.
- * @template TRequest The type of the request object.
  * @template TResponse The type of the API response.
  */
 export class CustomPager {
@@ -47,8 +41,7 @@ export class CustomPager {
         this._hasPreviousPage = args.hasPreviousPage;
         this.nextRequest = args.nextRequest;
         this.previousRequest = args.previousRequest;
-        this.context = args.context;
-        this.parser = args.parser;
+        this.sendRequest = args.sendRequest;
     }
     /**
      * @returns whether there is a next page to load
@@ -62,6 +55,15 @@ export class CustomPager {
     hasPreviousPage() {
         return this._hasPreviousPage;
     }
+    /**
+     * Returns the current page data.
+     * This is an alias for the `data` property for consistency with other pagination APIs.
+     *
+     * @returns the items from the current page
+     */
+    getCurrentPage() {
+        return this.data;
+    }
     /**
      * Retrieves the next page of results.
      * @returns this pager with updated data
@@ -72,14 +74,19 @@ export class CustomPager {
             if (!this._hasNextPage || !this.nextRequest) {
                 throw new Error("No next page available");
             }
-            const { data, rawResponse } = yield this.context.sendRequest(this.nextRequest).withRawResponse();
-            const parsed = yield this.parser(this.nextRequest, { data, rawResponse });
+            const response = yield this.sendRequest(this.nextRequest);
+            if (!response.ok) {
+                const reason = response.error.reason === "status-code" ? `HTTP ${response.error.statusCode}` : response.error.reason;
+                throw new Error(`Failed to fetch next page: ${reason}`);
+            }
+            const data = response.body;
+            const rawResponse = response.rawResponse;
+            const parsed = yield parse({ request: this.nextRequest, data, rawResponse });
             this.response = data;
             this.rawResponse = rawResponse;
             this.data = parsed.items;
             this._hasNextPage = parsed.hasNextPage;
             this._hasPreviousPage = parsed.hasPreviousPage;
-            this.context.currentRequest = this.nextRequest;
             this.nextRequest = parsed.nextRequest;
             this.previousRequest = parsed.previousRequest;
             return this;
@@ -95,14 +102,19 @@ export class CustomPager {
             if (!this._hasPreviousPage || !this.previousRequest) {
                 throw new Error("No previous page available");
             }
-            const { data, rawResponse } = yield this.context.sendRequest(this.previousRequest).withRawResponse();
-            const parsed = yield this.parser(this.previousRequest, { data, rawResponse });
+            const response = yield this.sendRequest(this.previousRequest);
+            if (!response.ok) {
+                const reason = response.error.reason === "status-code" ? `HTTP ${response.error.statusCode}` : response.error.reason;
+                throw new Error(`Failed to fetch previous page: ${reason}`);
+            }
+            const data = response.body;
+            const rawResponse = response.rawResponse;
+            const parsed = yield parse({ request: this.previousRequest, data, rawResponse });
             this.response = data;
             this.rawResponse = rawResponse;
             this.data = parsed.items;
             this._hasNextPage = parsed.hasNextPage;
             this._hasPreviousPage = parsed.hasPreviousPage;
-            this.context.currentRequest = this.previousRequest;
             this.nextRequest = parsed.nextRequest;
             this.previousRequest = parsed.previousRequest;
             return this;
@@ -141,32 +153,37 @@ export class CustomPager {
             }
         });
     }
-    /**
-     * Creates a CustomPager by making the initial request and parsing the response.
-     *
-     * @param args.sendRequest Function to send a request and get a response
-     * @param args.initialRequest The initial request to start pagination
-     * @param args.parse The parser function to extract items and pagination state
-     * @returns A new CustomPager instance
-     */
-    static create(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { data, rawResponse } = yield args.sendRequest(args.initialRequest).withRawResponse();
-            const parsed = yield args.parse(args.initialRequest, { data, rawResponse });
-            return new CustomPager({
-                response: data,
-                rawResponse,
-                items: parsed.items,
-                hasNextPage: parsed.hasNextPage,
-                hasPreviousPage: parsed.hasPreviousPage,
-                nextRequest: parsed.nextRequest,
-                previousRequest: parsed.previousRequest,
-                context: {
-                    sendRequest: args.sendRequest,
-                    currentRequest: args.initialRequest,
-                },
-                parser: args.parse,
-            });
+}
+export function createCustomPager(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ sendRequest, initialHttpRequest, clientOptions, }) {
+        const response = yield sendRequest(initialHttpRequest);
+        if (!response.ok) {
+            const reason = response.error.reason === "status-code" ? `HTTP ${response.error.statusCode}` : response.error.reason;
+            throw new Error(`Failed to fetch initial page: ${reason}`);
+        }
+        const data = response.body;
+        const rawResponse = response.rawResponse;
+        const parsed = yield parse({ request: initialHttpRequest, data, rawResponse });
+        return new CustomPager({
+            response: data,
+            rawResponse,
+            items: parsed.items,
+            hasNextPage: parsed.hasNextPage,
+            hasPreviousPage: parsed.hasPreviousPage,
+            nextRequest: parsed.nextRequest,
+            previousRequest: parsed.previousRequest,
+            sendRequest: sendRequest,
         });
-    }
+    });
+}
+function parse(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Placeholder implementation.
+        // TODO: Replace this with actual parsing logic.
+        return {
+            items: [],
+            hasNextPage: false,
+            hasPreviousPage: false,
+        };
+    });
 }

package/dist/esm/management/core/pagination/exports.d.mts

@@ -1,2 +1 @@
-export { CustomPager, type CustomPagerParser } from "./CustomPager.mjs";
 export type { Page } from "./Page.mjs";

package/dist/esm/management/core/pagination/exports.mjs

@@ -1 +1 @@
-export { CustomPager } from "./CustomPager.mjs";
+export {};

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

@@ -1,2 +1,2 @@
-export { CustomPager, type CustomPagerParser } from "./CustomPager.mjs";
+export { CustomPager, createCustomPager } from "./CustomPager.mjs";
 export { Page } from "./Page.mjs";

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

@@ -1,2 +1,2 @@
-export { CustomPager } from "./CustomPager.mjs";
+export { CustomPager, createCustomPager } from "./CustomPager.mjs";
 export { Page } from "./Page.mjs";

package/dist/esm/management/version.d.mts

@@ -1 +1 @@
-export declare const SDK_VERSION = "5.3.0";
+export declare const SDK_VERSION = "5.4.0";

package/dist/esm/management/version.mjs

@@ -1 +1 @@
-export const SDK_VERSION = "5.3.0";
+export const SDK_VERSION = "5.4.0";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "auth0",
-    "version": "5.3.0",
+    "version": "5.4.0",
     "private": false,
     "repository": {
         "type": "git",
@@ -87,7 +87,7 @@
         "msw": "2.11.2",
         "@types/node": "^18.19.70",
         "typescript": "~5.7.2",
-        "prettier": "3.4.2",
+        "prettier": "3.7.4",
         "typedoc": "^0.28.7",
         "typedoc-plugin-missing-exports": "^4.0.0",
         "nock": "^14.0.6",
@@ -106,7 +106,8 @@
         "fs": false,
         "os": false,
         "path": false,
-        "stream": false
+        "stream": false,
+        "crypto": false
     },
     "packageManager": "yarn@1.22.22",
     "engines": {