@classytic/arc-next 0.2.1 → 0.4.0

package/README.md

@@ -30,13 +30,14 @@ import { useRouter } from "next/navigation";
 // Required — sets the API base URL and auth mode
 configureClient({
   baseUrl: process.env.NEXT_PUBLIC_API_URL!,
-  authMode: "cookie", // 'cookie' for Better Auth, 'bearer' for token auth (default)
-  internalApiKey: process.env.NEXT_PUBLIC_INTERNAL_API_KEY, // optional
+  authMode: "cookie",        // 'cookie' | 'bearer' (default) | 'header'
+  // apiVersion: '2',        // sends Accept-Version header
+  // autoIdempotency: true,  // auto Idempotency-Key on mutations (retry-safe)
 });
 
-// Optional — auto-inject org context into queries/mutations
+// Optional — auto-inject tenant context into queries/mutations
 configureAuth({
-  getOrgId: () => activeOrgId, // return current org ID
+  getOrgId: () => activeTenantId, // return current tenant/org/workspace ID
   getToken: () => null, // null for cookie auth (token only for bearer)
 });
 
@@ -51,13 +52,15 @@ configureNavigation(useRouter);
 
 | Import                              | Purpose                                                                      | `"use client"` |
 | ----------------------------------- | ---------------------------------------------------------------------------- | :-------------: |
+| `@classytic/arc-next`               | Root — same as `/hooks` (`createCrudHooks`, `configureNavigation`)           |      Yes        |
 | `@classytic/arc-next/client`        | `configureClient`, `configureAuth`, `createClient`, `handleApiRequest`, `createQueryString`, `ArcApiError`, `isArcApiError`, `getAuthMode`, `getAuthContext` |       No        |
 | `@classytic/arc-next/api`           | `BaseApi`, `createCrudApi`, response types, type guards                      |       No        |
-| `@classytic/arc-next/query`         | `createQueryKeys`, `createCacheUtils`, `createListQuery`, `createDetailQuery`|      Yes        |
-| `@classytic/arc-next/mutation`      | `configureToast`, `useMutationWithTransition`, `createOptimisticMutation`    |      Yes        |
+| `@classytic/arc-next/query`         | `createQueryKeys`, `createCacheUtils`, `useListQuery`, `useDetailQuery`      |      Yes        |
+| `@classytic/arc-next/mutation`      | `configureToast`, `useMutationWithTransition`, `useOptimisticMutation`       |      Yes        |
 | `@classytic/arc-next/hooks`         | `createCrudHooks`, `configureNavigation`                                     |      Yes        |
 | `@classytic/arc-next/query-client`  | `getQueryClient` (SSR-safe singleton)                                        |       No        |
 | `@classytic/arc-next/prefetch`      | `createCrudPrefetcher`, `dehydrate` (SSR prefetch)                           |       No        |
+| `@classytic/arc-next/sse`           | `useEventStream` (Server-Sent Events for real-time cache invalidation)       |      Yes        |
 
 No barrel index — every file is its own entry point. Tree-shakeable (`sideEffects: false`).
 
@@ -147,27 +150,32 @@ export function ProductsPage() {
 ```ts
 configureClient({
   baseUrl: string;                          // Required — API base URL
-  authMode?: 'cookie' | 'bearer';          // Default: 'bearer'
-  internalApiKey?: string;                  // Optional — sent as x-internal-api-key header
-  defaultHeaders?: Record<string, string>; // Optional — merged into every request
+  authMode?: 'bearer' | 'cookie' | 'header'; // Default: 'bearer'
+  credentials?: RequestCredentials;         // Default: derived from authMode
+  internalApiKey?: string;                  // Sent as x-internal-api-key header
+  defaultHeaders?: Record<string, string>; // Merged into every request
+  apiVersion?: string;                     // Sent as Accept-Version header
+  autoIdempotency?: boolean;               // Auto Idempotency-Key on mutations (retry-safe)
 });
 ```
 
-- `authMode: 'bearer'` (default) — requires a token for authenticated requests; queries are disabled until a token is provided
-- `authMode: 'cookie'` — auth via HTTP-only cookies (e.g. Better Auth); queries are always enabled, no token needed
+- `authMode: 'bearer'` (default) — requires token; queries disabled until provided
+- `authMode: 'cookie'` — HTTP-only cookies (e.g. Better Auth); queries always enabled
+- `authMode: 'header'` — custom header auth (e.g. `x-api-key`); uses `headerName` from `configureAuth`
 
-Must be called before any API requests. Throws if not configured.
+Must be called before any API requests. Warns if called on the server (SSR safety).
 
 ### `configureAuth(config)`
 
 ```ts
 configureAuth({
-  getToken?: () => string | null;   // For bearer auth — return access token
+  getToken?: () => string | null;   // For bearer/header auth — return access token or API key
   getOrgId?: () => string | null;   // Return active organization ID
+  headerName?: string;              // Custom header name for authMode: 'header' (default: 'x-api-key')
 });
 ```
 
-Auto-injects `token` and `organizationId` into queries/mutations. Hooks use the new signature (no explicit token param) — legacy signature still works.
+Auto-injects `token` and tenant ID (sent as `x-organization-id` header) into queries/mutations. The header name is a convention — your backend controls how it's read and which field it maps to (`organizationId`, `workspaceId`, `teamId`, etc.). Hooks use the new signature (no explicit token param) — legacy signature still works.
 
 ### `handleApiRequest<T>(method, endpoint, options?)`
 
@@ -226,18 +234,21 @@ const api = createCrudApi<Product, CreateProduct>("products", {
 
 ### `createCrudHooks<T, TCreate, TUpdate>(config)`
 
-Factory that returns everything you need:
+Factory that returns everything you need. The `api` parameter accepts any `createCrudApi()` result directly — no casts needed. Types are derived from `BaseApi` via `Pick`, so generics thread through automatically:
 
 ```ts
 const {
   KEYS, cache,
   useList, useDetail, useInfiniteList,
-  useActions, useUpload, useSearch, useCustomMutation,
+  useActions, useBulkActions,
+  useDeleted, useDetailBySlug, useTree, useChildren, useFindBy,
+  useUpload, useSearch, useCustomMutation,
   useNavigation,
 } = createCrudHooks<Product, CreateProduct>({
-    api: productsApi,       // from createCrudApi()
+    api: productsApi,       // from createCrudApi() — types inferred, no cast
     entityKey: "products",  // TanStack Query key prefix
     singular: "Product",    // for toast messages
+    idField: "sku",         // optional — custom ID field for cache keys (default: _id → id)
     defaults: {             // optional
       staleTime: 60_000,
       messages: { createSuccess: "Product added!" },
@@ -263,7 +274,7 @@ const { items, pagination, isLoading, isFetching, refetch } = useList(
 );
 ```
 
-- Auto-scopes query keys by `organizationId` (tenant vs super-admin)
+- Auto-scopes list query keys by tenant context (when present → `tenant` scope, otherwise → `super-admin`)
 - Normalizes pagination from `docs`/`data`/`items`/`results` formats
 - Prefills detail cache from list results (skips re-fetch on navigate)
 - `options.public: true` — enables query without token
@@ -390,6 +401,52 @@ const { mutateAsync: publish, isPending } = useCustomMutation({
 });
 ```
 
+#### `useDeleted(params?, options?)`
+
+List soft-deleted items. Requires `softDelete` preset on the Arc resource.
+
+#### `useDetailBySlug(slug, options?)`
+
+Fetch a single item by slug (`GET /slug/:slug`). Requires `slugLookup` preset.
+
+#### `useTree(params?, options?)`
+
+Fetch hierarchical tree data (`GET /tree`). Requires `tree` preset.
+
+#### `useChildren(parentId, params?, options?)`
+
+Fetch children of a parent node (`GET /:parentId/children`). Requires `tree` preset.
+
+#### `useFindBy(field, value, options?)`
+
+Query by a single field with optional operator:
+
+```ts
+const { items } = useFindBy("status", "active");
+const { items } = useFindBy("price", 50, { operator: "gte" });
+```
+
+#### `useBulkActions()`
+
+```ts
+const { bulkCreate, bulkUpdate, bulkRemove } = useBulkActions();
+await bulkCreate({ data: [{ name: "A" }, { name: "B" }] });
+```
+
+#### `useEventStream(options)` (from `./sse`)
+
+Subscribe to Arc SSE events with auto-reconnect and query invalidation:
+
+```ts
+import { useEventStream } from "@classytic/arc-next/sse";
+
+const { isConnected, lastEvent } = useEventStream({
+  resource: "agents",
+  patterns: ["agents.created", "agents.updated"],
+  invalidateQueries: [agentKeys.lists()],
+});
+```
+
 ### Query Keys (`KEYS`)
 
 ```ts
@@ -534,7 +591,7 @@ useProducts(token, {}, { ...QUERY_CONFIGS.realtime });
 
 ### `updateListCache(listData, updater)`
 
-Transforms list cache regardless of format (`docs[]`, `data[]`, `items[]`, `results[]`, or raw array).
+Transforms list cache regardless of format — well-known keys (`docs[]`, `data[]`, `items[]`, `results[]`), custom keys (`products[]`, `users[]`, etc.), or raw arrays.
 Automatically adjusts `total`/`totalDocs` counts when items are added or removed (optimistic add/delete).
 
 ```ts
@@ -551,11 +608,11 @@ Extracts `_id` or `id` from any item. Returns `string | null`.
 
 ### `normalizePagination(data)`
 
-Converts any pagination response format to a normalized `PaginationData` object. Handles `total`/`totalDocs`, `pages`/`totalPages`, `page`/`currentPage`, `hasNext`/`hasNextPage`/`hasMore`, `hasPrev`/`hasPrevPage`.
+Converts any pagination response format to a normalized `PaginationData` object. Detects pagination method (`offset`, `keyset`, `aggregate`) and normalizes all fields: `total`/`totalDocs`, `pages`/`totalPages`, `page`/`currentPage`, `hasNext`/`hasNextPage`/`hasMore`, `hasPrev`/`hasPrevPage`, `next` (keyset cursor).
 
 ### `extractItems<T>(data)`
 
-Extracts the items array from any response format — looks for `docs`, `data`, `items`, `results` fields, or returns the data directly if it's already an array.
+Extracts the items array from any response format. Checks well-known keys first (`docs`, `data`, `items`, `results`), then falls back to finding the first top-level array — so `{ products: [...] }` or `{ users: [...] }` works without configuration.
 
 ## Multi-Client (Multiple APIs)
 
@@ -654,8 +711,10 @@ try {
 ### Multi-tenant data fetching
 
 ```ts
-// organizationId in params → scoped query key → isolated cache per tenant
-const { items } = useProducts(token, { organizationId: currentOrg });
+// Tenant ID in params → scoped query key → isolated cache per tenant
+// The param name is up to you — arc-next sends it as x-organization-id header,
+// your backend maps it to whatever tenant field your schema uses.
+const { items } = useProducts(token, { organizationId: currentTenantId });
 ```
 
 ### Public endpoints (no auth)
@@ -704,12 +763,19 @@ const adminApi = createCrudApi("users", {
 
 - **CRUD Factory** — `createCrudApi` + `createCrudHooks` generates typed API clients and React Query hooks
 - **Optimistic Updates** — Create, update, delete with instant UI feedback and automatic rollback
-- **Multi-Tenant Scoping** — `organizationId` in headers + scoped query keys
-- **Pagination Normalization** — Handles `docs`/`data`/`items`/`results` response formats, offset/keyset/aggregate pagination
+- **Multi-Tenant Scoping** — Tenant ID sent via `x-organization-id` header + scoped list query keys. Backend controls the tenant field name and access enforcement.
+- **Pagination Normalization** — Handles `docs`/`data`/`items`/`results` + any custom key, offset/keyset/aggregate pagination
 - **Detail Cache Prefilling** — List results auto-populate detail query cache
 - **React 19 Transitions** — `useMutationWithTransition` wraps invalidation in `startTransition`
-- **Cookie & Bearer Auth** — `authMode: 'cookie'` for Better Auth, `'bearer'` for token auth
-- **SSR Prefetch** — `createCrudPrefetcher` + `dehydrate` for server component data loading
+- **Cookie, Bearer & Header Auth** — `authMode: 'cookie'` / `'bearer'` / `'header'` (custom header like `x-api-key`)
+- **Custom ID Fields** — `idField` on `createCrudHooks` for resources keyed by `sku`, `slug`, `code`, etc.
+- **Preset Hooks** — `useDeleted`, `useBulkActions`, `useDetailBySlug`, `useTree`, `useChildren`, `useFindBy`
+- **SSE Real-Time** — `useEventStream` with auto-reconnect, pattern filtering, query invalidation
+- **Infinite Scroll** — `maxPages` for memory management with automatic scroll-back support
+- **Idempotency** — `autoIdempotency` generates retry-safe keys at mutation level
+- **API Versioning** — `apiVersion` sends `Accept-Version` header
+- **SSR Prefetch** — `createCrudPrefetcher` + `prefetchBySlug` / `prefetchDeleted` / `prefetchTree`
+- **SSR Safety** — warns when `configureClient`/`configureAuth` called on the server
 - **Multi-Client** — `createClient()` for multiple API backends side by side
 - **Pluggable Toast** — `configureToast()` — use sonner, react-hot-toast, or anything
 - **Pluggable Navigation** — `configureNavigation()` — use Next.js, React Router, or any router

package/dist/api.d.ts

@@ -52,9 +52,22 @@ interface DeleteResponse {
     soft?: boolean;
   };
 }
+interface BulkCreateResponse<T = unknown> {
+  success: boolean;
+  data?: T[];
+  count?: number;
+}
+interface BulkUpdateResponse {
+  success: boolean;
+  modifiedCount?: number;
+}
+interface BulkDeleteResponse {
+  success: boolean;
+  deletedCount?: number;
+}
 type SortDirection = 1 | -1 | 'asc' | 'desc';
 type SortSpec = Record<string, SortDirection> | string;
-type FilterOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'contains' | 'startsWith' | 'endsWith' | 'regex';
+type FilterOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'contains' | 'startsWith' | 'endsWith' | 'regex' | 'like' | 'exists' | 'size' | 'type';
 interface QueryParams {
   page?: number;
   limit?: number;
@@ -65,6 +78,13 @@ interface QueryParams {
   populate?: string | string[];
   populateOptions?: PopulateOption[];
   lean?: boolean | 'true' | 'false';
+  /** Database-agnostic joins. Maps alias → collection or full lookup config. */
+  lookup?: Record<string, string | {
+    from: string;
+    localField: string;
+    foreignField: string;
+    select?: string;
+  }>;
   [key: string]: unknown;
 }
 interface RequestOptions {
@@ -77,16 +97,6 @@ interface RequestOptions {
   responseType?: 'json' | 'blob' | 'text';
   signal?: AbortSignal;
 }
-/**
- * Arc scope for multi-tenant APIs.
- *
- * - `'tenant'` (default) — Org-scoped. Hooks auto-inject `organizationId` from auth context.
- * - `'platform'` — Platform admin scope. Skips org injection, sets `x-arc-scope: platform`
- *   header so Arc's elevation plugin grants cross-org access for superadmins.
- */
-type ArcScope = 'tenant' | 'platform';
-/** Header name used by Arc's elevation plugin */
-declare const ARC_SCOPE_HEADER = "x-arc-scope";
 interface BaseApiConfig {
   basePath?: string;
   defaultParams?: {
@@ -96,32 +106,13 @@ interface BaseApiConfig {
   };
   cache?: RequestCache;
   headers?: Record<string, string>;
-  /**
-   * API scope — controls org context injection and Arc scope headers.
-   *
-   * @default 'tenant'
-   *
-   * @example
-   * ```ts
-   * // Org-scoped API (default) — auto-injects organizationId
-   * const postsApi = createCrudApi('posts', { basePath: '/api' });
-   *
-   * // Platform admin API — skips org injection, adds x-arc-scope header
-   * const adminApi = createCrudApi('subscriptions', {
-   *   basePath: '/api',
-   *   scope: 'platform',
-   * });
-   * ```
-   */
-  scope?: ArcScope;
   client?: ArcClient;
 }
 declare class BaseApi<TDoc = Record<string, unknown>, TCreate = Partial<TDoc>, TUpdate = Partial<TDoc>> {
   readonly entity: string;
-  readonly config: Required<Omit<BaseApiConfig, 'client' | 'scope'>>;
+  readonly config: Required<Omit<BaseApiConfig, 'client'>>;
   readonly baseUrl: string;
   private readonly requestFn;
-  readonly scope: ArcScope;
   constructor(entity: string, config?: BaseApiConfig);
   /** Merge per-instance headers into request options */
   private withHeaders;
@@ -247,6 +238,103 @@ declare class BaseApi<TDoc = Record<string, unknown>, TCreate = Partial<TDoc>, T
     params?: QueryParams;
     options?: Omit<RequestOptions, 'token' | 'organizationId'>;
   }): Promise<TResponse>;
+  getDeleted({
+    token,
+    organizationId,
+    params,
+    options
+  }?: {
+    token?: string | null;
+    organizationId?: string | null;
+    params?: QueryParams;
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<PaginatedResponse<TDoc>>;
+  restore({
+    token,
+    organizationId,
+    id,
+    options
+  }: {
+    token?: string | null;
+    organizationId?: string | null;
+    id: string;
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<ApiResponse<TDoc>>;
+  bulkCreate({
+    token,
+    organizationId,
+    data,
+    options
+  }: {
+    token?: string | null;
+    organizationId?: string | null;
+    data: TCreate[];
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<BulkCreateResponse<TDoc>>;
+  bulkUpdate({
+    token,
+    organizationId,
+    filter,
+    data,
+    options
+  }: {
+    token?: string | null;
+    organizationId?: string | null;
+    filter: Record<string, unknown>;
+    data: TUpdate;
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<BulkUpdateResponse>;
+  bulkDelete({
+    token,
+    organizationId,
+    filter,
+    options
+  }: {
+    token?: string | null;
+    organizationId?: string | null;
+    filter: Record<string, unknown>;
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<BulkDeleteResponse>;
+  getBySlug({
+    token,
+    organizationId,
+    slug,
+    params,
+    options
+  }: {
+    token?: string | null;
+    organizationId?: string | null;
+    slug: string;
+    params?: {
+      select?: string;
+      populate?: string | string[];
+    };
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<ApiResponse<TDoc>>;
+  getTree({
+    token,
+    organizationId,
+    params,
+    options
+  }?: {
+    token?: string | null;
+    organizationId?: string | null;
+    params?: QueryParams;
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<ApiResponse<TDoc[]>>;
+  getChildren({
+    token,
+    organizationId,
+    parentId,
+    params,
+    options
+  }: {
+    token?: string | null;
+    organizationId?: string | null;
+    parentId: string;
+    params?: QueryParams;
+    options?: Omit<RequestOptions, 'token' | 'organizationId'>;
+  }): Promise<PaginatedResponse<TDoc>>;
 }
 declare function createCrudApi<TDoc = Record<string, unknown>, TCreate = Partial<TDoc>, TUpdate = Partial<TDoc>>(entity: string, config?: BaseApiConfig): BaseApi<TDoc, TCreate, TUpdate>;
 type ExtractDoc<T> = T extends PaginatedResponse<infer D> ? D : never;
@@ -254,5 +342,4 @@ declare function isOffsetPagination<T>(response: PaginatedResponse<T>): response
 declare function isKeysetPagination<T>(response: PaginatedResponse<T>): response is KeysetPaginationResponse<T>;
 declare function isAggregatePagination<T>(response: PaginatedResponse<T>): response is AggregatePaginationResponse<T>;
 //#endregion
-export { ARC_SCOPE_HEADER, AggregatePaginationResponse, ApiResponse, ArcScope, BaseApi, BaseApiConfig, DeleteResponse, ExtractDoc, FilterOperator, KeysetPaginationResponse, OffsetPaginationResponse, PaginatedResponse, PopulateOption, QueryParams, RequestOptions, SortDirection, SortSpec, createCrudApi, isAggregatePagination, isKeysetPagination, isOffsetPagination };
-//# sourceMappingURL=api.d.ts.map
+export { AggregatePaginationResponse, ApiResponse, BaseApi, BaseApiConfig, BulkCreateResponse, BulkDeleteResponse, BulkUpdateResponse, DeleteResponse, ExtractDoc, FilterOperator, KeysetPaginationResponse, OffsetPaginationResponse, PaginatedResponse, PopulateOption, QueryParams, RequestOptions, SortDirection, SortSpec, createCrudApi, isAggregatePagination, isKeysetPagination, isOffsetPagination };

package/dist/api.js

@@ -1,19 +1,14 @@
 import { createQueryString, handleApiRequest } from "./client.js";
 
 //#region src/api.ts
-/** Header name used by Arc's elevation plugin */
-const ARC_SCOPE_HEADER = "x-arc-scope";
 var BaseApi = class {
 	entity;
 	config;
 	baseUrl;
 	requestFn;
-	scope;
 	constructor(entity, config = {}) {
 		this.entity = entity;
-		this.scope = config.scope ?? "tenant";
 		this.requestFn = config.client?.request ?? handleApiRequest;
-		const scopeHeaders = this.scope === "platform" ? { [ARC_SCOPE_HEADER]: "platform" } : {};
 		this.config = {
 			basePath: config.basePath ?? "/api/v1",
 			defaultParams: {
@@ -22,10 +17,7 @@ var BaseApi = class {
 				...config.defaultParams || {}
 			},
 			cache: config.cache ?? "no-store",
-			headers: {
-				...scopeHeaders,
-				...config.headers || {}
-			}
+			headers: { ...config.headers || {} }
 		};
 		this.baseUrl = `${this.config.basePath}/${this.entity}`;
 	}
@@ -56,6 +48,19 @@ var BaseApi = class {
 				if (Array.isArray(value) && value.length > 0) result[key] = value;
 				return;
 			}
+			if (key === "lookup") {
+				if (typeof value === "object" && value !== null) Object.entries(value).forEach(([alias, lv]) => {
+					if (typeof lv === "string") result[`lookup[${alias}]`] = lv;
+					else if (typeof lv === "object" && lv !== null) {
+						const cfg = lv;
+						result[`lookup[${alias}][from]`] = cfg.from;
+						result[`lookup[${alias}][localField]`] = cfg.localField;
+						result[`lookup[${alias}][foreignField]`] = cfg.foreignField;
+						if (cfg.select) result[`lookup[${alias}][select]`] = cfg.select;
+					}
+				});
+				return;
+			}
 			if (value !== void 0 && value !== "") if (["page", "limit"].includes(key)) result[key] = parseInt(String(value)) || (key === "page" ? 1 : 10);
 			else if (Array.isArray(value)) {
 				if (value.length > 1) result[`${key}[in]`] = value.join(",");
@@ -65,7 +70,11 @@ var BaseApi = class {
 		return result;
 	}
 	async getAll({ token = null, organizationId = null, params = {}, options = {} } = {}) {
-		const processedParams = this.prepareParams(params);
+		const mergedParams = {
+			...this.config.defaultParams,
+			...params
+		};
+		const processedParams = this.prepareParams(mergedParams);
 		const queryString = this.createQueryString(processedParams);
 		const requestOptions = {
 			cache: this.config.cache,
@@ -126,6 +135,7 @@ var BaseApi = class {
 	}
 	async search({ token = null, organizationId = null, searchParams = {}, params = {}, options = {} } = {}) {
 		const queryParams = {
+			...this.config.defaultParams,
 			...params,
 			...searchParams
 		};
@@ -141,7 +151,10 @@ var BaseApi = class {
 	}
 	async findBy({ token = null, organizationId = null, field, value, operator, params = {}, options = {} }) {
 		if (!field || value === void 0) throw new Error("Field and value are required");
-		const queryParams = { ...params };
+		const queryParams = {
+			...this.config.defaultParams,
+			...params
+		};
 		if (operator) queryParams[`${field}[${operator}]`] = Array.isArray(value) ? value.join(",") : value;
 		else queryParams[field] = value;
 		const processedParams = this.prepareParams(queryParams);
@@ -169,6 +182,97 @@ var BaseApi = class {
 		if (organizationId) requestOptions.organizationId = organizationId;
 		return this.requestFn(method, url, this.withHeaders(requestOptions));
 	}
+	async getDeleted({ token = null, organizationId = null, params = {}, options = {} } = {}) {
+		const mergedParams = {
+			...this.config.defaultParams,
+			...params
+		};
+		const processedParams = this.prepareParams(mergedParams);
+		const queryString = this.createQueryString(processedParams);
+		const requestOptions = {
+			cache: this.config.cache,
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("GET", `${this.baseUrl}/deleted?${queryString}`, this.withHeaders(requestOptions));
+	}
+	async restore({ token, organizationId = null, id, options = {} }) {
+		if (!id) throw new Error("ID is required");
+		const requestOptions = { ...options };
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("POST", `${this.baseUrl}/${id}/restore`, this.withHeaders(requestOptions));
+	}
+	async bulkCreate({ token, organizationId = null, data, options = {} }) {
+		const requestOptions = {
+			body: data,
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("POST", `${this.baseUrl}/bulk`, this.withHeaders(requestOptions));
+	}
+	async bulkUpdate({ token, organizationId = null, filter, data, options = {} }) {
+		const requestOptions = {
+			body: {
+				filter,
+				data
+			},
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("PATCH", `${this.baseUrl}/bulk`, this.withHeaders(requestOptions));
+	}
+	async bulkDelete({ token, organizationId = null, filter, options = {} }) {
+		const requestOptions = {
+			body: { filter },
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("DELETE", `${this.baseUrl}/bulk`, this.withHeaders(requestOptions));
+	}
+	async getBySlug({ token = null, organizationId = null, slug, params = {}, options = {} }) {
+		if (!slug) throw new Error("Slug is required");
+		const queryString = this.createQueryString(params);
+		const url = queryString ? `${this.baseUrl}/slug/${slug}?${queryString}` : `${this.baseUrl}/slug/${slug}`;
+		const requestOptions = {
+			cache: this.config.cache,
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("GET", url, this.withHeaders(requestOptions));
+	}
+	async getTree({ token = null, organizationId = null, params = {}, options = {} } = {}) {
+		const processedParams = this.prepareParams(params);
+		const queryString = this.createQueryString(processedParams);
+		const requestOptions = {
+			cache: this.config.cache,
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("GET", `${this.baseUrl}/tree?${queryString}`, this.withHeaders(requestOptions));
+	}
+	async getChildren({ token = null, organizationId = null, parentId, params = {}, options = {} }) {
+		if (!parentId) throw new Error("Parent ID is required");
+		const mergedParams = {
+			...this.config.defaultParams,
+			...params
+		};
+		const processedParams = this.prepareParams(mergedParams);
+		const queryString = this.createQueryString(processedParams);
+		const requestOptions = {
+			cache: this.config.cache,
+			...options
+		};
+		if (token) requestOptions.token = token;
+		if (organizationId) requestOptions.organizationId = organizationId;
+		return this.requestFn("GET", `${this.baseUrl}/${parentId}/children?${queryString}`, this.withHeaders(requestOptions));
+	}
 };
 function createCrudApi(entity, config = {}) {
 	return new BaseApi(entity, config);
@@ -184,5 +288,4 @@ function isAggregatePagination(response) {
 }
 
 //#endregion
-export { ARC_SCOPE_HEADER, BaseApi, createCrudApi, isAggregatePagination, isKeysetPagination, isOffsetPagination };
-//# sourceMappingURL=api.js.map
+export { BaseApi, createCrudApi, isAggregatePagination, isKeysetPagination, isOffsetPagination };