alepha 0.10.1 → 0.10.3

package/server.d.ts

@@ -1,6 +1,6 @@
-import * as _alepha_core7 from "alepha";
+import * as _alepha_core11 from "alepha";
 import { Alepha, AlephaError, Async, Descriptor, FileLike, KIND, Static, StreamLike, TArray, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
-import * as _alepha_logger2 from "alepha/logger";
+import * as _alepha_logger3 from "alepha/logger";
 import { Readable } from "node:stream";
 import { ReadableStream } from "node:stream/web";
 import { Route, RouterProvider } from "alepha/router";
@@ -176,13 +176,13 @@ declare class ServerRequestParser {
 //#region src/providers/ServerTimingProvider.d.ts
 type TimingMap = Record<string, [number, number]>;
 declare class ServerTimingProvider {
-  protected readonly log: _alepha_logger2.Logger;
+  protected readonly log: _alepha_logger3.Logger;
   protected readonly alepha: Alepha;
   options: {
     disabled: boolean;
   };
-  readonly onRequest: _alepha_core7.HookDescriptor<"server:onRequest">;
-  readonly onResponse: _alepha_core7.HookDescriptor<"server:onResponse">;
+  readonly onRequest: _alepha_core11.HookDescriptor<"server:onRequest">;
+  readonly onResponse: _alepha_core11.HookDescriptor<"server:onResponse">;
   protected get handlerName(): string;
   beginTiming(name: string): void;
   endTiming(name: string): void;
@@ -222,7 +222,7 @@ declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
 //#endregion
 //#region src/services/HttpClient.d.ts
 declare class HttpClient {
-  protected readonly log: _alepha_logger2.Logger;
+  protected readonly log: _alepha_logger3.Logger;
   protected readonly alepha: Alepha;
   readonly cache: _alepha_cache0.CacheDescriptorFn<HttpClientCache, any[]>;
   protected readonly pendingRequests: HttpClientPendingRequests;
@@ -334,8 +334,9 @@ interface HttpAction {
  * import { t } from "alepha";
  *
  * class UserController {
- *   // GET /api/users
+ *
  *   getUsers = $action({
+ *     path: "/users",
  *     description: "Retrieve all users with pagination",
  *     schema: {
  *       query: t.object({
@@ -366,8 +367,9 @@ interface HttpAction {
  *     }
  *   });
  *
- *   // POST /api/users
  *   createUser = $action({
+ *     method: "POST",
+ *     path: "/users",
  *     description: "Create a new user account",
  *     schema: {
  *       body: t.object({
@@ -402,8 +404,8 @@ interface HttpAction {
  *     }
  *   });
  *
- *   // GET /api/users/:id
  *   getUser = $action({
+ *     path: "/users/:id",
  *     description: "Retrieve user by ID",
  *     schema: {
  *       params: t.object({
@@ -430,9 +432,9 @@ interface HttpAction {
  *     }
  *   });
  *
- *   // PUT /api/users/:id
  *   updateUser = $action({
  *     method: "PUT",
+ *     path: "/users/:id",
  *     description: "Update user information",
  *     schema: {
  *       params: t.object({ id: t.string() }),
@@ -460,363 +462,6 @@ interface HttpAction {
  * }
  * ```
  *
- * @example
- * **File upload with multipart form data:**
- * ```ts
- * class FileController {
- *   uploadAvatar = $action({
- *     method: "POST",
- *     description: "Upload user avatar image",
- *     schema: {
- *       body: t.object({
- *         file: t.file({
- *           maxSize: 5 * 1024 * 1024, // 5MB
- *           allowedMimeTypes: ["image/jpeg", "image/png", "image/webp"]
- *         }),
- *         userId: t.string()
- *       }),
- *       response: t.object({
- *         url: t.string({ format: "uri" }),
- *         size: t.number(),
- *         mimeType: t.string(),
- *         uploadedAt: t.datetime()
- *       })
- *     },
- *     handler: async ({ body }) => {
- *       const { file, userId } = body;
- *
- *       // Validate file
- *       await this.fileService.validateImage(file);
- *
- *       // Generate unique filename
- *       const filename = `avatars/${userId}/${Date.now()}-${file.name}`;
- *
- *       // Upload to storage
- *       const uploadResult = await this.storageService.upload(filename, file);
- *
- *       // Update user profile
- *       await this.userService.updateAvatar(userId, uploadResult.url);
- *
- *       return {
- *         url: uploadResult.url,
- *         size: file.size,
- *         mimeType: file.type,
- *         uploadedAt: new Date().toISOString()
- *       };
- *     }
- *   });
- *
- *   downloadFile = $action({
- *     method: "GET",
- *     description: "Download file by ID",
- *     schema: {
- *       params: t.object({ id: t.string() }),
- *       query: t.object({
- *         download: t.optional(t.boolean()),
- *         thumbnail: t.optional(t.boolean())
- *       }),
- *       response: t.file()
- *     },
- *     handler: async ({ params, query, reply, user }) => {
- *       const file = await this.fileService.findById(params.id);
- *       if (!file) {
- *         throw new Error("File not found");
- *       }
- *
- *       // Check permissions
- *       await this.fileService.checkAccess(params.id, user.id);
- *
- *       const fileBuffer = query.thumbnail
- *         ? await this.fileService.getThumbnail(file.id)
- *         : await this.fileService.getBuffer(file.path);
- *
- *       // Set appropriate headers
- *       reply.header("Content-Type", file.mimeType);
- *       reply.header("Content-Length", fileBuffer.length);
- *
- *       if (query.download) {
- *         reply.header("Content-Disposition", `attachment; filename="${file.name}"`);
- *       }
- *
- *       return fileBuffer;
- *     }
- *   });
- * }
- * ```
- *
- * @example
- * **Advanced API with custom paths and grouped operations:**
- * ```ts
- * class OrderController {
- *   group = "orders"; // Groups all actions under "orders" tag
- *
- *   // GET /api/orders/search
- *   searchOrders = $action({
- *     name: "search",
- *     path: "/orders/search", // Custom path
- *     description: "Advanced order search with filtering",
- *     schema: {
- *       query: t.object({
- *         status: t.optional(t.union([
- *           t.literal("pending"),
- *           t.literal("processing"),
- *           t.literal("shipped"),
- *           t.literal("delivered"),
- *           t.literal("cancelled")
- *         ])),
- *         customerId: t.optional(t.string()),
- *         dateFrom: t.optional(t.date()),
- *         dateTo: t.optional(t.date()),
- *         minAmount: t.optional(t.number({ minimum: 0 })),
- *         maxAmount: t.optional(t.number({ minimum: 0 })),
- *         sortBy: t.optional(t.union([
- *           t.literal("createdAt"),
- *           t.literal("amount"),
- *           t.literal("status")
- *         ])),
- *         sortOrder: t.optional(t.enum(["asc", "desc"]))
- *       }),
- *       response: t.object({
- *         orders: t.array(t.object({
- *           id: t.string(),
- *           orderNumber: t.string(),
- *           customerId: t.string(),
- *           customerName: t.string(),
- *           status: t.string(),
- *           totalAmount: t.number(),
- *           createdAt: t.datetime(),
- *           itemCount: t.number()
- *         })),
- *         pagination: t.object({
- *           page: t.number(),
- *           limit: t.number(),
- *           total: t.number(),
- *           hasMore: t.boolean()
- *         }),
- *         filters: t.object({
- *           appliedFilters: t.array(t.string()),
- *           availableStatuses: t.array(t.string())
- *         })
- *       })
- *     },
- *     handler: async ({ query }) => {
- *       // Build dynamic query based on filters
- *       const searchCriteria = this.orderService.buildSearchCriteria(query);
- *       const results = await this.orderService.searchOrders(searchCriteria);
- *
- *       return {
- *         orders: results.orders,
- *         pagination: results.pagination,
- *         filters: {
- *           appliedFilters: Object.keys(query).filter(key => query[key] !== undefined),
- *           availableStatuses: await this.orderService.getAvailableStatuses()
- *         }
- *       };
- *     }
- *   });
- *
- *   // POST /api/orders/:id/process
- *   processOrder = $action({
- *     method: "POST",
- *     path: "/orders/:id/process",
- *     description: "Process an order through the fulfillment workflow",
- *     schema: {
- *       params: t.object({ id: t.string() }),
- *       body: t.object({
- *         notes: t.optional(t.string()),
- *         priority: t.optional(t.union([
- *           t.literal("low"),
- *           t.literal("normal"),
- *           t.literal("high"),
- *           t.literal("urgent")
- *         ])),
- *         assignToWarehouse: t.optional(t.string())
- *       }),
- *       response: t.object({
- *         orderId: t.string(),
- *         status: t.string(),
- *         processedAt: t.datetime(),
- *         estimatedFulfillment: t.datetime(),
- *         trackingInfo: t.optional(t.object({
- *           trackingNumber: t.string(),
- *           carrier: t.string(),
- *           estimatedDelivery: t.date()
- *         }))
- *       })
- *     },
- *     handler: async ({ params, body, user }) => {
- *       // Validate order can be processed
- *       const order = await this.orderService.findById(params.id);
- *       if (!order || order.status !== "pending") {
- *         throw new Error("Order cannot be processed in current status");
- *       }
- *
- *       // Check inventory availability
- *       const inventoryCheck = await this.inventoryService.checkAvailability(order.items);
- *       if (!inventoryCheck.available) {
- *         throw new Error(`Insufficient inventory: ${inventoryCheck.missingItems.join(", ")}`);
- *       }
- *
- *       // Process the order
- *       const processResult = await this.fulfillmentService.processOrder({
- *         orderId: params.id,
- *         options: {
- *           notes: body.notes,
- *           priority: body.priority || "normal",
- *           warehouse: body.assignToWarehouse
- *         }
- *       });
- *
- *       // Update order status
- *       await this.orderService.updateStatus(params.id, "processing", {
- *         processedBy: user.id,
- *         processedAt: new Date(),
- *         notes: body.notes
- *       });
- *
- *       // Send notification
- *       await this.notificationService.sendOrderUpdate(order.customerId, {
- *         orderId: params.id,
- *         status: "processing",
- *         message: "Your order is now being processed"
- *       });
- *
- *       return {
- *         orderId: params.id,
- *         status: "processing",
- *         processedAt: new Date().toISOString(),
- *         estimatedFulfillment: processResult.estimatedCompletion,
- *         trackingInfo: processResult.trackingInfo
- *       };
- *     }
- *   });
- * }
- * ```
- *
- * @example
- * **Actions with security integration and role-based access:**
- * ```ts
- * class AdminController {
- *   group = "admin";
- *
- *   // Only accessible to users with "admin:users:read" permission
- *   getUserStats = $action({
- *     description: "Get comprehensive user statistics",
- *     security: { permissions: ["admin:users:read"] },
- *     schema: {
- *       query: t.object({
- *         includeInactive: t.optional(t.boolean())
- *       }),
- *       response: t.object({
- *         totalUsers: t.number(),
- *         activeUsers: t.number(),
- *         newUsers: t.number(),
- *         userGrowth: t.number(),
- *         breakdown: t.object({
- *           byRole: t.record(t.string(), t.number()),
- *           byStatus: t.record(t.string(), t.number()),
- *           byRegistrationSource: t.record(t.string(), t.number())
- *         }),
- *         trends: t.array(t.object({
- *           date: t.date(),
- *           registrations: t.number(),
- *           activations: t.number()
- *         }))
- *       })
- *     },
- *     handler: async ({ query, user }) => {
- *       // user is available through security integration
- *       this.auditLogger.log({
- *         action: "admin.getUserStats",
- *         userId: user.id,
- *         userRole: user.role,
- *         timestamp: new Date()
- *       });
- *
- *       const period = query.period || "month";
- *       const stats = await this.analyticsService.getUserStatistics({
- *         period,
- *         includeInactive: query.includeInactive || false
- *       });
- *
- *       return stats;
- *     }
- *   });
- *
- *   // Bulk operations with transaction support
- *   bulkUpdateUsers = $action({
- *     method: "POST",
- *     path: "/admin/users/bulk-update",
- *     description: "Bulk update user properties",
- *     security: { permissions: ["admin:users:write"] },
- *     schema: {
- *       body: t.object({
- *         userIds: t.array(t.string(), { minItems: 1, maxItems: 1000 }),
- *         updates: t.object({
- *           status: t.optional(t.union([t.literal("active"), t.literal("inactive")])),
- *           role: t.optional(t.string()),
- *           tags: t.optional(t.array(t.string())),
- *           customFields: t.optional(t.record(t.string(), t.any()))
- *         }),
- *         reason: t.string({ minLength: 10, maxLength: 500 })
- *       }),
- *       response: t.object({
- *         updated: t.number(),
- *         failed: t.number(),
- *         errors: t.array(t.object({
- *           userId: t.string(),
- *           error: t.string()
- *         })),
- *         auditLogId: t.string()
- *       })
- *     },
- *     handler: async ({ body, user }) => {
- *       const results = { updated: 0, failed: 0, errors: [] };
- *
- *       // Create audit log entry
- *       const auditLogId = await this.auditService.logBulkOperation({
- *         operation: "bulk_user_update",
- *         initiatedBy: user.id,
- *         targetCount: body.userIds.length,
- *         reason: body.reason,
- *         changes: body.updates
- *       });
- *
- *       // Process in batches to avoid overwhelming the database
- *       const batchSize = 50;
- *       for (let i = 0; i < body.userIds.length; i += batchSize) {
- *         const batch = body.userIds.slice(i, i + batchSize);
- *
- *         try {
- *           const updateResult = await this.userService.bulkUpdate(batch, body.updates);
- *           results.updated += updateResult.success;
- *           results.failed += updateResult.failed;
- *           results.errors.push(...updateResult.errors);
- *         } catch (error) {
- *           // Log batch failure but continue processing
- *           this.logger.error(`Bulk update batch failed`, {
- *             batch: i / batchSize + 1,
- *             userIds: batch,
- *             error: error.message
- *           });
- *
- *           results.failed += batch.length;
- *           results.errors.push(...batch.map(userId => ({
- *             userId,
- *             error: error.message
- *           })));
- *         }
- *       }
- *
- *       // Update audit log with results
- *       await this.auditService.updateBulkOperationResults(auditLogId, results);
- *
- *       return { ...results, auditLogId };
- *     }
- *   });
- * }
- * ```
- *
  * **Important Notes**:
  * - Actions are automatically registered with the HTTP server when the service is initialized
  * - Use `run()` for direct invocation (testing, internal calls, or remote services)
@@ -824,12 +469,9 @@ interface HttpAction {
  * - Schema validation occurs automatically for all requests and responses
  * - Path parameters are automatically extracted from schema definitions
  * - Content-Type headers are automatically set based on schema types
- * - Actions can be disabled via the `disabled` option for maintenance or feature flags
- *
- * @stability 2
  */
 declare const $action: {
-  <TConfig extends RequestConfigSchema>(options: ActionDescriptorOptions<TConfig>): ActionDescriptor<TConfig>;
+  <TConfig extends RequestConfigSchema>(options: ActionDescriptorOptions<TConfig>): ActionDescriptorFn<TConfig>;
   [KIND]: typeof ActionDescriptor;
 };
 interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
@@ -899,7 +541,7 @@ interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends O
   handler: ServerActionHandler<TConfig>;
 }
 declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<TConfig>> {
-  protected readonly log: _alepha_logger2.Logger;
+  protected readonly log: _alepha_logger3.Logger;
   protected readonly env: {
     SERVER_API_PREFIX: string;
   };
@@ -939,12 +581,15 @@ declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Desc
    */
   fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
 }
+interface ActionDescriptorFn<TConfig extends RequestConfigSchema> extends ActionDescriptor<TConfig> {
+  (config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
+}
 type ClientRequestEntry<TConfig extends RequestConfigSchema, T = ClientRequestEntryContainer<TConfig>> = { [K in keyof T as T[K] extends undefined ? never : K]: T[K] };
 type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
-  body: TConfig["body"] extends TSchema ? Static<TConfig["body"]> : undefined;
-  params: TConfig["params"] extends TSchema ? Static<TConfig["params"]> : undefined;
-  headers?: TConfig["headers"] extends TSchema ? Static<TConfig["headers"]> : undefined;
-  query?: TConfig["query"] extends TSchema ? Partial<Static<TConfig["query"]>> : undefined;
+  body: TConfig["body"] extends TObject ? Static<TConfig["body"]> : undefined;
+  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : undefined;
+  headers?: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : undefined;
+  query?: TConfig["query"] extends TObject ? Partial<Static<TConfig["query"]>> : undefined;
 };
 interface ClientRequestOptions extends FetchOptions {
   /**
@@ -1068,9 +713,9 @@ declare const okSchema: typebox0.TObject<{
 type Ok = Static<typeof okSchema>;
 //#endregion
 //#region src/providers/NodeHttpServerProvider.d.ts
-declare const envSchema: _alepha_core7.TObject<{
-  SERVER_PORT: _alepha_core7.TInteger;
-  SERVER_HOST: _alepha_core7.TString;
+declare const envSchema: _alepha_core11.TObject<{
+  SERVER_PORT: _alepha_core11.TInteger;
+  SERVER_HOST: _alepha_core11.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -1078,31 +723,31 @@ declare module "alepha" {
 declare class NodeHttpServerProvider extends ServerProvider {
   protected readonly alepha: Alepha;
   protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly log: _alepha_logger2.Logger;
+  protected readonly log: _alepha_logger3.Logger;
   protected readonly env: {
     SERVER_PORT: number;
     SERVER_HOST: string;
   };
   protected readonly router: ServerRouterProvider;
   protected readonly server: http0.Server<typeof IncomingMessage, typeof ServerResponse$1>;
-  protected readonly onNodeRequest: _alepha_core7.HookDescriptor<"node:request">;
+  protected readonly onNodeRequest: _alepha_core11.HookDescriptor<"node:request">;
   handle(req: IncomingMessage, res: ServerResponse$1): Promise<void>;
   createRouterRequest(req: IncomingMessage, res: ServerResponse$1, params?: Record<string, string>): ServerRawRequest;
   getProtocol(req: IncomingMessage): "http" | "https";
   get hostname(): string;
-  readonly start: _alepha_core7.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core7.HookDescriptor<"stop">;
+  readonly start: _alepha_core11.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core11.HookDescriptor<"stop">;
   protected listen(): Promise<void>;
   protected close(): Promise<void>;
 }
 //#endregion
 //#region src/providers/ServerLoggerProvider.d.ts
 declare class ServerLoggerProvider {
-  protected readonly log: _alepha_logger2.Logger;
+  protected readonly log: _alepha_logger3.Logger;
   protected readonly alepha: Alepha;
-  readonly onRequest: _alepha_core7.HookDescriptor<"server:onRequest">;
-  readonly onError: _alepha_core7.HookDescriptor<"server:onError">;
-  readonly onResponse: _alepha_core7.HookDescriptor<"server:onResponse">;
+  readonly onRequest: _alepha_core11.HookDescriptor<"server:onRequest">;
+  readonly onError: _alepha_core11.HookDescriptor<"server:onError">;
+  readonly onResponse: _alepha_core11.HookDescriptor<"server:onResponse">;
 }
 //#endregion
 //#region src/providers/ServerNotReadyProvider.d.ts
@@ -1115,7 +760,7 @@ declare class ServerLoggerProvider {
  */
 declare class ServerNotReadyProvider {
   protected readonly alepha: Alepha;
-  readonly onRequest: _alepha_core7.HookDescriptor<"server:onRequest">;
+  readonly onRequest: _alepha_core11.HookDescriptor<"server:onRequest">;
 }
 //#endregion
 //#region src/index.d.ts
@@ -1183,7 +828,7 @@ declare module "alepha" {
  * @see {@link $action}
  * @module alepha.server
  */
-declare const AlephaServer: _alepha_core7.Service<_alepha_core7.Module>;
+declare const AlephaServer: _alepha_core11.Service<_alepha_core11.Module<{}>>;
 //#endregion
-export { $action, $route, ActionDescriptor, ActionDescriptorOptions, AlephaServer, BadRequestError, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ConflictError, ErrorSchema, FetchActionArgs, FetchOptions, FetchResponse, ForbiddenError, HttpAction, HttpClient, HttpClientPendingRequests, HttpError, HttpErrorLike, NodeHttpServerProvider, NotFoundError, Ok, RequestConfigSchema, ResponseBodyType, ResponseKind, RouteDescriptor, RouteDescriptorOptions, RouteMethod, ServerActionHandler, ServerActionRequest, ServerHandler, ServerLoggerProvider, ServerNotReadyProvider, ServerProvider, ServerRawRequest, ServerReply, ServerRequest, ServerRequestConfig, ServerRequestConfigEntry, ServerResponse, ServerResponseBody, ServerRoute, ServerRouteMatcher, ServerRouteRequestHandler, ServerRouterProvider, ServerTimingProvider, TRequestBody, TResponseBody, UnauthorizedError, ValidationError, errorNameByStatus, errorSchema, isHttpError, isMultipart, okSchema, routeMethods };
+export { $action, $route, ActionDescriptor, ActionDescriptorFn, ActionDescriptorOptions, AlephaServer, BadRequestError, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ConflictError, ErrorSchema, FetchActionArgs, FetchOptions, FetchResponse, ForbiddenError, HttpAction, HttpClient, HttpClientPendingRequests, HttpError, HttpErrorLike, NodeHttpServerProvider, NotFoundError, Ok, RequestConfigSchema, ResponseBodyType, ResponseKind, RouteDescriptor, RouteDescriptorOptions, RouteMethod, ServerActionHandler, ServerActionRequest, ServerHandler, ServerLoggerProvider, ServerNotReadyProvider, ServerProvider, ServerRawRequest, ServerReply, ServerRequest, ServerRequestConfig, ServerRequestConfigEntry, ServerResponse, ServerResponseBody, ServerRoute, ServerRouteMatcher, ServerRouteRequestHandler, ServerRouterProvider, ServerTimingProvider, TRequestBody, TResponseBody, UnauthorizedError, ValidationError, errorNameByStatus, errorSchema, isHttpError, isMultipart, okSchema, routeMethods };
 //# sourceMappingURL=index.d.ts.map

package/topic/redis.d.ts

@@ -36,7 +36,7 @@ declare class RedisTopicProvider extends TopicProvider {
  * @see {@link RedisTopicProvider}
  * @module alepha.topic.redis
  */
-declare const AlephaTopicRedis: _alepha_core1.Service<_alepha_core1.Module>;
+declare const AlephaTopicRedis: _alepha_core1.Service<_alepha_core1.Module<{}>>;
 //#endregion
 export { AlephaTopicRedis, RedisTopicProvider };
 //# sourceMappingURL=index.d.ts.map

package/topic.d.ts

@@ -948,7 +948,7 @@ declare class MemoryTopicProvider extends TopicProvider {
  * @see {@link $subscriber}
  * @module alepha.topic
  */
-declare const AlephaTopic: _alepha_core1.Service<_alepha_core1.Module>;
+declare const AlephaTopic: _alepha_core1.Service<_alepha_core1.Module<{}>>;
 //#endregion
 export { $subscriber, $topic, AlephaTopic, MemoryTopicProvider, SubscribeCallback, SubscriberDescriptor, SubscriberDescriptorOptions, TopicDescriptor, TopicDescriptorOptions, TopicHandler, TopicMessage, TopicMessageSchema, TopicProvider, TopicTimeoutError, TopicWaitOptions, UnSubscribeFn };
 //# sourceMappingURL=index.d.ts.map