@asaidimu/hestia 1.0.1 → 1.0.2

package/index.d.cts

@@ -0,0 +1,920 @@
+import { QueryDSL, QueryFilter, SortConfiguration } from "@asaidimu/query";
+import { ApiResponse } from "@asaidimu/network-client";
+import { Issue, SystemError } from "@asaidimu/utils-error";
+import { DataStore, ReactiveDataStore } from "@asaidimu/utils-store";
+import { SchemaDefinition } from "@asaidimu/utils-schema";
+//#region core/types.d.ts
+interface DocumentMetadata {
+  checksum: string;
+  created: string;
+  updated: string;
+  version: number;
+}
+interface BaseDocument {
+  _id_: string;
+  _metadata_: DocumentMetadata;
+}
+type Document<T extends Record<string, any>> = BaseDocument & T;
+/**
+ * Provides comprehensive pagination information for a collection of records.
+ */
+type PaginationInfo = {
+  /** The current page number (1-based). */
+  number: number;
+  /** The maximum number of items requested per page. */
+  size: number;
+  /** The number of items in the current page */
+  count: number;
+  /** The total count of all items across all pages. */
+  total: number;
+  /** The total number of available pages. */
+  pages: number;
+};
+/**
+ * Represents a single paginated response containing a list of records and pagination details.
+ * @template T The type of the records in the page.
+ */
+interface Page<T extends Record<string, any>> {
+  /** The array of records for the current page. */
+  data: Document<T>[];
+  /** Indicates if the data query is currently loading. */
+  loading: boolean;
+  /** An error object if the query failed, otherwise `undefined`. */
+  error?: any | undefined;
+  /** Pagination metadata providing details about the current page and total collection. */
+  page: PaginationInfo;
+}
+interface PagerRefreshOptions {
+  sort?: SortConfiguration | SortConfiguration[];
+  filter?: QueryFilter;
+  delay?: number;
+  size?: number;
+  page?: number;
+}
+/**
+ * Represents the complete state and control mechanisms for consuming paginated data.
+ * @template T The type of the records in the page (`TableRowData` or an extension).
+ */
+interface PagedData<T extends Record<string, any>> {
+  id: () => string;
+  /** The current paginated data, or `undefined` if not found or still loading. */
+  page: () => Page<T>;
+  /** Function to fetch a specific page of data.
+   * @param page The 1-based page number to fetch.
+   */
+  navigate: (page: number) => Promise<void>;
+  sort: (sort: SortConfiguration<T> | SortConfiguration<T>[]) => Promise<void>;
+  filter: (filter?: QueryFilter<T>) => Promise<void>;
+  /**
+   * Function to change the page size of the data
+   */
+  resize: (size: number, page: number) => Promise<void>;
+  /**
+   * Function to force a refresh of the current page data, optionally with a delay.
+   * @param delay Optional delay in milliseconds before the refresh operation starts.
+   */
+  refresh: (opts?: PagerRefreshOptions) => Promise<void>;
+  /**
+   * Subscribes to page changes.
+   * The callback is invoked immediately with the current page, and then on every
+   * subsequent change (navigation, resize, SSE patch, refresh).
+   *
+   * @param listener A function that receives the current Page<T>.
+   * @returns An unsubscribe function.
+   */
+  subscribe: (listener: (page: Page<T>) => void) => () => void;
+  /**
+   * Invalidates the pagination controller, cleaning up any cached resources
+   * (e.g., store subscriptions, in‑flight requests) and removing internal state.
+   * After calling `invalidate()`, the controller should no longer be used.
+   *
+   * This is useful when the component using the pager is unmounted or when
+   * you need to reset the pagination state completely.
+   */
+  invalidate: () => void;
+}
+/**
+ * Represents an event emitted by the store, typically for notifications or state changes.
+ */
+interface StoreEvent {
+  /** The scope of the event, indicating its type and context. Custom scopes are allowed. */
+  scope: string;
+  /** Optional payload carrying data related to the event. */
+  payload?: any;
+}
+/**
+ * Defines the core interface for interacting with a remote data store.
+ * @template T The type of the records managed by the store, extending Record.
+ * @template TFindOptions Options for the find operation.
+ * @template TReadOptions Options for the read operation.
+ * @template TListOptions Options for the list operation.
+ * @template TPageOptions Options for the paging operation.
+ * @template TDeleteOptions Options for the delete operation.
+ * @template TUpdateOptions Options for the update operation.
+ * @template TCreateOptions Options for the create operation.
+ * @template TUploadOptions Options for the upload operation.
+ * @template TStreamOptions Options for the stream operation.
+ */
+interface DocumentStore<T extends Record<string, any>, TFindOptions = Record<string, unknown>, TReadOptions = Record<string, unknown>, TListOptions = Record<string, unknown>, TPageOptions = Record<string, unknown>, TDeleteOptions = Record<string, unknown>, TUpdateOptions = Record<string, unknown>, TCreateOptions = Record<string, unknown>, TUploadOptions = Record<string, unknown>, TStreamOptions = Record<string, unknown>> {
+  /**
+   * Finds records based on provided options, returning a paginated result.
+   * @param options The options for the find operation.
+   * @returns A promise that resolves to a Page of records.
+   */
+  find: (options: TFindOptions) => Promise<Page<T>>;
+  /**
+   * Reads a single record by its identifier or other read options.
+   * @param options The options for the read operation, typically including an ID.
+   * @returns A promise that resolves to the record or undefined if not found.
+   */
+  read: (options: TReadOptions) => Promise<Document<T> | undefined>;
+  /**
+   * Lists records based on provided options, returning a paginated result.
+   * @param options The options for the list operation.
+   * @returns A promise that resolves to a Page of records.
+   */
+  list: (options: TListOptions) => Promise<Page<T>>;
+  /**
+   * Deletes a record based on provided options, typically including an ID.
+   * @param options The options for the delete operation.
+   * @returns A promise that resolves when the deletion is complete.
+   */
+  delete: (options: TDeleteOptions) => Promise<void>;
+  /**
+   * Updates an existing record.
+   * @param props An object containing the ID of the record to update, the partial data, and optional update options.
+   * @returns A promise that resolves to the updated record or undefined if not found.
+   */
+  update: (props: {
+    data: Partial<T>;
+    options?: TUpdateOptions;
+  }) => Promise<Document<T> | undefined>;
+  /**
+   * Creates a new record.
+   * @param props An object containing the data for the new record and optional create options.
+   * @returns A promise that resolves to the newly created record or undefined if creation failed.
+   */
+  create: (props: {
+    data: Partial<T>;
+    options?: TCreateOptions;
+  }) => Promise<Document<T> | undefined>;
+  /**
+   * Uploads a file associated with a record. Optionally updates the record with upload details.
+   * @param props An object containing the file to upload and optional upload options.
+   * @returns A promise that resolves to the updated record after upload or undefined if upload failed.
+   */
+  upload: (props: {
+    file: File;
+    options?: TUploadOptions;
+  }) => Promise<Document<T> | undefined>;
+  /**
+   * Subscribes to store events for a given scope.
+   * @param scope The event scope to subscribe to (e.g., 'todos:created:success', '*').
+   * @param callback The function to call when an event matching the scope is received.
+   * @returns A promise that resolves to an unsubscribe function. Call this function to stop receiving events.
+   */
+  subscribe(scope: string, callback: (event: StoreEvent) => void): Promise<() => void>;
+  /**
+   * Notifies the store of an event, which can then be broadcast to subscribers.
+   * @param event The StoreEvent to notify.
+   * @returns A promise that resolves when the notification has been processed.
+   */
+  notify: (event: StoreEvent) => Promise<void>;
+  /**
+   * Establishes a stream of records based on provided options.
+   * @param options Options for configuring the stream (e.g., batch size, delay, filters).
+   * @param onStreamChange A callback function that is called when the stream's status changes.
+   * @returns An object containing the async iterable stream, a cancel function, and a status getter.
+   */
+  stream: (options: TStreamOptions, onStreamChange: () => void) => {
+    /** An async iterable that yields records as they become available in the stream. */
+    stream: () => AsyncIterable<Document<T>>;
+    /** A function to call to cancel the ongoing stream. */
+    cancel: () => void;
+    /** A getter function that returns the current status of the stream ('active', 'cancelled', or 'completed'). */
+    status: () => "active" | "cancelled" | "completed";
+  };
+  /**
+   * Creates a paginated data controller for this store.
+   *
+   * @param options - The pagination options, whose type is defined by the
+   *                  store's `TPageOptions` generic parameter. This lets you
+   *                  pass any configuration (e.g., filters, sorting, custom
+   *                  pagination metadata) that your store implementation needs.
+   * @returns A `PagedData<T>` controller that manages loading, navigation,
+   *          resizing, and refresh.
+   *
+   * @example
+   * // Define your store with a custom TPageOptions type
+   * interface MyTodoStore extends DocumentStore<
+   *   Todo,
+   *   FindOptions,
+   *   ReadOptions,
+   *   ListOptions,
+   *   { page: number; size: number; sort?: string; filter?: string }
+   * > {}
+   *
+   * // Use it
+   * const todosPaged = myTodoStore.page({
+   *   page: 1,
+   *   size: 10,
+   *   sort: 'createdAt',
+   *   filter: 'done:false'
+   * });
+   *
+   * // Get current page state
+   * const { data, loading, page } = todosPaged.page();
+   * console.log(`Page ${page.number} of ${page.pages}`);
+   *
+   * // Navigate
+   * await todosPaged.navigate(2);
+   */
+  page(options: TPageOptions): PagedData<T>;
+}
+//#endregion
+//#region system/identity/types.d.ts
+interface UserData {
+  email: string;
+  name: string;
+  verified: boolean;
+  permissions: string[];
+  deleted?: string | null;
+}
+type UserIdentity = Document<UserData>;
+interface CreateUserRequest {
+  email: string;
+  password: string;
+  name: string;
+  permissions?: string[];
+  verified?: boolean;
+}
+interface UpdateUserRequest {
+  name?: string;
+  email?: string;
+  permissions?: string[];
+  verified?: boolean;
+}
+interface ChangePasswordRequest {
+  current: string;
+  new: string;
+}
+//#endregion
+//#region core/client.d.ts
+interface IdentityProvider {
+  identity(): UserIdentity | null;
+  token(key: "access" | "refresh"): string | null;
+  setTokens(access: string, refresh: string): Promise<void>;
+  setIdentity(id: UserIdentity | null): Promise<void>;
+  clear(): Promise<void>;
+}
+declare class HestiaResponse<T> {
+  readonly data: T;
+  readonly status: number;
+  constructor(data: T, status: number);
+}
+type BodyType = "json" | "form" | "text" | "blob" | "stream" | "auto";
+type ResponseType = "json" | "text" | "blob" | "arrayBuffer" | "formData" | "auto";
+interface RequestOptions {
+  headers?: Record<string, string>;
+  responseType?: ResponseType;
+  bodyType?: BodyType;
+  signal?: AbortSignal;
+}
+interface StreamHandlers {
+  onMessage: (data: string) => void;
+  onError?: (err: Error) => void;
+  onOpen?: () => void;
+  onClose?: () => void;
+}
+interface StreamOptions {
+  headers?: Record<string, string>;
+  signal?: AbortSignal;
+}
+declare class HestiaNetworkClient {
+  private baseUrl;
+  private apiPrefix;
+  private tokens;
+  private onAuthStateChanged?;
+  private raw;
+  private refreshing;
+  private refreshFailed;
+  constructor(baseUrl: string, apiPrefix: string, tokens: IdentityProvider, onAuthStateChanged?: (() => void) | undefined);
+  base(): string;
+  prefix(): string;
+  private canonicalPath;
+  storeTokens(access: string, refresh?: string): Promise<void>;
+  private refreshToken;
+  private doRefresh;
+  private request;
+  get<T>(path: string, options?: RequestOptions): Promise<HestiaResponse<T>>;
+  post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<HestiaResponse<T>>;
+  patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<HestiaResponse<T>>;
+  put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<HestiaResponse<T>>;
+  delete<T>(path: string, body?: unknown, options?: RequestOptions): Promise<HestiaResponse<T>>;
+  openStream(path: string, handlers: StreamHandlers, options?: StreamOptions): Promise<void>;
+}
+//#endregion
+//#region core/collection.d.ts
+declare class HestiaCollection<T extends Record<string, any>> implements DocumentStore<T, Record<string, unknown>, string, Record<string, unknown>, Record<string, unknown>, string, string, Record<string, unknown>> {
+  private client;
+  private collectionName;
+  private defaultLimit;
+  private pagerOptions;
+  private pager;
+  constructor(client: HestiaNetworkClient, collectionName: string, defaultLimit?: number);
+  name(): string;
+  private get queryPath();
+  private get documentsPath();
+  private documentPath;
+  find(query?: Record<string, unknown>): Promise<Page<T>>;
+  read(id: string): Promise<Document<T> | undefined>;
+  create(props: {
+    data: Partial<T>;
+  }): Promise<Document<T> | undefined>;
+  update(props: {
+    data: Partial<T>;
+    options?: string;
+  }): Promise<Document<T> | undefined>;
+  delete(id: string): Promise<void>;
+  list(options?: Record<string, unknown>): Promise<Page<T>>;
+  upload(_props: {
+    file: File;
+  }): Promise<Document<T> | undefined>;
+  subscribe(_scope: string, _callback: (event: StoreEvent) => void): Promise<() => void>;
+  notify(_event: StoreEvent): Promise<void>;
+  stream(_options: Record<string, unknown>, _onStreamChange: () => void): {
+    stream: () => AsyncIterable<Document<T>>;
+    cancel: () => void;
+    status: () => "active" | "cancelled" | "completed";
+  };
+  page(_options?: Record<string, unknown>): PagedData<T>;
+}
+//#endregion
+//#region core/errors.d.ts
+interface ServerErrorBody {
+  code?: string;
+  message?: string;
+  details?: {
+    issues?: Issue[];
+  };
+}
+declare function parseErrorBody(raw: Response): Promise<ServerErrorBody | null>;
+declare function toSystemError(response: ApiResponse<unknown>, body: ServerErrorBody | null): SystemError;
+declare function notFound(path?: string): SystemError;
+declare function permissionDenied(operation?: string): SystemError;
+declare function internalError(cause?: unknown): SystemError;
+//#endregion
+//#region core/pager.d.ts
+interface PageOptions<T extends Record<string, any>> {
+  page?: number;
+  size?: number;
+  sort?: SortConfiguration<T> | SortConfiguration<T>[];
+  filter?: QueryFilter<T>;
+}
+declare function createPagedController<T extends Record<string, any>>(collectionName: string, store: DataStore<any>, options: PageOptions<T>, find: (query: QueryDSL<T>) => Promise<Page<T>>): PagedData<T>;
+//#endregion
+//#region auth/types.d.ts
+interface TokenPair {
+  access: string;
+  refresh: string;
+  type: string;
+  validity: number;
+}
+interface LoginResult {
+  token: TokenPair;
+  user: UserIdentity;
+}
+interface ServerHealth {
+  bootstrapped: boolean;
+  ok: boolean;
+}
+interface LoginRequest {
+  email: string;
+  password: string;
+}
+interface RegisterRequest {
+  email: string;
+  password: string;
+  name: string;
+}
+interface RefreshRequest {
+  refresh_token: string;
+}
+interface BootstrapPasswordRequest {
+  password: string;
+  email: string;
+}
+//#endregion
+//#region auth/store.d.ts
+declare class HestiaAuth {
+  private client;
+  private provider;
+  constructor(client: HestiaNetworkClient, provider: IdentityProvider);
+  health(): Promise<ServerHealth>;
+  login(email: string, password: string): Promise<LoginResult>;
+  register(email: string, password: string, name: string): Promise<{
+    _id_: string;
+    email: string;
+    name: string;
+  }>;
+  refresh(refreshToken?: string): Promise<TokenPair>;
+  logout(): Promise<void>;
+  requestPasswordReset(email: string): Promise<void>;
+  confirmPasswordReset(resetToken: string, password: string): Promise<void>;
+  bootstrap(key: string, password: string, email: string): Promise<void>;
+}
+//#endregion
+//#region system/identity/store.d.ts
+declare class HestiaUsers implements DocumentStore<UserData, QueryDSL<UserData>, string, QueryDSL<UserData>, Record<string, unknown>, string, string, Record<string, unknown>> {
+  private client;
+  private pagerOptions;
+  private pager;
+  constructor(client: HestiaNetworkClient);
+  name(): string;
+  find(query?: QueryDSL<UserData>): Promise<Page<UserData>>;
+  list(options?: QueryDSL<UserData>): Promise<Page<UserData>>;
+  read(id: string): Promise<Document<UserData> | undefined>;
+  update(props: {
+    data: Partial<UserData>;
+    options?: string;
+  }): Promise<Document<UserData> | undefined>;
+  delete(id: string): Promise<void>;
+  create(props: {
+    data: Partial<UserData>;
+  }): Promise<Document<UserData> | undefined>;
+  upload(_props: {
+    file: File;
+  }): Promise<Document<UserData> | undefined>;
+  subscribe(_scope: string, _callback: (event: StoreEvent) => void): Promise<() => void>;
+  notify(_event: StoreEvent): Promise<void>;
+  stream(_options: Record<string, unknown>, _onStreamChange: () => void): {
+    stream: () => AsyncIterable<Document<UserData>>;
+    cancel: () => void;
+    status: () => "active" | "cancelled" | "completed";
+  };
+  page(_options?: Record<string, unknown>): PagedData<UserData>;
+  changePassword(userId: string, current: string, newPassword: string): Promise<void>;
+}
+//#endregion
+//#region system/api-keys/types.d.ts
+interface APIKey {
+  _id_: string;
+  name: string;
+  prefix: string;
+  operations: string[];
+  status: string;
+  expiry?: string | null;
+  environment?: string;
+  usage?: number;
+  last_used?: string | null;
+  _metadata_: Record<string, unknown>;
+}
+interface APIKeyWithSecret extends APIKey {
+  key: string;
+}
+interface CreateKeyRequest {
+  name: string;
+  environment?: string;
+  operations?: string[];
+  expiry?: string;
+}
+interface UpdateKeyRequest {
+  name?: string;
+  environment?: string;
+  operations?: string[];
+  status?: "active" | "revoked";
+  expiry?: string;
+}
+//#endregion
+//#region system/api-keys/store.d.ts
+declare class HestiaKeyStore implements DocumentStore<APIKey, QueryDSL<APIKey>, string, QueryDSL<APIKey>, Record<string, unknown>, string, string, Record<string, unknown>> {
+  private client;
+  private pager;
+  constructor(client: HestiaNetworkClient);
+  private basePath;
+  find(_query?: QueryDSL<APIKey>): Promise<Page<APIKey>>;
+  list(options?: QueryDSL<APIKey>): Promise<Page<APIKey>>;
+  read(id: string): Promise<Document<APIKey> | undefined>;
+  create(props: {
+    data: Partial<APIKey>;
+  }): Promise<Document<APIKey> | undefined>;
+  update(props: {
+    data: Partial<APIKey>;
+    options?: string;
+  }): Promise<Document<APIKey> | undefined>;
+  delete(id: string): Promise<void>;
+  upload(_props: {
+    file: File;
+  }): Promise<Document<APIKey> | undefined>;
+  subscribe(_scope: string, _callback: (event: StoreEvent) => void): Promise<() => void>;
+  notify(_event: StoreEvent): Promise<void>;
+  stream(_options: Record<string, unknown>, _onStreamChange: () => void): {
+    stream: () => AsyncIterable<Document<APIKey>>;
+    cancel: () => void;
+    status: () => "active" | "cancelled" | "completed";
+  };
+  page(_options?: Record<string, unknown>): PagedData<APIKey>;
+  rotate(id: string): Promise<Document<APIKeyWithSecret>>;
+}
+//#endregion
+//#region system/policies/types.d.ts
+interface OperationPolicy {
+  name: string;
+  ruleKey: string;
+  description?: string;
+  intentType?: "COMMAND" | "QUERY";
+}
+interface UpsertOperationRequest {
+  ruleKey: string;
+  description?: string;
+  intentType?: "COMMAND" | "QUERY";
+}
+interface IamRule {
+  name: string;
+  ruleType?: string;
+  expression?: string;
+  description?: string;
+}
+interface UpsertRuleRequest {
+  expression: string;
+  ruleType?: string;
+  description?: string;
+}
+interface ValidateRuleRequest {
+  expression: string;
+  identity?: Record<string, unknown>;
+  resource?: Record<string, unknown>;
+  environment?: Record<string, unknown>;
+}
+interface ValidateRuleResult {
+  valid: boolean;
+  compile?: string;
+  result?: boolean;
+}
+interface ReloadResult {
+  operations: number;
+  rules: number;
+}
+//#endregion
+//#region system/policies/store.d.ts
+declare class HestiaPolicies implements DocumentStore<OperationPolicy, QueryDSL<OperationPolicy>, string, QueryDSL<OperationPolicy>, Record<string, unknown>, string, string, Record<string, unknown>> {
+  private client;
+  private pager;
+  private operationsPath;
+  private rulesPath;
+  constructor(client: HestiaNetworkClient);
+  private collectionQuery;
+  find(query?: QueryDSL<OperationPolicy>): Promise<Page<OperationPolicy>>;
+  list(options?: QueryDSL<OperationPolicy>): Promise<Page<OperationPolicy>>;
+  read(id: string): Promise<Document<OperationPolicy> | undefined>;
+  create(props: {
+    data: Partial<OperationPolicy>;
+  }): Promise<Document<OperationPolicy> | undefined>;
+  update(props: {
+    data: Partial<OperationPolicy>;
+    options?: string;
+  }): Promise<Document<OperationPolicy> | undefined>;
+  delete(id: string): Promise<void>;
+  upsertOperation(name: string, data: UpsertOperationRequest): Promise<Document<OperationPolicy>>;
+  getRule(name: string): Promise<Document<IamRule> | undefined>;
+  upsertRule(name: string, data: UpsertRuleRequest): Promise<Document<IamRule>>;
+  deleteRule(name: string): Promise<void>;
+  listRules(options?: Record<string, unknown>): Promise<Page<IamRule>>;
+  validateRule(expression: string): Promise<boolean>;
+  reload(): Promise<ReloadResult>;
+  upload(_props: {
+    file: File;
+  }): Promise<Document<OperationPolicy> | undefined>;
+  subscribe(_scope: string, _callback: (event: StoreEvent) => void): Promise<() => void>;
+  notify(_event: StoreEvent): Promise<void>;
+  stream(_options: Record<string, unknown>, _onStreamChange: () => void): {
+    stream: () => AsyncIterable<Document<OperationPolicy>>;
+    cancel: () => void;
+    status: () => "active" | "cancelled" | "completed";
+  };
+  page(_options?: Record<string, unknown>): PagedData<OperationPolicy>;
+}
+//#endregion
+//#region system/logs/types.d.ts
+interface AuditEntry {
+  event_id: string;
+  occurred_at: string;
+  recorded_at: string;
+  trace_id?: string;
+  request_id?: string;
+  actor_id: string;
+  actor_type: "user" | "service" | "system" | "anonymous";
+  on_behalf_of_id?: string;
+  auth_method?: "password" | "oauth" | "api_key" | "mtls" | "sso" | "service_account" | "none";
+  session_id?: string;
+  operation: "create" | "read" | "update" | "delete" | "login" | "logout" | "grant" | "revoke" | "execute" | "other";
+  resource_type: string;
+  resource_id?: string;
+  event_name: string;
+  status: "success" | "failure" | "denied" | "error";
+  severity?: "info" | "warning" | "critical";
+  error_code?: string;
+  error_message?: string;
+  latency_ms: number;
+  source_ip?: string;
+  user_agent?: string;
+  service_name: string;
+  region?: string;
+}
+type RequestLogEntry = AuditEntry;
+interface LogFilter {
+  actor_id?: string;
+  actor_type?: string;
+  operation?: string;
+  status?: string;
+  resource_type?: string;
+  trace_id?: string;
+  start?: string;
+  end?: string;
+}
+//#endregion
+//#region system/logs/store.d.ts
+declare class HestiaLogs implements DocumentStore<AuditEntry, QueryDSL<AuditEntry>, string, QueryDSL<AuditEntry>, Record<string, unknown>, string, string, Record<string, unknown>> {
+  private client;
+  private baseUrl;
+  private pagerOptions;
+  private pager;
+  private apiPrefix;
+  constructor(client: HestiaNetworkClient, baseUrl: string, apiPrefix?: string);
+  find(query?: QueryDSL<AuditEntry>): Promise<Page<AuditEntry>>;
+  list(options?: QueryDSL<AuditEntry>): Promise<Page<AuditEntry>>;
+  read(_id: string): Promise<Document<AuditEntry> | undefined>;
+  create(_props: {
+    data: Partial<AuditEntry>;
+  }): Promise<Document<AuditEntry> | undefined>;
+  update(_props: {
+    data: Partial<AuditEntry>;
+    options?: string;
+  }): Promise<Document<AuditEntry> | undefined>;
+  delete(_id: string): Promise<void>;
+  upload(_props: {
+    file: File;
+  }): Promise<Document<AuditEntry> | undefined>;
+  subscribe(_scope: string, _callback: (event: StoreEvent) => void): Promise<() => void>;
+  notify(_event: StoreEvent): Promise<void>;
+  stream(_options: Record<string, unknown>, _onStreamChange: () => void): {
+    stream: () => AsyncIterable<Document<AuditEntry>>;
+    cancel: () => void;
+    status: () => "active" | "cancelled" | "completed";
+  };
+  page(_options?: Record<string, unknown>): PagedData<AuditEntry>;
+  getStreamUrl(): string;
+}
+//#endregion
+//#region blobs/types.d.ts
+interface NamespaceInfo {
+  id: string;
+  display_name: string;
+}
+interface BlobMeta {
+  key: string;
+  namespace_id: string;
+  content_type: string;
+  size: number;
+  created_at: string;
+  updated_at?: string;
+  custom?: Record<string, any>;
+}
+type BlobDocument = Document<BlobMeta>;
+interface ListBlobsRequest {
+  prefix?: string;
+  limit?: number;
+}
+interface CreateNamespaceRequest {
+  display_name?: string;
+  ns?: string;
+}
+//#endregion
+//#region blobs/store.d.ts
+declare class BlobNamespace implements DocumentStore<BlobMeta, QueryDSL<BlobMeta>, string, QueryDSL<BlobMeta>, Record<string, unknown>, string, Record<string, any>, Record<string, unknown>, {
+  key: string;
+  contentType?: string;
+}, Record<string, unknown>> {
+  private client;
+  private ns;
+  private pagerOptions;
+  private pager;
+  private prefixFilter;
+  constructor(client: HestiaNetworkClient, ns: string);
+  name(): string;
+  setPrefix(prefix: string): void;
+  private basePath;
+  find(query?: QueryDSL<BlobMeta>): Promise<Page<BlobMeta>>;
+  read(key: string): Promise<Document<BlobMeta> | undefined>;
+  create(_props: {
+    data: Partial<BlobMeta>;
+  }): Promise<Document<BlobMeta> | undefined>;
+  update(props: {
+    data: Partial<BlobMeta>;
+    options?: Record<string, any>;
+  }): Promise<Document<BlobMeta> | undefined>;
+  delete(key: string): Promise<void>;
+  list(options?: QueryDSL<BlobMeta>): Promise<Page<BlobMeta>>;
+  upload(props: {
+    file: File;
+    options?: {
+      key?: string;
+      contentType?: string;
+    };
+  }): Promise<Document<BlobMeta> | undefined>;
+  subscribe(_scope: string, _callback: (event: StoreEvent) => void): Promise<() => void>;
+  notify(_event: StoreEvent): Promise<void>;
+  stream(_options: Record<string, unknown>, _onStreamChange: () => void): {
+    stream: () => AsyncIterable<Document<BlobMeta>>;
+    cancel: () => void;
+    status: () => "active" | "cancelled" | "completed";
+  };
+  page(_options?: Record<string, unknown>): PagedData<BlobMeta>;
+  download(key: string): Promise<{
+    data: Blob;
+    contentType: string;
+  }>;
+}
+declare class HestiaBlobClient {
+  private client;
+  private apiPrefix;
+  constructor(client: HestiaNetworkClient, apiPrefix?: string);
+  private nsBase;
+  namespaces(): Promise<NamespaceInfo[]>;
+  createNamespace(data: CreateNamespaceRequest): Promise<NamespaceInfo>;
+  deleteNamespace(ns: string): Promise<void>;
+  blob(namespace: string, key: string): string;
+  namespace(ns: string): BlobNamespace;
+}
+//#endregion
+//#region collections/types.d.ts
+interface CollectionMeta {
+  name: string;
+  schema: SchemaDefinition;
+  created: string;
+  updated: string;
+}
+type CollectionDocument = Document<{
+  schema: any;
+}>;
+//#endregion
+//#region collections/store.d.ts
+declare class HestiaCollections implements DocumentStore<CollectionMeta, Record<string, unknown>, string, Record<string, unknown>, Record<string, unknown>, string, string, Record<string, unknown>> {
+  private client;
+  constructor(client: HestiaNetworkClient);
+  find(_query?: Record<string, unknown>): Promise<Page<CollectionMeta>>;
+  read(name: string): Promise<Document<CollectionMeta> | undefined>;
+  create(props: {
+    data: Partial<CollectionMeta>;
+  }): Promise<Document<CollectionMeta> | undefined>;
+  update(_props: {
+    data: Partial<CollectionMeta>;
+    options?: string;
+  }): Promise<Document<CollectionMeta> | undefined>;
+  delete(name: string): Promise<void>;
+  list(_options?: Record<string, unknown>): Promise<Page<CollectionMeta>>;
+  upload(_props: {
+    file: File;
+  }): Promise<Document<CollectionMeta> | undefined>;
+  subscribe(_scope: string, _callback: (event: StoreEvent) => void): Promise<() => void>;
+  notify(_event: StoreEvent): Promise<void>;
+  stream(_options: Record<string, unknown>, _onStreamChange: () => void): {
+    stream: () => AsyncIterable<Document<CollectionMeta>>;
+    cancel: () => void;
+    status: () => "active" | "cancelled" | "completed";
+  };
+  page(_options?: Record<string, unknown>): PagedData<CollectionMeta>;
+  documents<T extends Record<string, any>>(collectionName: string): HestiaCollection<T>;
+}
+//#endregion
+//#region node_modules/@asaidimu/utils-persistence/index.d.ts
+interface SimplePersistence<T> {
+  /**
+   * Persists data to storage.
+   *
+   * @param id The **unique identifier of the *consumer instance*** making the change. This is NOT the ID of the data (`T`) itself.
+   * Think of it as the ID of the specific browser tab, component, or module that's currently interacting with the persistence layer.
+   * It should typically be a **UUID** generated once at the consumer instance's instantiation.
+   * This `id` is crucial for the `subscribe` method, helping to differentiate updates originating from the current instance versus other instances/tabs, thereby preventing self-triggered notification loops.
+   * @param state The state (of type T) to persist. This state is generally considered the **global or shared state** that all instances interact with.
+   * @returns `true` if the operation was successful, `false` if an error occurred. For asynchronous implementations (like `IndexedDBPersistence`), this returns a `Promise<boolean>`.
+   */
+  set(id: string, state: T): boolean | Promise<boolean>;
+  /**
+   * Retrieves the global persisted data from storage.
+   *
+   * @returns The retrieved state of type `T`, or `null` if no data is found or if an error occurs during retrieval/parsing.
+   * For asynchronous implementations, this returns a `Promise<T | null>`.
+   */
+  get(): (T | null) | Promise<T | null>;
+  /**
+   * Subscribes to changes in the global persisted data that originate from *other* instances of your application (e.g., other tabs or independent components using the same persistence layer).
+   *
+   * @param id The **unique identifier of the *consumer instance* subscribing**. This allows the persistence implementation to filter out notifications that were initiated by the subscribing instance itself.
+   * @param callback The function to call when the global persisted data changes from *another* source. The new state (`T`) is passed as an argument to this callback.
+   * @returns A function that, when called, will unsubscribe the provided callback from future updates. Call this when your component or instance is no longer active to prevent memory leaks.
+   */
+  subscribe(id: string, callback: (state: T) => void): () => void;
+  /**
+   * Clears (removes) the entire global persisted data from storage.
+   *
+   * @returns `true` if the operation was successful, `false` if an error occurred. For asynchronous implementations, this returns a `Promise<boolean>`.
+   */
+  clear(): boolean | Promise<boolean>;
+  /**
+   * Returns metadata about the persistence layer.
+   *
+   * This is useful for distinguishing between multiple apps running on the same host
+   * (e.g., several apps served at `localhost:3000` that share the same storage key).
+   *
+   * @returns An object containing:
+   * - `version`: The semantic version string of the persistence schema or application.
+   * - `id`: A unique identifier for the application using this persistence instance.
+   */
+  stats(): {
+    version: string;
+    id: string;
+  };
+  /**
+   * Closes the persistence instance, releasing the file watcher.
+   * Call this when shutting down to clean up resources.
+   */
+  close?: () => Promise<void>;
+}
+//#endregion
+//#region system/capabilities/store.d.ts
+declare class HestiaCapabilities implements DocumentStore<any, Record<string, unknown>, string, Record<string, unknown>, Record<string, unknown>, string, string, Record<string, unknown>> {
+  private client;
+  constructor(client: HestiaNetworkClient);
+  find(_query?: Record<string, unknown>): Promise<Page<any>>;
+  read(_id: string): Promise<Document<any> | undefined>;
+  create(_props: {
+    data: Partial<any>;
+  }): Promise<Document<any> | undefined>;
+  update(_props: {
+    data: Partial<any>;
+    options?: string;
+  }): Promise<Document<any> | undefined>;
+  delete(_id: string): Promise<void>;
+  list(_options?: Record<string, unknown>): Promise<Page<any>>;
+  upload(_props: {
+    file: File;
+  }): Promise<Document<any> | undefined>;
+  subscribe(_scope: string, _callback: (event: StoreEvent) => void): Promise<() => void>;
+  notify(_event: StoreEvent): Promise<void>;
+  stream(_options: Record<string, unknown>, _onStreamChange: () => void): {
+    stream: () => AsyncIterable<Document<any>>;
+    cancel: () => void;
+    status: () => "active" | "cancelled" | "completed";
+  };
+  page(_options?: Record<string, unknown>): PagedData<any>;
+}
+//#endregion
+//#region container.d.ts
+interface HestiaConfig {
+  baseUrl: string;
+  apiPrefix?: string;
+  persistence?: SimplePersistence<AuthState>;
+}
+interface AuthState {
+  access: string | null;
+  refresh: string | null;
+  identity: UserIdentity | null;
+}
+declare class HestiaClient {
+  readonly store: ReactiveDataStore<AuthState>;
+  readonly client: HestiaNetworkClient;
+  readonly auth: HestiaAuth;
+  readonly users: HestiaUsers;
+  readonly keys: HestiaKeyStore;
+  readonly policies: HestiaPolicies;
+  readonly logs: HestiaLogs;
+  readonly collections: HestiaCollections;
+  readonly blobs: HestiaBlobClient;
+  readonly capabilities: HestiaCapabilities;
+  private tokenProvider;
+  private onAuthStateChanged?;
+  constructor(config: HestiaConfig);
+  onAuthStateChange(callback: () => void): void;
+  authenticated(): boolean;
+  collection<T extends Record<string, any>>(name: string): HestiaCollection<T>;
+}
+//#endregion
+//#region utils/pager.d.ts
+interface FetchResult<T extends Record<string, any>> {
+  data: T[];
+  replace: boolean;
+  scope: 'page' | 'collection';
+  total?: number;
+}
+interface ArrayPagerOptions<T extends Record<string, any>, F = any> {
+  collectionName: string;
+  initialData?: T[];
+  page?: number;
+  size?: number;
+  customFunctions?: Record<string, (...args: any[]) => boolean>;
+  fetch?: (query: QueryDSL<T, F>) => Promise<FetchResult<T>> | FetchResult<T>;
+}
+declare function createArrayPager<T extends Record<string, any>, F = any>(options: ArrayPagerOptions<T, F>): PagedData<T>;
+//#endregion
+export { APIKey, APIKeyWithSecret, ArrayPagerOptions, AuditEntry, BlobDocument, BlobMeta, BlobNamespace, BootstrapPasswordRequest, ChangePasswordRequest, CollectionDocument, CollectionMeta, CreateKeyRequest, CreateNamespaceRequest, CreateUserRequest, Document, DocumentStore, FetchResult, HestiaAuth, HestiaBlobClient, HestiaClient, HestiaCollection, HestiaCollections, HestiaKeyStore, HestiaLogs, HestiaNetworkClient, HestiaPolicies, HestiaResponse, HestiaUsers, IamRule, IdentityProvider, ListBlobsRequest, LogFilter, LoginRequest, LoginResult, NamespaceInfo, OperationPolicy, Page, PagedData, PagerRefreshOptions, PaginationInfo, RefreshRequest, RegisterRequest, ReloadResult, RequestLogEntry, ServerHealth, StoreEvent, StreamHandlers, StreamOptions, TokenPair, UpdateKeyRequest, UpdateUserRequest, UpsertOperationRequest, UpsertRuleRequest, UserData, UserIdentity, ValidateRuleRequest, ValidateRuleResult, createArrayPager, createPagedController, internalError, notFound, parseErrorBody, permissionDenied, toSystemError };