@classytic/arc-next 0.4.1 → 0.6.0

package/dist/mutation.js

@@ -21,6 +21,25 @@ let toastHandler = {
 function configureToast(handler) {
 	toastHandler = handler;
 }
+/**
+* Get the configured toast handler. Returns the console-based default when
+* no handler has been configured yet.
+*
+* Use this when domain code outside the react-query lifecycle needs to fire
+* ad-hoc success/error toasts using the same handler the SDK uses internally
+* — avoids the need for consumer SDKs to keep a parallel cache of the handler.
+*
+* @example
+* // In a domain helper outside any mutation lifecycle:
+* import { getToastHandler } from '@classytic/arc-next/mutation';
+*
+* function notifySaved(label: string) {
+*   getToastHandler().success(`${label} saved`);
+* }
+*/
+function getToastHandler() {
+	return toastHandler;
+}
 function showToast(type, messages, data, variables, error, handler) {
 	const activeHandler = handler ?? toastHandler;
 	if (type === "success") {
@@ -163,4 +182,4 @@ function useOptimisticMutation(config) {
 }
 
 //#endregion
-export { configureToast, useMutationWithOptimistic, useMutationWithTransition, useOptimisticMutation };
+export { configureToast, getToastHandler, useMutationWithOptimistic, useMutationWithTransition, useOptimisticMutation };

package/dist/prefetch.d.ts

@@ -1,4 +1,4 @@
-import { QueryClient, dehydrate } from "@tanstack/react-query";
+import { HydrationBoundary, InfiniteData, QueryClient, dehydrate } from "@tanstack/react-query";
 
 //#region src/prefetch.d.ts
 interface PrefetchAuthContext {
@@ -51,6 +51,31 @@ interface CrudPrefetcher {
    * Only available when the API has a `getTree` method (tree preset).
    */
   prefetchTree: (queryClient: QueryClient, params?: Record<string, unknown>, options?: PrefetchOptions) => Promise<void>;
+  /**
+   * Prefetch an infinite list query (cursor / page-based pagination). Uses the
+   * same query keys as `useInfiniteList` and seeds the `{ pages, pageParams }`
+   * shape TanStack Query expects for `useInfiniteQuery` — a flat
+   * `prefetchQuery` would NOT match the cache shape and the client hook would
+   * re-fetch from scratch, defeating the prefetch.
+   *
+   * @example
+   * await productsPrefetcher.prefetchInfiniteList(queryClient, { limit: 20 });
+   */
+  /**
+   * Prefetch a declared aggregation (arc 2.13+). Uses the same query key as
+   * `useAggregation` so RSC-pre-rendered dashboard rows hydrate without a
+   * client refetch.
+   *
+   * @example
+   * await ordersPrefetcher.prefetchAggregation(
+   *   queryClient,
+   *   'salesByDay',
+   *   { from: '2025-01-01', to: '2025-12-31' },
+   *   { token: jwt, organizationId: orgId, staleTime: 60_000 },
+   * );
+   */
+  prefetchAggregation: (queryClient: QueryClient, name: string, filter?: Record<string, unknown>, options?: PrefetchOptions) => Promise<void>;
+  prefetchInfiniteList: (queryClient: QueryClient, params?: Record<string, unknown>, options?: PrefetchOptions) => Promise<void>;
 }
 /**
  * Create server-safe prefetch helpers for CRUD queries.
@@ -111,6 +136,15 @@ declare function createCrudPrefetcher(api: {
       headerOptions?: Record<string, string>;
     };
   }) => Promise<unknown>;
+  aggregate?: (opts: {
+    name: string;
+    filter?: Record<string, unknown>;
+    token?: string | null;
+    organizationId?: string | null;
+    options?: {
+      headerOptions?: Record<string, string>;
+    };
+  }) => Promise<unknown>;
   getTree?: (opts: {
     params?: Record<string, unknown>;
     token?: string | null;
@@ -121,4 +155,4 @@ declare function createCrudPrefetcher(api: {
   }) => Promise<unknown>;
 }, entityKey: string): CrudPrefetcher;
 //#endregion
-export { CrudPrefetcher, PrefetchAuthContext, PrefetchDetailOptions, PrefetchOptions, createCrudPrefetcher, dehydrate };
+export { CrudPrefetcher, HydrationBoundary, type InfiniteData, PrefetchAuthContext, PrefetchDetailOptions, PrefetchOptions, createCrudPrefetcher, dehydrate };

package/dist/prefetch.js

@@ -1,5 +1,5 @@
-import { createQueryKeys } from "./query.js";
-import { dehydrate } from "@tanstack/react-query";
+import { createQueryKeys } from "./cache.js";
+import { HydrationBoundary, dehydrate } from "@tanstack/react-query";
 
 //#region src/prefetch.ts
 /**
@@ -100,6 +100,26 @@ function createCrudPrefetcher(api, entityKey) {
 				staleTime: options.staleTime
 			});
 		},
+		async prefetchAggregation(queryClient, name, filter, options = {}) {
+			if (!api.aggregate) throw new Error(`[arc-next] prefetchAggregation requires an api with aggregate (arc 2.13+)`);
+			if (!name) throw new Error("[arc-next] prefetchAggregation: aggregation name is required");
+			const orgId = options.organizationId ?? null;
+			const filterKey = orgId ? {
+				_org: orgId,
+				...filter ?? {}
+			} : filter ?? {};
+			await queryClient.prefetchQuery({
+				queryKey: KEYS.aggregation(name, filterKey),
+				queryFn: () => api.aggregate({
+					name,
+					filter,
+					token: options.token ?? null,
+					organizationId: orgId,
+					...options.headers ? { options: { headerOptions: options.headers } } : {}
+				}),
+				staleTime: options.staleTime
+			});
+		},
 		async prefetchTree(queryClient, params = {}, options = {}) {
 			if (!api.getTree) throw new Error(`[arc-next] prefetchTree requires an api with getTree (tree preset)`);
 			const { organizationId: paramOrgId, ...restParams } = params;
@@ -118,9 +138,33 @@ function createCrudPrefetcher(api, entityKey) {
 				}),
 				staleTime: options.staleTime
 			});
+		},
+		async prefetchInfiniteList(queryClient, params = {}, options = {}) {
+			const { organizationId: paramOrgId, ...restParams } = params;
+			const orgId = paramOrgId ?? options.organizationId ?? null;
+			const scope = orgId ? "tenant" : "super-admin";
+			const queryKey = [...KEYS.scopedList(scope, {
+				...orgId ? { organizationId: orgId } : {},
+				...restParams
+			}), "infinite"];
+			await queryClient.prefetchInfiniteQuery({
+				queryKey,
+				queryFn: ({ pageParam }) => api.getAll({
+					params: {
+						...restParams,
+						...pageParam ? { page: pageParam } : {}
+					},
+					token: options.token ?? null,
+					organizationId: orgId,
+					...options.headers ? { options: { headerOptions: options.headers } } : {}
+				}),
+				initialPageParam: 1,
+				getNextPageParam: () => void 0,
+				staleTime: options.staleTime
+			});
 		}
 	};
 }
 
 //#endregion
-export { createCrudPrefetcher, dehydrate };
+export { HydrationBoundary, createCrudPrefetcher, dehydrate };

package/dist/presets/bulk.d.ts

@@ -0,0 +1,43 @@
+import { BaseApi, ScopedArgs } from "../api.js";
+import { BulkCreateResult, DeleteManyResult, UpdateManyResult } from "@classytic/repo-core/repository";
+
+//#region src/presets/bulk.d.ts
+interface BulkMethods<TDoc, TCreate = Partial<TDoc>, TUpdate = Partial<TDoc>> {
+  /** Insert many docs in one round-trip. Backend mounts `POST /:resource/bulk`. */
+  bulkCreate(args: ScopedArgs & {
+    data: TCreate[];
+  }): Promise<BulkCreateResult<TDoc>>;
+  /**
+   * Update all docs matching `filter` with `data`.
+   * Backend mounts `PATCH /:resource/bulk`.
+   */
+  bulkUpdate(args: ScopedArgs & {
+    filter: Record<string, unknown>;
+    data: TUpdate;
+  }): Promise<UpdateManyResult>;
+  /**
+   * Delete all docs matching `filter`.
+   * Backend mounts `DELETE /:resource/bulk`.
+   */
+  bulkDelete(args: ScopedArgs & {
+    filter: Record<string, unknown>;
+  }): Promise<DeleteManyResult>;
+}
+/**
+ * Adds bulk preset methods to a BaseApi.
+ *
+ * Mirrors arc's `bulk` preset — three /bulk routes for batch ops. Bulk endpoints
+ * require explicit per-resource permissions on the backend (the standard CRUD
+ * `allowPublic()` doesn't cover them).
+ *
+ * @example
+ * import { withBulk } from '@classytic/arc-next/presets/bulk';
+ * const todos = withBulk(createCrudApi<Todo>('todos'));
+ *
+ * await todos.bulkCreate({ data: [{ title: 'A' }, { title: 'B' }] });
+ * await todos.bulkUpdate({ filter: { status: 'pending' }, data: { status: 'archived' } });
+ * await todos.bulkDelete({ filter: { archivedBefore: '2024-01-01' } });
+ */
+declare function withBulk<TDoc, TCreate, TUpdate>(api: BaseApi<TDoc, TCreate, TUpdate>): BaseApi<TDoc, TCreate, TUpdate> & BulkMethods<TDoc, TCreate, TUpdate>;
+//#endregion
+export { BulkMethods, withBulk };

package/dist/presets/bulk.js

@@ -0,0 +1,50 @@
+//#region src/presets/bulk.ts
+/**
+* Adds bulk preset methods to a BaseApi.
+*
+* Mirrors arc's `bulk` preset — three /bulk routes for batch ops. Bulk endpoints
+* require explicit per-resource permissions on the backend (the standard CRUD
+* `allowPublic()` doesn't cover them).
+*
+* @example
+* import { withBulk } from '@classytic/arc-next/presets/bulk';
+* const todos = withBulk(createCrudApi<Todo>('todos'));
+*
+* await todos.bulkCreate({ data: [{ title: 'A' }, { title: 'B' }] });
+* await todos.bulkUpdate({ filter: { status: 'pending' }, data: { status: 'archived' } });
+* await todos.bulkDelete({ filter: { archivedBefore: '2024-01-01' } });
+*/
+function withBulk(api) {
+	return Object.assign(api, {
+		async bulkCreate({ token = null, organizationId = null, data, options = {} }) {
+			return api.request("POST", `${api.baseUrl}/bulk`, {
+				token,
+				organizationId,
+				data: { items: data },
+				options
+			});
+		},
+		async bulkUpdate({ token = null, organizationId = null, filter, data, options = {} }) {
+			return api.request("PATCH", `${api.baseUrl}/bulk`, {
+				token,
+				organizationId,
+				data: {
+					filter,
+					data
+				},
+				options
+			});
+		},
+		async bulkDelete({ token = null, organizationId = null, filter, options = {} }) {
+			return api.request("DELETE", `${api.baseUrl}/bulk`, {
+				token,
+				organizationId,
+				data: { filter },
+				options
+			});
+		}
+	});
+}
+
+//#endregion
+export { withBulk };

package/dist/presets/search.d.ts

@@ -0,0 +1,56 @@
+import { BaseApi, ScopedArgs } from "../api.js";
+import { PaginatedResult } from "@classytic/repo-core/pagination";
+
+//#region src/presets/search.d.ts
+interface SearchPresetMethods<TDoc> {
+  /**
+   * Engine-backed full-text search (Elastic, Algolia, Typesense...).
+   * Backend mounts `POST /:resource/search` via `searchPreset()`.
+   */
+  searchEngine<TResult = TDoc, TBody extends Record<string, unknown> = Record<string, unknown>>(args?: ScopedArgs & {
+    /** Free-text query forwarded as `body.query`. */query?: string; /** Engine-specific options merged into the request body. */
+    body?: TBody; /** Override path (default `/search`). */
+    path?: string;
+  }): Promise<TResult[] | PaginatedResult<TResult>>;
+  /**
+   * Vector / semantic similarity (Atlas, Pinecone, Qdrant...).
+   * Backend mounts `POST /:resource/search-similar`.
+   */
+  searchSimilar<TResult = TDoc, TBody extends Record<string, unknown> = Record<string, unknown>>(args?: ScopedArgs & {
+    /** Text query — backend embeds and searches for nearest neighbors. */query?: string; /** Pre-computed embedding vector — used directly for similarity search. */
+    vector?: number[]; /** Vector-engine options (`topK`, `filter`, `index`, ...). */
+    body?: TBody; /** Override path (default `/search-similar`). */
+    path?: string;
+  }): Promise<TResult[]>;
+  /**
+   * Convert text/media to a vector embedding via the engine the resource is wired to.
+   * Backend mounts `POST /:resource/embed`.
+   */
+  embed(args: ScopedArgs & {
+    /** Text or array of texts to embed. */input: string | string[]; /** Embed-engine options (`model`, `dimensions`, ...). */
+    body?: Record<string, unknown>; /** Override path (default `/embed`). */
+    path?: string;
+  }): Promise<number[] | number[][]>;
+}
+/**
+ * Adds search preset methods to a BaseApi.
+ *
+ * Mirrors arc's `searchPreset()` — three POST routes for engine-backed search,
+ * vector similarity, and embedding generation. Each route is independently
+ * permission-gated on the backend.
+ *
+ * Differs from {@link BaseApi.search} (a GET against the list endpoint with
+ * filter params) — that's the legacy filtered-list pattern. These methods hit
+ * the new POST routes the preset mounts.
+ *
+ * @example
+ * import { withSearchPreset } from '@classytic/arc-next/presets/search';
+ * const places = withSearchPreset(createCrudApi<Place>('places'));
+ *
+ * await places.searchEngine({ query: 'park', body: { filter: { category: 'park' } } });
+ * await places.searchSimilar({ vector: [0.1, 0.2, ...], body: { topK: 5 } });
+ * await places.embed({ input: 'hello world' });
+ */
+declare function withSearchPreset<TDoc, TCreate, TUpdate>(api: BaseApi<TDoc, TCreate, TUpdate>): BaseApi<TDoc, TCreate, TUpdate> & SearchPresetMethods<TDoc>;
+//#endregion
+export { SearchPresetMethods, withSearchPreset };

package/dist/presets/search.js

@@ -0,0 +1,60 @@
+//#region src/presets/search.ts
+/**
+* Adds search preset methods to a BaseApi.
+*
+* Mirrors arc's `searchPreset()` — three POST routes for engine-backed search,
+* vector similarity, and embedding generation. Each route is independently
+* permission-gated on the backend.
+*
+* Differs from {@link BaseApi.search} (a GET against the list endpoint with
+* filter params) — that's the legacy filtered-list pattern. These methods hit
+* the new POST routes the preset mounts.
+*
+* @example
+* import { withSearchPreset } from '@classytic/arc-next/presets/search';
+* const places = withSearchPreset(createCrudApi<Place>('places'));
+*
+* await places.searchEngine({ query: 'park', body: { filter: { category: 'park' } } });
+* await places.searchSimilar({ vector: [0.1, 0.2, ...], body: { topK: 5 } });
+* await places.embed({ input: 'hello world' });
+*/
+function withSearchPreset(api) {
+	return Object.assign(api, {
+		async searchEngine({ token = null, organizationId = null, query, body, path = "/search", options = {} } = {}) {
+			const requestBody = { ...body ?? {} };
+			if (query !== void 0) requestBody.query = query;
+			return api.request("POST", `${api.baseUrl}${path}`, {
+				token,
+				organizationId,
+				data: requestBody,
+				options
+			});
+		},
+		async searchSimilar({ token = null, organizationId = null, query, vector, body, path = "/search-similar", options = {} } = {}) {
+			const requestBody = { ...body ?? {} };
+			if (query !== void 0) requestBody.query = query;
+			if (vector !== void 0) requestBody.vector = vector;
+			return api.request("POST", `${api.baseUrl}${path}`, {
+				token,
+				organizationId,
+				data: requestBody,
+				options
+			});
+		},
+		async embed({ token = null, organizationId = null, input, body, path = "/embed", options = {} }) {
+			const requestBody = {
+				input,
+				...body ?? {}
+			};
+			return api.request("POST", `${api.baseUrl}${path}`, {
+				token,
+				organizationId,
+				data: requestBody,
+				options
+			});
+		}
+	});
+}
+
+//#endregion
+export { withSearchPreset };

package/dist/presets/slug.d.ts

@@ -0,0 +1,28 @@
+import { BaseApi, ScopedArgs } from "../api.js";
+
+//#region src/presets/slug.d.ts
+interface SlugLookupMethods<TDoc> {
+  /** Fetch a single doc by slug. Backend mounts `GET /:resource/slug/:slug`. */
+  getBySlug(args: ScopedArgs & {
+    slug: string;
+    params?: {
+      select?: string;
+      populate?: string | string[];
+    };
+  }): Promise<TDoc>;
+}
+/**
+ * Adds slug-lookup preset methods to a BaseApi.
+ *
+ * Mirrors arc's `slugLookup` preset — exposes `getBySlug` for resources keyed
+ * by URL-friendly slugs alongside the canonical id.
+ *
+ * @example
+ * import { withSlugLookup } from '@classytic/arc-next/presets/slug';
+ * const categories = withSlugLookup(createCrudApi<Category>('categories'));
+ *
+ * const cat = await categories.getBySlug({ slug: 'engineering' });
+ */
+declare function withSlugLookup<TDoc, TCreate, TUpdate>(api: BaseApi<TDoc, TCreate, TUpdate>): BaseApi<TDoc, TCreate, TUpdate> & SlugLookupMethods<TDoc>;
+//#endregion
+export { SlugLookupMethods, withSlugLookup };

package/dist/presets/slug.js

@@ -0,0 +1,27 @@
+//#region src/presets/slug.ts
+/**
+* Adds slug-lookup preset methods to a BaseApi.
+*
+* Mirrors arc's `slugLookup` preset — exposes `getBySlug` for resources keyed
+* by URL-friendly slugs alongside the canonical id.
+*
+* @example
+* import { withSlugLookup } from '@classytic/arc-next/presets/slug';
+* const categories = withSlugLookup(createCrudApi<Category>('categories'));
+*
+* const cat = await categories.getBySlug({ slug: 'engineering' });
+*/
+function withSlugLookup(api) {
+	return Object.assign(api, { async getBySlug({ token = null, organizationId = null, slug, params = {}, options = {} }) {
+		if (!slug) throw new Error("Slug is required");
+		return api.request("GET", `${api.baseUrl}/slug/${slug}`, {
+			token,
+			organizationId,
+			params,
+			options
+		});
+	} });
+}
+
+//#endregion
+export { withSlugLookup };

package/dist/presets/soft-delete.d.ts

@@ -0,0 +1,34 @@
+import { BaseApi, QueryParams, ScopedArgs } from "../api.js";
+import { PaginatedResult } from "@classytic/repo-core/pagination";
+
+//#region src/presets/soft-delete.d.ts
+interface SoftDeleteMethods<TDoc> {
+  /** List soft-deleted docs. Backend mounts `GET /:resource/deleted`. */
+  getDeleted(args?: ScopedArgs & {
+    params?: QueryParams;
+  }): Promise<PaginatedResult<TDoc>>;
+  /** Undo a soft-delete. Backend mounts `POST /:resource/:id/restore`. */
+  restore(args: ScopedArgs & {
+    id: string;
+  }): Promise<TDoc>;
+}
+/**
+ * Adds soft-delete preset methods to a BaseApi.
+ *
+ * Mirrors arc's server-side `softDelete` preset routes. Use when your resource
+ * is registered with `presets: ['softDelete']`. With this preset, `delete()`
+ * becomes soft-delete on the backend and {@link SoftDeleteMethods.restore}
+ * undoes it; {@link SoftDeleteMethods.getDeleted} lists the tombstones.
+ *
+ * @example
+ * import { createCrudApi } from '@classytic/arc-next/api';
+ * import { withSoftDelete } from '@classytic/arc-next/presets/soft-delete';
+ *
+ * const todos = withSoftDelete(createCrudApi<Todo>('todos'));
+ * await todos.delete({ id });             // soft delete (backend)
+ * await todos.restore({ id });            // undo
+ * const trash = await todos.getDeleted();
+ */
+declare function withSoftDelete<TDoc, TCreate, TUpdate>(api: BaseApi<TDoc, TCreate, TUpdate>): BaseApi<TDoc, TCreate, TUpdate> & SoftDeleteMethods<TDoc>;
+//#endregion
+export { SoftDeleteMethods, withSoftDelete };

package/dist/presets/soft-delete.js

@@ -0,0 +1,45 @@
+//#region src/presets/soft-delete.ts
+/**
+* Adds soft-delete preset methods to a BaseApi.
+*
+* Mirrors arc's server-side `softDelete` preset routes. Use when your resource
+* is registered with `presets: ['softDelete']`. With this preset, `delete()`
+* becomes soft-delete on the backend and {@link SoftDeleteMethods.restore}
+* undoes it; {@link SoftDeleteMethods.getDeleted} lists the tombstones.
+*
+* @example
+* import { createCrudApi } from '@classytic/arc-next/api';
+* import { withSoftDelete } from '@classytic/arc-next/presets/soft-delete';
+*
+* const todos = withSoftDelete(createCrudApi<Todo>('todos'));
+* await todos.delete({ id });             // soft delete (backend)
+* await todos.restore({ id });            // undo
+* const trash = await todos.getDeleted();
+*/
+function withSoftDelete(api) {
+	return Object.assign(api, {
+		async getDeleted({ token = null, organizationId = null, params = {}, options = {} } = {}) {
+			const merged = {
+				...api.config.defaultParams,
+				...params
+			};
+			return api.request("GET", `${api.baseUrl}/deleted`, {
+				token,
+				organizationId,
+				params: merged,
+				options
+			});
+		},
+		async restore({ token = null, organizationId = null, id, options = {} }) {
+			if (!id) throw new Error("ID is required");
+			return api.request("POST", `${api.baseUrl}/${id}/restore`, {
+				token,
+				organizationId,
+				options
+			});
+		}
+	});
+}
+
+//#endregion
+export { withSoftDelete };

package/dist/presets/tree.d.ts

@@ -0,0 +1,32 @@
+import { BaseApi, QueryParams, ScopedArgs } from "../api.js";
+import { PaginatedResult } from "@classytic/repo-core/pagination";
+
+//#region src/presets/tree.d.ts
+interface TreeMethods<TDoc> {
+  /** Fetch the full hierarchy. Backend mounts `GET /:resource/tree`. */
+  getTree(args?: ScopedArgs & {
+    params?: QueryParams;
+  }): Promise<TDoc[]>;
+  /** Fetch direct children of a node. Backend mounts `GET /:resource/:id/children`. */
+  getChildren(args: ScopedArgs & {
+    parentId: string;
+    params?: QueryParams;
+  }): Promise<PaginatedResult<TDoc>>;
+}
+/**
+ * Adds tree preset methods to a BaseApi.
+ *
+ * Mirrors arc's `tree` preset — for resources with a `parentId` field, exposes
+ * `getTree` (full hierarchy) and `getChildren` (one level deep). Backend caps
+ * tree depth via the preset config.
+ *
+ * @example
+ * import { withTree } from '@classytic/arc-next/presets/tree';
+ * const categories = withTree(createCrudApi<Category>('categories'));
+ *
+ * const root = await categories.getTree();
+ * const kids = await categories.getChildren({ parentId: 'engineering' });
+ */
+declare function withTree<TDoc, TCreate, TUpdate>(api: BaseApi<TDoc, TCreate, TUpdate>): BaseApi<TDoc, TCreate, TUpdate> & TreeMethods<TDoc>;
+//#endregion
+export { TreeMethods, withTree };

package/dist/presets/tree.js

@@ -0,0 +1,47 @@
+//#region src/presets/tree.ts
+/**
+* Adds tree preset methods to a BaseApi.
+*
+* Mirrors arc's `tree` preset — for resources with a `parentId` field, exposes
+* `getTree` (full hierarchy) and `getChildren` (one level deep). Backend caps
+* tree depth via the preset config.
+*
+* @example
+* import { withTree } from '@classytic/arc-next/presets/tree';
+* const categories = withTree(createCrudApi<Category>('categories'));
+*
+* const root = await categories.getTree();
+* const kids = await categories.getChildren({ parentId: 'engineering' });
+*/
+function withTree(api) {
+	return Object.assign(api, {
+		async getTree({ token = null, organizationId = null, params = {}, options = {} } = {}) {
+			const merged = {
+				...api.config.defaultParams,
+				...params
+			};
+			return api.request("GET", `${api.baseUrl}/tree`, {
+				token,
+				organizationId,
+				params: merged,
+				options
+			});
+		},
+		async getChildren({ token = null, organizationId = null, parentId, params = {}, options = {} }) {
+			if (!parentId) throw new Error("Parent ID is required");
+			const merged = {
+				...api.config.defaultParams,
+				...params
+			};
+			return api.request("GET", `${api.baseUrl}/${parentId}/children`, {
+				token,
+				organizationId,
+				params: merged,
+				options
+			});
+		}
+	});
+}
+
+//#endregion
+export { withTree };