auth0 5.3.0 → 5.4.0

package/dist/cjs/management/auth/BearerAuthProvider.d.ts

@@ -1,16 +1,20 @@
 import * as core from "../core/index.js";
-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/cjs/management/auth/BearerAuthProvider.js

@@ -46,19 +46,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BearerAuthProvider = void 0;
 const core = __importStar(require("../core/index.js"));
 const errors = __importStar(require("../errors/index.js"));
+const TOKEN_PARAM = "token";
 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 {
@@ -68,3 +69,11 @@ class BearerAuthProvider {
     }
 }
 exports.BearerAuthProvider = 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 || (exports.BearerAuthProvider = BearerAuthProvider = {}));

package/dist/cjs/management/core/fetcher/EndpointSupplier.d.ts

@@ -1,12 +1,12 @@
 import type { EndpointMetadata } from "./EndpointMetadata.js";
 import type { Supplier } from "./Supplier.js";
 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/cjs/management/core/fetcher/Fetcher.d.ts

@@ -1,14 +1,13 @@
 import { type LogConfig, type Logger } from "../logging/logger.js";
 import type { APIResponse } from "./APIResponse.js";
 import type { EndpointMetadata } from "./EndpointMetadata.js";
-import { EndpointSupplier } from "./EndpointSupplier.js";
 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/cjs/management/core/fetcher/Fetcher.js

@@ -156,7 +156,13 @@ function getHeaders(args) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         const newHeaders = new Headers_js_1.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/cjs/management/core/form-data-utils/FormDataWrapper.js

@@ -153,7 +153,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/cjs/management/core/headers.d.ts

@@ -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/cjs/management/core/pagination/CustomPager.d.ts

@@ -1,49 +1,34 @@
-import { HttpResponsePromise, type RawResponse, type WithRawResponse } from "../fetcher/index.js";
+import type { BaseRequestOptions, NormalizedClientOptions } from "../../BaseClient.js";
+import type { APIResponse } from "../fetcher/APIResponse.js";
+import type { Fetcher } from "../fetcher/Fetcher.js";
+import type { RawResponse } from "../fetcher/index.js";
 /**
- * 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/cjs/management/core/pagination/CustomPager.js

@@ -30,15 +30,10 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomPager = void 0;
+exports.createCustomPager = createCustomPager;
 /**
- * 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.
  */
 class CustomPager {
@@ -50,8 +45,7 @@ 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
@@ -65,6 +59,15 @@ 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
@@ -75,14 +78,19 @@ 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;
@@ -98,14 +106,19 @@ 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;
@@ -144,33 +157,38 @@ 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,
-            });
-        });
-    }
 }
 exports.CustomPager = CustomPager;
+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/cjs/management/core/pagination/exports.d.ts

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

package/dist/cjs/management/core/pagination/exports.js

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

package/dist/cjs/management/core/pagination/index.d.ts

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

package/dist/cjs/management/core/pagination/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Page = exports.CustomPager = void 0;
+exports.Page = exports.createCustomPager = exports.CustomPager = void 0;
 var CustomPager_js_1 = require("./CustomPager.js");
 Object.defineProperty(exports, "CustomPager", { enumerable: true, get: function () { return CustomPager_js_1.CustomPager; } });
+Object.defineProperty(exports, "createCustomPager", { enumerable: true, get: function () { return CustomPager_js_1.createCustomPager; } });
 var Page_js_1 = require("./Page.js");
 Object.defineProperty(exports, "Page", { enumerable: true, get: function () { return Page_js_1.Page; } });

package/dist/cjs/management/version.d.ts

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

package/dist/cjs/management/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = "5.3.0";
+exports.SDK_VERSION = "5.4.0";

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

@@ -29,12 +29,12 @@ export interface BaseRequestOptions {
     /** Additional headers to include in the request. */
     headers?: Record<string, string | core.Supplier<string | null | undefined> | null | undefined>;
 }
-export type NormalizedClientOptions<T extends BaseClientOptions> = T & {
+export type NormalizedClientOptions<T extends BaseClientOptions = BaseClientOptions> = T & {
     logging: core.logging.Logger;
     authProvider?: core.AuthProvider;
 };
-export type NormalizedClientOptionsWithAuth<T extends BaseClientOptions> = NormalizedClientOptions<T> & {
+export type NormalizedClientOptionsWithAuth<T extends BaseClientOptions = BaseClientOptions> = NormalizedClientOptions<T> & {
     authProvider: core.AuthProvider;
 };
-export declare function normalizeClientOptions<T extends BaseClientOptions>(options: T): NormalizedClientOptions<T>;
-export declare function normalizeClientOptionsWithAuth<T extends BaseClientOptions>(options: T): NormalizedClientOptionsWithAuth<T>;
+export declare function normalizeClientOptions<T extends BaseClientOptions = BaseClientOptions>(options: T): NormalizedClientOptions<T>;
+export declare function normalizeClientOptionsWithAuth<T extends BaseClientOptions = BaseClientOptions>(options: T): NormalizedClientOptionsWithAuth<T>;