fix: Revert Custom Domains pagination to return simple array

reference.md

@@ -2349,7 +2349,7 @@ await client.connections.checkStatus("id");
 
 ## CustomDomains
 
-<details><summary><code>client.customDomains.<a href="/src/management/api/resources/customDomains/client/Client.ts">list</a>({ ...params }) -> core.Page<Management.CustomDomain, Management.ListCustomDomainsPaginatedResponseContent></code></summary>
+<details><summary><code>client.customDomains.<a href="/src/management/api/resources/customDomains/client/Client.ts">list</a>({ ...params }) -> Management.ListCustomDomainsResponseContent</code></summary>
 <dl>
 <dd>
 
@@ -2377,33 +2377,12 @@ Retrieve details on <a href="https://auth0.com/docs/custom-domains">custom domai
 <dd>
 
 ```typescript
-const pageableResponse = await client.customDomains.list({
-    take: 1,
-    from: "from",
-    q: "q",
-    fields: "fields",
-    include_fields: true,
-    sort: "sort",
-});
-for await (const item of pageableResponse) {
-    console.log(item);
-}
-
-// Or you can manually iterate page-by-page
-let page = await client.customDomains.list({
-    take: 1,
-    from: "from",
+await client.customDomains.list({
     q: "q",
     fields: "fields",
     include_fields: true,
     sort: "sort",
 });
-while (page.hasNextPage()) {
-    page = page.getNextPage();
-}
-
-// You can also access the underlying response
-const response = page.response;
 ```
 
 </dd>

src/management/api/requests/requests.ts

@@ -533,19 +533,13 @@ export interface UpdateConnectionRequestContent {
 /**
  * @example
  *     {
- *         take: 1,
- *         from: "from",
  *         q: "q",
  *         fields: "fields",
  *         include_fields: true,
  *         sort: "sort"
  *     }
  */
 export interface ListCustomDomainsRequestParameters {
-    /** Number of results per page. Defaults to 50. */
-    take?: number | null;
-    /** Optional Id from which to start selection. */
-    from?: string | null;
     /** Query in <a href ="http://www.lucenetutorial.com/lucene-query-syntax.html">Lucene query string syntax</a>. */
     q?: string | null;
     /** Comma-separated list of fields to include or exclude (based on value provided for include_fields) in the result. Leave empty to retrieve all fields. */

src/management/api/resources/customDomains/client/Client.ts

@@ -34,106 +34,88 @@ export class CustomDomainsClient {
      *
      * @example
      *     await client.customDomains.list({
-     *         take: 1,
-     *         from: "from",
      *         q: "q",
      *         fields: "fields",
      *         include_fields: true,
      *         sort: "sort"
      *     })
      */
-    public async list(
+    public list(
         request: Management.ListCustomDomainsRequestParameters = {},
         requestOptions?: CustomDomainsClient.RequestOptions,
-    ): Promise<core.Page<Management.CustomDomain, Management.ListCustomDomainsPaginatedResponseContent>> {
-        const list = core.HttpResponsePromise.interceptFunction(
-            async (
-                request: Management.ListCustomDomainsRequestParameters,
-            ): Promise<core.WithRawResponse<Management.ListCustomDomainsPaginatedResponseContent>> => {
-                const { take = 50, from: from_, q, fields, include_fields: includeFields, sort } = request;
-                const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
-                if (take !== undefined) {
-                    _queryParams["take"] = take?.toString() ?? null;
-                }
-                if (from_ !== undefined) {
-                    _queryParams["from"] = from_;
-                }
-                if (q !== undefined) {
-                    _queryParams["q"] = q;
-                }
-                if (fields !== undefined) {
-                    _queryParams["fields"] = fields;
-                }
-                if (includeFields !== undefined) {
-                    _queryParams["include_fields"] = includeFields?.toString() ?? null;
-                }
-                if (sort !== undefined) {
-                    _queryParams["sort"] = sort;
-                }
-                const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
-                let _headers: core.Fetcher.Args["headers"] = mergeHeaders(
-                    _authRequest.headers,
-                    this._options?.headers,
-                    requestOptions?.headers,
-                );
-                const _response = await (this._options.fetcher ?? core.fetcher)({
-                    url: core.url.join(
-                        (await core.Supplier.get(this._options.baseUrl)) ??
-                            (await core.Supplier.get(this._options.environment)) ??
-                            environments.ManagementEnvironment.Default,
-                        "custom-domains",
-                    ),
-                    method: "GET",
-                    headers: _headers,
-                    queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
-                    timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-                    maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-                    abortSignal: requestOptions?.abortSignal,
-                    fetchFn: this._options?.fetch,
-                    logging: this._options.logging,
-                });
-                if (_response.ok) {
-                    return {
-                        data: _response.body as Management.ListCustomDomainsPaginatedResponseContent,
-                        rawResponse: _response.rawResponse,
-                    };
-                }
-                if (_response.error.reason === "status-code") {
-                    switch (_response.error.statusCode) {
-                        case 401:
-                            throw new Management.UnauthorizedError(
-                                _response.error.body as unknown,
-                                _response.rawResponse,
-                            );
-                        case 403:
-                            throw new Management.ForbiddenError(_response.error.body as unknown, _response.rawResponse);
-                        case 429:
-                            throw new Management.TooManyRequestsError(
-                                _response.error.body as unknown,
-                                _response.rawResponse,
-                            );
-                        default:
-                            throw new errors.ManagementError({
-                                statusCode: _response.error.statusCode,
-                                body: _response.error.body,
-                                rawResponse: _response.rawResponse,
-                            });
-                    }
-                }
-                return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/custom-domains");
-            },
+    ): core.HttpResponsePromise<Management.ListCustomDomainsResponseContent> {
+        return core.HttpResponsePromise.fromPromise(this.__list(request, requestOptions));
+    }
+
+    private async __list(
+        request: Management.ListCustomDomainsRequestParameters = {},
+        requestOptions?: CustomDomainsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<Management.ListCustomDomainsResponseContent>> {
+        const { q, fields, include_fields: includeFields, sort } = request;
+        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
+        if (q !== undefined) {
+            _queryParams["q"] = q;
+        }
+
+        if (fields !== undefined) {
+            _queryParams["fields"] = fields;
+        }
+
+        if (includeFields !== undefined) {
+            _queryParams["include_fields"] = includeFields?.toString() ?? null;
+        }
+
+        if (sort !== undefined) {
+            _queryParams["sort"] = sort;
+        }
+
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        let _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            requestOptions?.headers,
         );
-        const dataWithRawResponse = await list(request).withRawResponse();
-        return new core.Page<Management.CustomDomain, Management.ListCustomDomainsPaginatedResponseContent>({
-            response: dataWithRawResponse.data,
-            rawResponse: dataWithRawResponse.rawResponse,
-            hasNextPage: (response) =>
-                response?.next != null && !(typeof response?.next === "string" && response?.next === ""),
-            getItems: (response) => response?.custom_domains ?? [],
-            loadPage: (response) => {
-                return list(core.setObjectProperty(request, "from", response?.next));
-            },
+        const _response = await (this._options.fetcher ?? core.fetcher)({
+            url: core.url.join(
+                (await core.Supplier.get(this._options.baseUrl)) ??
+                    (await core.Supplier.get(this._options.environment)) ??
+                    environments.ManagementEnvironment.Default,
+                "custom-domains",
+            ),
+            method: "GET",
+            headers: _headers,
+            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
         });
+        if (_response.ok) {
+            return {
+                data: _response.body as Management.ListCustomDomainsResponseContent,
+                rawResponse: _response.rawResponse,
+            };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Management.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
+                case 403:
+                    throw new Management.ForbiddenError(_response.error.body as unknown, _response.rawResponse);
+                case 429:
+                    throw new Management.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
+                default:
+                    throw new errors.ManagementError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/custom-domains");
     }
 
     /**

src/management/api/types/types.ts

@@ -12343,11 +12343,7 @@ export interface ListConnectionsCheckpointPaginatedResponseContent {
     connections?: Management.ConnectionForList[];
 }
 
-export interface ListCustomDomainsPaginatedResponseContent {
-    custom_domains: Management.CustomDomain[];
-    /** A cursor to be used as the "from" query parameter for the next page of results. */
-    next?: string;
-}
+export type ListCustomDomainsResponseContent = Management.CustomDomain[];
 
 export interface ListDeviceCredentialsOffsetPaginatedResponseContent {
     start?: number;