@snackbase/sdk 0.1.0

package/dist/index-Dr6K4PMl.d.mts

@@ -0,0 +1,2118 @@
+//#region src/types/config.d.ts
+type LogLevel$1 = 'debug' | 'info' | 'warn' | 'error';
+type StorageBackend = 'localStorage' | 'sessionStorage' | 'memory' | 'asyncStorage';
+interface SnackBaseConfig {
+  /**
+   * API base URL (required)
+   */
+  baseUrl: string;
+  /**
+   * Request timeout in milliseconds (default: 30000)
+   */
+  timeout?: number;
+  /**
+   * Optional API key for service authentication
+   */
+  apiKey?: string;
+  /**
+   * Enable automatic token refresh (default: true)
+   */
+  enableAutoRefresh?: boolean;
+  /**
+   * Refresh tokens N seconds before expiry (default: 300)
+   */
+  refreshBeforeExpiry?: number;
+  /**
+   * Maximum retry attempts for failed requests (default: 3)
+   */
+  maxRetries?: number;
+  /**
+   * Delay between retries in milliseconds (default: 1000)
+   */
+  retryDelay?: number;
+  /**
+   * Token storage backend.
+   * 'localStorage' or 'sessionStorage' for web,
+   * 'asyncStorage' for React Native.
+   * Default: auto-detect based on platform.
+   */
+  storageBackend?: StorageBackend;
+  /**
+   * Enable request/response logging (default: false in production)
+   */
+  enableLogging?: boolean;
+  /**
+   * Logging level (default: 'error')
+   */
+  logLevel?: LogLevel$1;
+  /**
+   * Callback for 401 authentication errors
+   */
+  onAuthError?: (error: any) => void;
+  /**
+   * Callback for network failures
+   */
+  onNetworkError?: (error: any) => void;
+  /**
+   * Callback for 429 rate limit errors
+   */
+  onRateLimitError?: (error: any) => void;
+  /**
+   * Default account slug/ID for single-tenant mode (optional)
+   */
+  defaultAccount?: string;
+  /**
+   * Maximum reconnection attempts for real-time (default: 10)
+   */
+  maxRealTimeRetries?: number;
+  /**
+   * Initial delay for real-time reconnection in milliseconds (default: 1000)
+   */
+  realTimeReconnectionDelay?: number;
+}
+declare const DEFAULT_CONFIG: Partial<SnackBaseConfig>;
+//#endregion
+//#region src/core/logger.d.ts
+declare enum LogLevel {
+  NONE = 0,
+  ERROR = 1,
+  WARN = 2,
+  INFO = 3,
+  DEBUG = 4
+}
+interface LogEntry {
+  timestamp: string;
+  level: LogLevel;
+  message: string;
+  data?: any;
+}
+declare class Logger {
+  private level;
+  private handlers;
+  private logs;
+  private maxLogs;
+  constructor(level?: LogLevel);
+  setLevel(level: LogLevel): void;
+  getLogs(): LogEntry[];
+  clearLogs(): void;
+  private log;
+  error(message: string, data?: any): void;
+  warn(message: string, data?: any): void;
+  info(message: string, data?: any): void;
+  debug(message: string, data?: any): void;
+}
+//#endregion
+//#region src/core/http-client.d.ts
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+interface HttpRequest {
+  url: string;
+  method: HttpMethod;
+  headers: Record<string, string>;
+  body?: any;
+  params?: Record<string, string | number | boolean | undefined>;
+  timeout?: number;
+  signal?: AbortSignal;
+}
+interface HttpResponse<T = any> {
+  data: T;
+  status: number;
+  headers: Headers;
+  request: HttpRequest;
+}
+type RequestInterceptor = (request: HttpRequest) => HttpRequest | Promise<HttpRequest>;
+type ResponseInterceptor = (response: HttpResponse) => HttpResponse | Promise<HttpResponse>;
+type ErrorInterceptor = (error: any) => any | Promise<any>;
+interface HttpClientConfig {
+  baseUrl: string;
+  timeout?: number;
+  maxRetries?: number;
+  retryDelay?: number;
+  logger?: Logger;
+}
+/**
+ * Robust HTTP client wrapping the fetch API.
+ */
+declare class HttpClient {
+  private config;
+  private requestInterceptors;
+  private responseInterceptors;
+  private errorInterceptors;
+  constructor(config: HttpClientConfig);
+  addRequestInterceptor(interceptor: RequestInterceptor): void;
+  addResponseInterceptor(interceptor: ResponseInterceptor): void;
+  addErrorInterceptor(interceptor: ErrorInterceptor): void;
+  request<T = any>(req: Partial<HttpRequest>): Promise<HttpResponse<T>>;
+  get<T = any>(url: string, config?: Partial<HttpRequest>): Promise<HttpResponse<T>>;
+  post<T = any>(url: string, body?: any, config?: Partial<HttpRequest>): Promise<HttpResponse<T>>;
+  put<T = any>(url: string, body?: any, config?: Partial<HttpRequest>): Promise<HttpResponse<T>>;
+  patch<T = any>(url: string, body?: any, config?: Partial<HttpRequest>): Promise<HttpResponse<T>>;
+  delete<T = any>(url: string, config?: Partial<HttpRequest>): Promise<HttpResponse<T>>;
+  private resolveUrl;
+  private shouldRetry;
+  private calculateRetryDelay;
+}
+//#endregion
+//#region src/types/account.d.ts
+interface Account$1 {
+  id: string;
+  slug: string;
+  name: string;
+  created_at: string;
+}
+interface AccountCreate {
+  name: string;
+  slug?: string;
+}
+interface AccountUpdate {
+  name: string;
+}
+interface AccountListParams {
+  page?: number;
+  page_size?: number;
+  search?: string;
+  is_active?: boolean;
+  sort_by?: string;
+  sort_order?: 'asc' | 'desc';
+  [key: string]: string | number | boolean | undefined;
+}
+interface AccountListResponse {
+  items: Account$1[];
+  total: number;
+}
+interface AccountUserListParams {
+  page?: number;
+  page_size?: number;
+  [key: string]: string | number | boolean | undefined;
+}
+//#endregion
+//#region src/types/user.d.ts
+interface User$1 {
+  id: string;
+  email: string;
+  role: string;
+  groups: string[];
+  is_active: boolean;
+  created_at: string;
+  last_login: string | null;
+}
+interface UserCreate {
+  email: string;
+  password?: string;
+  account_id: string;
+  role?: string;
+}
+interface UserUpdate {
+  email?: string;
+  role?: string;
+  is_active?: boolean;
+}
+interface UserListParams {
+  page?: number;
+  page_size?: number;
+  account_id?: string;
+  role_id?: string;
+  is_active?: boolean;
+  search?: string;
+  sort_by?: string;
+  sort_order?: 'asc' | 'desc';
+  [key: string]: string | number | boolean | undefined;
+}
+interface UserListResponse {
+  items: User$1[];
+  total: number;
+}
+//#endregion
+//#region src/types/auth.d.ts
+interface AuthState {
+  user: User | null;
+  account: Account | null;
+  token: string | null;
+  refreshToken: string | null;
+  isAuthenticated: boolean;
+  expiresAt: string | null;
+}
+type AuthEvent = 'auth:login' | 'auth:logout' | 'auth:refresh' | 'auth:error';
+interface AuthEvents {
+  'auth:login': (state: AuthState) => void;
+  'auth:logout': () => void;
+  'auth:refresh': (state: AuthState) => void;
+  'auth:error': (error: Error) => void;
+}
+interface LoginCredentials {
+  account?: string;
+  email: string;
+  password: string;
+}
+interface RegisterData {
+  email: string;
+  password: string;
+  accountName?: string;
+  accountSlug?: string;
+}
+interface AuthResponse {
+  user: User;
+  account: Account;
+  token?: string;
+  refreshToken?: string;
+  expiresAt?: string;
+}
+interface PasswordResetRequest {
+  account?: string;
+  email: string;
+}
+interface PasswordResetConfirm {
+  token: string;
+  newPassword: string;
+}
+type OAuthProvider = 'google' | 'github' | 'microsoft' | 'apple';
+interface OAuthUrlResponse {
+  url: string;
+  state: string;
+}
+interface OAuthCallbackParams {
+  provider: OAuthProvider;
+  code: string;
+  redirectUri: string;
+  state: string;
+}
+interface OAuthResponse extends AuthResponse {
+  isNewUser: boolean;
+  isNewAccount: boolean;
+}
+type SAMLProvider = 'okta' | 'azure_ad' | 'generic_saml';
+interface SAMLUrlResponse {
+  url: string;
+}
+interface SAMLCallbackParams {
+  SAMLResponse: string;
+  relayState?: string;
+}
+interface SAMLResponse extends AuthResponse {
+  isNewUser: boolean;
+  isNewAccount: boolean;
+}
+//#endregion
+//#region src/core/storage.d.ts
+interface AuthStorage {
+  getItem(key: string): string | null | Promise<string | null>;
+  setItem(key: string, value: string): void | Promise<void>;
+  removeItem(key: string): void | Promise<void>;
+}
+//#endregion
+//#region src/core/auth.d.ts
+interface AuthManagerOptions {
+  storage: AuthStorage;
+  storageKey?: string;
+}
+declare class AuthManager {
+  private state;
+  private storage;
+  private storageKey;
+  private events;
+  constructor(options: AuthManagerOptions);
+  initialize(): Promise<void>;
+  getState(): AuthState;
+  get user(): User$1 | null;
+  get account(): Account$1 | null;
+  get token(): string | null;
+  get refreshToken(): string | null;
+  get isAuthenticated(): boolean;
+  setState(newState: Partial<AuthState>): Promise<void>;
+  clear(): Promise<void>;
+  on<K extends keyof AuthEvents>(event: K, listener: AuthEvents[K]): () => void;
+  private hydrate;
+  private persist;
+  private validateSession;
+}
+//#endregion
+//#region src/core/auth-service.d.ts
+/**
+ * Service for handling authentication operations.
+ */
+declare class AuthService {
+  private http;
+  private auth;
+  private apiKey?;
+  private defaultAccount?;
+  private oauthStates;
+  private readonly STATE_EXPIRY_MS;
+  constructor(http: HttpClient, auth: AuthManager, apiKey?: string | undefined, defaultAccount?: string | undefined);
+  /**
+   * Helper to ensure API key is not used for user-specific operations.
+   */
+  private checkApiKeyRestriction;
+  /**
+   * Authenticate a user with email and password.
+   */
+  login(credentials: LoginCredentials): Promise<AuthResponse>;
+  /**
+   * Register a new user and account.
+   */
+  register(data: RegisterData): Promise<AuthResponse>;
+  /**
+   * Refresh the access token using the refresh token.
+   */
+  refreshToken(): Promise<AuthResponse>;
+  /**
+   * Log out the current user.
+   */
+  logout(): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Get the current authenticated user profile.
+   */
+  getCurrentUser(): Promise<AuthResponse>;
+  /**
+   * Initiate password reset flow.
+   */
+  forgotPassword(data: PasswordResetRequest): Promise<{
+    message: string;
+  }>;
+  /**
+   * Reset password using a token.
+   */
+  resetPassword(data: PasswordResetConfirm): Promise<{
+    message: string;
+  }>;
+  /**
+   * Verify email using a token.
+   */
+  verifyEmail(token: string): Promise<{
+    message: string;
+  }>;
+  /**
+   * Resend the verification email to the current user.
+   */
+  resendVerificationEmail(): Promise<{
+    message: string;
+  }>;
+  /**
+   * Send a verification email to a specific email address.
+   * This can be used by admins to send verification emails to users.
+   */
+  sendVerification(email: string): Promise<{
+    message: string;
+  }>;
+  /**
+   * Verify a password reset token is valid.
+   * Returns the email associated with the token if valid.
+   */
+  verifyResetToken(token: string): Promise<{
+    email: string;
+  }>;
+  /**
+   * Generate OAuth authorization URL for the specified provider.
+   */
+  getOAuthUrl(provider: OAuthProvider, redirectUri: string, state?: string): Promise<OAuthUrlResponse>;
+  /**
+   * Handle OAuth callback and authenticate user.
+   */
+  handleOAuthCallback(params: OAuthCallbackParams): Promise<OAuthResponse>;
+  /**
+   * Generate SAML SSO authorization URL for the specified provider and account.
+   */
+  getSAMLUrl(provider: SAMLProvider, account: string, relayState?: string): Promise<SAMLUrlResponse>;
+  /**
+   * Handle SAML callback (ACS) and authenticate user.
+   */
+  handleSAMLCallback(params: SAMLCallbackParams): Promise<SAMLResponse>;
+  /**
+   * Get SAML metadata for the specified provider and account.
+   */
+  getSAMLMetadata(provider: SAMLProvider, account: string): Promise<string>;
+  /**
+   * Cleanup expired state tokens.
+   */
+  private cleanupExpiredStates;
+}
+//#endregion
+//#region src/core/account-service.d.ts
+/**
+ * Service for managing accounts and their users.
+ * Requires superadmin authentication.
+ */
+declare class AccountService {
+  private http;
+  constructor(http: HttpClient);
+  /**
+   * List all accounts with pagination, filtering, and sorting.
+   */
+  list(params?: AccountListParams): Promise<AccountListResponse>;
+  /**
+   * Get details for a specific account.
+   */
+  get(accountId: string): Promise<Account$1>;
+  /**
+   * Create a new account.
+   */
+  create(data: AccountCreate): Promise<Account$1>;
+  /**
+   * Update an existing account.
+   */
+  update(accountId: string, data: AccountUpdate): Promise<Account$1>;
+  /**
+   * Delete an account and all its associated data.
+   */
+  delete(accountId: string): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Get all users belonging to a specific account.
+   */
+  getUsers(accountId: string, params?: AccountUserListParams): Promise<UserListResponse>;
+}
+//#endregion
+//#region src/core/user-service.d.ts
+/**
+ * Service for managing users.
+ * Requires superadmin authentication for most operations.
+ */
+declare class UserService {
+  private http;
+  constructor(http: HttpClient);
+  /**
+   * List all users with pagination, filtering, and sorting.
+   */
+  list(params?: UserListParams): Promise<UserListResponse>;
+  /**
+   * Get details for a specific user.
+   */
+  get(userId: string): Promise<User$1>;
+  /**
+   * Create a new user in a specific account.
+   */
+  create(data: UserCreate): Promise<User$1>;
+  /**
+   * Update an existing user.
+   */
+  update(userId: string, data: UserUpdate): Promise<User$1>;
+  /**
+   * Soft delete (deactivate) a user.
+   */
+  delete(userId: string): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Manually set a new password for a user.
+   */
+  setPassword(userId: string, password: string): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Manually verify a user's email address.
+   */
+  verifyEmail(userId: string): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Resend the verification email to a user.
+   */
+  resendVerification(userId: string): Promise<{
+    success: boolean;
+  }>;
+}
+//#endregion
+//#region src/types/collection.d.ts
+type FieldType = 'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'email' | 'url' | 'phone' | 'select' | 'multi_select' | 'relation' | 'json';
+interface FieldDefinition {
+  name: string;
+  type: FieldType;
+  required?: boolean;
+  default?: any;
+  unique?: boolean;
+  options?: string[];
+  collection?: string;
+}
+interface Collection {
+  id: string;
+  name: string;
+  fields: FieldDefinition[];
+  record_count: number;
+  field_count: number;
+  created_at: string;
+  updated_at: string;
+}
+interface CollectionCreate {
+  name: string;
+  fields: FieldDefinition[];
+}
+interface CollectionUpdate {
+  name?: string;
+  fields?: FieldDefinition[];
+}
+//#endregion
+//#region src/core/collection-service.d.ts
+/**
+ * Service for managing collections and their schemas.
+ * Requires superadmin authentication.
+ */
+declare class CollectionService {
+  private http;
+  constructor(http: HttpClient);
+  /**
+   * List all collections.
+   */
+  list(): Promise<Collection[]>;
+  /**
+   * List collection names only.
+   */
+  listNames(): Promise<string[]>;
+  /**
+   * Get schema details for a specific collection.
+   */
+  get(collectionId: string): Promise<Collection>;
+  /**
+   * Create a new collection and its physical table.
+   */
+  create(data: CollectionCreate): Promise<Collection>;
+  /**
+   * Update an existing collection schema.
+   * Note: Field types cannot be changed for data safety.
+   */
+  update(collectionId: string, data: CollectionUpdate): Promise<Collection>;
+  /**
+   * Delete a collection and drop its physical table.
+   */
+  delete(collectionId: string): Promise<{
+    success: boolean;
+  }>;
+}
+//#endregion
+//#region src/types/record.d.ts
+/**
+ * Base record fields managed by the system.
+ */
+interface BaseRecord {
+  id: string;
+  account_id: string;
+  created_at: string;
+  updated_at: string;
+  created_by?: string;
+  updated_by?: string;
+  [key: string]: any;
+}
+/**
+ * Parameters for listing records.
+ */
+interface RecordListParams {
+  /**
+   * Number of records to skip.
+   */
+  skip?: number;
+  /**
+   * Maximum number of records to return.
+   */
+  limit?: number;
+  /**
+   * Sort expression (e.g., 'created_at' or '-created_at' for descending).
+   */
+  sort?: string;
+  /**
+   * Fields to include in the response.
+   */
+  fields?: string[] | string;
+  /**
+   * Filter parameters.
+   */
+  filter?: any;
+  /**
+   * Related collections to expand.
+   */
+  expand?: string[] | string;
+}
+/**
+ * Paginated response for records.
+ */
+interface RecordListResponse<T> {
+  items: (T & BaseRecord)[];
+  total: number;
+  skip: number;
+  limit: number;
+}
+//#endregion
+//#region src/types/query.d.ts
+/**
+ * Supported filter operators.
+ */
+type FilterOperator = '=' | '!=' | '>' | '>=' | '<' | '<=' | '~' | '!~' | '?=' | '?!=';
+/**
+ * Filter expression object.
+ */
+interface FilterExpression {
+  field: string;
+  operator: FilterOperator;
+  value?: any;
+}
+/**
+ * Sort direction.
+ */
+type SortDirection = 'asc' | 'desc';
+/**
+ * Sort expression object.
+ */
+interface SortExpression {
+  field: string;
+  direction: SortDirection;
+}
+/**
+ * Query parameters interface matching the backend expectations.
+ * This is similar to RecordListParams but used internally by the builder.
+ */
+interface QueryParams {
+  page?: number;
+  perPage?: number;
+  sort?: string;
+  filter?: string;
+  expand?: string;
+  fields?: string;
+  skip?: number;
+  limit?: number;
+}
+//#endregion
+//#region src/core/query-builder.d.ts
+/**
+ * Fluent interface for building complex queries.
+ */
+declare class QueryBuilder<T = any> {
+  private service;
+  private collection;
+  private _fields;
+  private _expand;
+  private _filterParts;
+  private _sortParts;
+  private _page;
+  private _perPage;
+  private _skip;
+  private _limit;
+  private _useLegacyPagination;
+  constructor(service: RecordService, collection: string);
+  /**
+   * Specify fields to return.
+   * @param fields Array of field names or comma-separated string
+   */
+  select(fields: string | string[]): this;
+  /**
+   * Expand related records.
+   * @param relations Array of relation names or comma-separated string
+   */
+  expand(relations: string | string[]): this;
+  /**
+   * Add a filter condition.
+   * @param field Field name
+   * @param operator Filter operator
+   * @param value Value to compare against
+   */
+  filter(field: string, operator: FilterOperator, value?: any): this;
+  /**
+   * Add a raw filter string.
+   * @param filterString Raw filter string (e.g., "age > 21")
+   */
+  filter(filterString: string): this;
+  /**
+   * Add sorting.
+   * @param field Field name
+   * @param direction 'asc' or 'desc' (default: 'asc')
+   */
+  sort(field: string, direction?: SortDirection): this;
+  /**
+   * Set limit (and optionally skip).
+   * Note: Using limit/skip switches to manual offset pagination.
+   * @param limit Max records
+   * @param skip Records to skip
+   */
+  limit(limit: number): this;
+  /**
+   * Set skip.
+   * Note: Using limit/skip switches to manual offset pagination.
+   * @param skip Records to skip
+   */
+  skip(skip: number): this;
+  /**
+   * Set page number and page size.
+   * @param page Page number (1-based)
+   * @param perPage Records per page
+   */
+  page(page: number, perPage?: number): this;
+  /**
+   * Execute query and get list of records.
+   */
+  get(): Promise<RecordListResponse<T>>;
+  /**
+   * Execute query and get the first matching record.
+   */
+  first(): Promise<(T & BaseRecord) | null>;
+  private formatValue;
+}
+//#endregion
+//#region src/core/record-service.d.ts
+/**
+ * Service for performing CRUD operations on dynamic collections.
+ */
+declare class RecordService {
+  private http;
+  constructor(http: HttpClient);
+  /**
+   * List records from a collection with pagination, filtering, and sorting.
+   * @template T The record type
+   * @param collection Collection name
+   * @param params Query parameters
+   */
+  list<T = any>(collection: string, params?: RecordListParams): Promise<RecordListResponse<T>>;
+  /**
+   * Create a query builder for the collection.
+   * @template T The record type
+   * @param collection Collection name
+   */
+  query<T = any>(collection: string): QueryBuilder<T>;
+  /**
+   * Get a single record by ID.
+   * @template T The record type
+   * @param collection Collection name
+   * @param recordId Record ID
+   * @param params Optional query parameters (e.g., fields)
+   */
+  get<T = any>(collection: string, recordId: string, params?: {
+    fields?: string[] | string;
+    expand?: string[] | string;
+  }): Promise<T & BaseRecord>;
+  /**
+   * Create a new record in a collection.
+   * @template T The record type
+   * @param collection Collection name
+   * @param data Record data
+   */
+  create<T = any>(collection: string, data: Partial<T>): Promise<T & BaseRecord>;
+  /**
+   * Full update of an existing record (PUT).
+   * @template T The record type
+   * @param collection Collection name
+   * @param recordId Record ID
+   * @param data Record data
+   */
+  update<T = any>(collection: string, recordId: string, data: Partial<T>): Promise<T & BaseRecord>;
+  /**
+   * Partial update of an existing record (PATCH).
+   * @template T The record type
+   * @param collection Collection name
+   * @param recordId Record ID
+   * @param data Partial record data
+   */
+  patch<T = any>(collection: string, recordId: string, data: Partial<T>): Promise<T & BaseRecord>;
+  /**
+   * Delete a record from a collection.
+   * @param collection Collection name
+   * @param recordId Record ID
+   */
+  delete(collection: string, recordId: string): Promise<{
+    success: boolean;
+  }>;
+}
+//#endregion
+//#region src/types/group.d.ts
+interface Group {
+  id: string;
+  account_id: string;
+  name: string;
+  description?: string;
+  is_system: boolean;
+  created_at: string;
+  updated_at: string;
+}
+interface GroupCreate {
+  name: string;
+  description?: string;
+}
+interface GroupUpdate {
+  name?: string;
+  description?: string;
+}
+interface GroupListParams {
+  page?: number;
+  page_size?: number;
+  search?: string;
+  [key: string]: string | number | boolean | undefined;
+}
+interface GroupListResponse {
+  items: Group[];
+  total: number;
+  page: number;
+  page_size: number;
+}
+//#endregion
+//#region src/core/group-service.d.ts
+/**
+ * Service for managing groups.
+ */
+declare class GroupsService {
+  private http;
+  constructor(http: HttpClient);
+  /**
+   * List all groups in the current account.
+   */
+  list(params?: GroupListParams): Promise<GroupListResponse>;
+  /**
+   * Get details for a specific group.
+   */
+  get(groupId: string): Promise<Group>;
+  /**
+   * Create a new group in the current account.
+   */
+  create(data: GroupCreate): Promise<Group>;
+  /**
+   * Update a group's name or description.
+   */
+  update(groupId: string, data: GroupUpdate): Promise<Group>;
+  /**
+   * Delete a group.
+   */
+  delete(groupId: string): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Add a user to a group.
+   */
+  addMember(groupId: string, userId: string): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Remove a user from a group.
+   */
+  removeMember(groupId: string, userId: string): Promise<{
+    success: boolean;
+  }>;
+}
+//#endregion
+//#region src/types/invitation.d.ts
+interface Invitation {
+  id: string;
+  email: string;
+  account_id: string;
+  role_id?: string;
+  status: 'pending' | 'accepted' | 'expired' | 'cancelled';
+  token?: string;
+  expires_at: string;
+  created_at: string;
+  updated_at: string;
+}
+interface InvitationCreate {
+  email: string;
+  role_id?: string;
+}
+interface InvitationListParams {
+  status?: 'pending' | 'accepted' | 'expired' | 'cancelled';
+  page?: number;
+  page_size?: number;
+  [key: string]: string | number | boolean | undefined;
+}
+//#endregion
+//#region src/core/invitation-service.d.ts
+/**
+ * Service for managing user invitations.
+ * Allows admins to invite users and tracks invitation status.
+ */
+declare class InvitationService {
+  private http;
+  constructor(http: HttpClient);
+  /**
+   * List all invitations in the current account.
+   */
+  list(params?: InvitationListParams): Promise<Invitation[]>;
+  /**
+   * Create a new invitation for a user.
+   */
+  create(data: InvitationCreate): Promise<Invitation>;
+  /**
+   * Resend an invitation email.
+   */
+  resend(invitationId: string): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Get public details of an invitation using a token.
+   * No authentication required.
+   */
+  getPublic(token: string): Promise<Invitation>;
+  /**
+   * Accept an invitation using a token and password.
+   * Creates the user account and returns authentication tokens.
+   */
+  accept(token: string, password: string): Promise<AuthResponse>;
+  /**
+   * Cancel a pending invitation.
+   */
+  cancel(invitationId: string): Promise<{
+    success: boolean;
+  }>;
+}
+//#endregion
+//#region src/types/api-key.d.ts
+interface ApiKey {
+  id: string;
+  name: string;
+  /**
+   * The full API key. Only returned once during creation.
+   */
+  key?: string;
+  /**
+   * The masked version of the key (e.g., "sk_...42").
+   */
+  masked_key: string;
+  /**
+   * The last 4 characters of the key.
+   */
+  last_4: string;
+  expires_at: string | null;
+  created_at: string;
+  updated_at: string;
+  revoked_at: string | null;
+}
+interface ApiKeyCreate {
+  name: string;
+  expires_at?: string;
+}
+//#endregion
+//#region src/core/api-key-service.d.ts
+/**
+ * Service for managing API keys.
+ * API keys are used for service-to-service communication.
+ */
+declare class ApiKeyService {
+  private http;
+  constructor(http: HttpClient);
+  /**
+   * List all API keys for the current user.
+   * Keys are masked except for the last 4 characters.
+   */
+  list(): Promise<ApiKey[]>;
+  /**
+   * Get details for a specific API key.
+   * The key itself is masked.
+   */
+  get(keyId: string): Promise<ApiKey>;
+  /**
+   * Create a new API key.
+   * The response includes the full key, which is shown only once.
+   */
+  create(data: ApiKeyCreate): Promise<ApiKey>;
+  /**
+   * Revoke an existing API key.
+   * Once revoked, the key can no longer be used.
+   */
+  revoke(keyId: string): Promise<{
+    success: boolean;
+  }>;
+}
+//#endregion
+//#region src/types/audit-log.d.ts
+interface AuditLog {
+  id: string;
+  account_id: string;
+  table_name: string;
+  record_id: string;
+  user_id: string;
+  operation: 'create' | 'update' | 'delete' | 'login' | 'logout' | string;
+  before: Record<string, any> | null;
+  after: Record<string, any> | null;
+  created_at: string;
+}
+interface AuditLogFilters {
+  account_id?: string;
+  table_name?: string;
+  record_id?: string;
+  user_id?: string;
+  operation?: string;
+  from_date?: string;
+  to_date?: string;
+  page?: number;
+  skip?: number;
+  limit?: number;
+  sort?: string;
+}
+type AuditLogExportFormat = 'csv' | 'json';
+interface AuditLogListResponse {
+  items: AuditLog[];
+  total: number;
+  page: number;
+  limit: number;
+  audit_logging_enabled: boolean;
+}
+//#endregion
+//#region src/core/audit-log-service.d.ts
+declare class AuditLogService {
+  private httpClient;
+  constructor(httpClient: HttpClient);
+  /**
+   * Lists audit logs with optional filtering, pagination, and sorting.
+   */
+  list(params?: AuditLogFilters): Promise<AuditLogListResponse>;
+  /**
+   * Retrieves a single audit log entry by ID.
+   */
+  get(logId: string): Promise<AuditLog>;
+  /**
+   * Exports audit logs in the specified format.
+   */
+  export(params?: AuditLogFilters, format?: AuditLogExportFormat): Promise<string>;
+}
+//#endregion
+//#region src/types/role.d.ts
+interface Role {
+  id: string;
+  name: string;
+  description: string;
+  created_at: string;
+  updated_at: string;
+}
+interface RoleCreate {
+  name: string;
+  description?: string;
+}
+interface RoleUpdate {
+  name?: string;
+  description?: string;
+}
+interface RoleListResponse {
+  items: Role[];
+  total: number;
+}
+interface CollectionRule {
+  list_rule: string | null;
+  view_rule: string | null;
+  create_rule: string | null;
+  update_rule: string | null;
+  delete_rule: string | null;
+  list_fields: string;
+  view_fields: string;
+  create_fields: string;
+  update_fields: string;
+}
+interface CollectionRuleUpdate {
+  list_rule?: string | null;
+  view_rule?: string | null;
+  create_rule?: string | null;
+  update_rule?: string | null;
+  delete_rule?: string | null;
+  list_fields?: string;
+  view_fields?: string;
+  create_fields?: string;
+  update_fields?: string;
+}
+interface RuleValidationResult {
+  valid: boolean;
+  errors?: string[];
+}
+interface RuleTestResult {
+  result: boolean;
+}
+interface RuleValidationParams {
+  rule: string;
+  operation: 'list' | 'view' | 'create' | 'update' | 'delete';
+  collectionFields: string[];
+}
+/**
+ * Permission type alias for CollectionRule (Permission System V2).
+ */
+type Permission = CollectionRule;
+//#endregion
+//#region src/core/role-service.d.ts
+/**
+ * Service for managing roles.
+ * Requires superadmin authentication.
+ */
+declare class RoleService {
+  private http;
+  constructor(http: HttpClient);
+  /**
+   * List all roles with pagination.
+   */
+  list(): Promise<RoleListResponse>;
+  /**
+   * Get details for a specific role.
+   */
+  get(roleId: string): Promise<Role>;
+  /**
+   * Create a new role.
+   */
+  create(data: RoleCreate): Promise<Role>;
+  /**
+   * Update an existing role.
+   */
+  update(roleId: string, data: RoleUpdate): Promise<Role>;
+  /**
+   * Delete a role.
+   * Fails if the role is currently in use.
+   */
+  delete(roleId: string): Promise<{
+    success: boolean;
+  }>;
+}
+//#endregion
+//#region src/core/collection-rule-service.d.ts
+/**
+ * Service for managing collection-level access rules and field permissions.
+ * Requires superadmin authentication.
+ */
+declare class CollectionRuleService {
+  private http;
+  constructor(http: HttpClient);
+  /**
+   * Get access rules and field permissions for a specific collection.
+   */
+  get(collectionName: string): Promise<CollectionRule>;
+  /**
+   * Update access rules and field permissions for a specific collection.
+   */
+  update(collectionName: string, data: CollectionRuleUpdate): Promise<CollectionRule>;
+  /**
+   * Validate a rule expression against a collection schema.
+   */
+  validateRule(rule: string, operation: 'list' | 'view' | 'create' | 'update' | 'delete', collectionFields: string[]): Promise<RuleValidationResult>;
+  /**
+   * Test a rule evaluation with a sample context.
+   */
+  testRule(rule: string, context: any): Promise<RuleTestResult>;
+}
+//#endregion
+//#region src/types/macro.d.ts
+interface Macro {
+  id: string;
+  name: string;
+  description: string;
+  sql_query: string;
+  parameters: string[];
+  is_builtin: boolean;
+  created_at: string;
+  updated_at: string;
+}
+interface MacroCreate {
+  name: string;
+  description: string;
+  sql_query: string;
+  parameters: string[];
+}
+interface MacroUpdate {
+  name?: string;
+  description?: string;
+  sql_query?: string;
+  parameters?: string[];
+}
+interface MacroTestResult {
+  success: boolean;
+  result: any;
+}
+interface MacroListResponse {
+  items: Macro[];
+  total: number;
+}
+//#endregion
+//#region src/core/macro-service.d.ts
+/**
+ * Service for managing SQL macros.
+ * Macros can be used in permission rules.
+ * Requires superadmin authentication for most operations.
+ */
+declare class MacroService {
+  private http;
+  constructor(http: HttpClient);
+  /**
+   * List all macros, including built-in ones.
+   */
+  list(): Promise<MacroListResponse>;
+  /**
+   * Get details for a specific macro.
+   */
+  get(macroId: string): Promise<Macro>;
+  /**
+   * Create a new custom macro.
+   */
+  create(data: MacroCreate): Promise<Macro>;
+  /**
+   * Update an existing custom macro.
+   * Built-in macros cannot be updated.
+   */
+  update(macroId: string, data: MacroUpdate): Promise<Macro>;
+  /**
+   * Delete a macro.
+   * Fails if the macro is built-in or currently in use.
+   */
+  delete(macroId: string): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Test a macro with parameters.
+   */
+  test(macroId: string, params: Record<string, any>): Promise<MacroTestResult>;
+}
+//#endregion
+//#region src/types/dashboard.d.ts
+/**
+ * Dashboard statistics and metrics for superadmins.
+ */
+interface DashboardStats {
+  /** Total number of accounts in the system */
+  total_accounts: number;
+  /** Total number of users across all accounts */
+  total_users: number;
+  /** Total number of collections defined */
+  total_collections: number;
+  /** Total number of records across all collections */
+  total_records: number;
+  /** Number of new accounts created in the last 7 days */
+  new_accounts_7d: number;
+  /** Number of new users registered in the last 7 days */
+  new_users_7d: number;
+  /** List of the most recent user registrations */
+  recent_registrations: User$1[];
+  /** Overview of current system health and status */
+  system_health: SystemHealth;
+  /** Number of currently active user sessions */
+  active_sessions: number;
+  /** List of the most recent audit log entries */
+  recent_audit_logs: AuditLog[];
+}
+/**
+ * System health information.
+ */
+interface SystemHealth {
+  /** overall status of the system */
+  status: 'healthy' | 'degraded' | 'unhealthy' | string;
+  /** System uptime (e.g., "7 days, 4 hours") */
+  uptime?: string;
+  /** Current version of the SnackBase server */
+  version?: string;
+  /** Additional health metrics */
+  [key: string]: any;
+}
+//#endregion
+//#region src/core/dashboard-service.d.ts
+/**
+ * Service for interacting with the Dashboard API.
+ * Provides statistics and metrics for system monitoring.
+ */
+declare class DashboardService {
+  private httpClient;
+  constructor(httpClient: HttpClient);
+  /**
+   * Retrieves dashboard statistics including counts for accounts, users,
+   * collections, and records, as well as recent activity and health metrics.
+   *
+   * @returns {Promise<DashboardStats>} A promise that resolves to dashboard statistics.
+   * @throws {AuthenticationError} If not authenticated.
+   * @throws {AuthorizationError} If the user is not a superadmin.
+   */
+  getStats(): Promise<DashboardStats>;
+}
+//#endregion
+//#region src/types/admin.d.ts
+/**
+ * Configuration record representing a system or account level setting.
+ */
+interface Configuration {
+  id: string;
+  name: string;
+  category: string;
+  provider_name: string;
+  is_system: boolean;
+  account_id?: string;
+  enabled: boolean;
+  created_at: string;
+  updated_at: string;
+}
+/**
+ * Statistics for configurations by category.
+ */
+interface ConfigurationStats {
+  system_count: number;
+  account_count: number;
+  by_category: Record<string, {
+    system: number;
+    account: number;
+  }>;
+}
+/**
+ * Available provider definition.
+ */
+interface ProviderDefinition {
+  name: string;
+  display_name: string;
+  category: string;
+  description?: string;
+  is_built_in: boolean;
+  icon?: string;
+}
+/**
+ * Connection test result.
+ */
+interface ConnectionTestResult {
+  success: boolean;
+  message: string;
+  details?: Record<string, any>;
+}
+/**
+ * Request data for creating a configuration.
+ */
+interface ConfigurationCreate {
+  name: string;
+  category: string;
+  provider_name: string;
+  values: Record<string, any>;
+  is_system?: boolean;
+  account_id?: string;
+  enabled?: boolean;
+}
+/**
+ * Recent configuration summary.
+ */
+interface RecentConfiguration extends Configuration {
+  last_modified_by?: {
+    id: string;
+    email: string;
+  };
+}
+//#endregion
+//#region src/core/admin-service.d.ts
+/**
+ * Service for superadmin operations and system configuration management.
+ */
+declare class AdminService {
+  private http;
+  constructor(http: HttpClient);
+  /**
+   * Returns configuration statistics by category.
+   */
+  getConfigurationStats(): Promise<ConfigurationStats>;
+  /**
+   * Returns recently modified configurations.
+   * @param limit Number of configurations to return
+   */
+  getRecentConfigurations(limit?: number): Promise<RecentConfiguration[]>;
+  /**
+   * Returns all system-level configurations.
+   * @param category Optional category filter
+   */
+  listSystemConfigurations(category?: string): Promise<Configuration[]>;
+  /**
+   * Returns configurations for specific account.
+   * @param accountId Account ID
+   * @param category Optional category filter
+   */
+  listAccountConfigurations(accountId: string, category?: string): Promise<Configuration[]>;
+  /**
+   * Returns decrypted configuration values with secrets masked.
+   * @param configId Configuration ID
+   */
+  getConfigurationValues(configId: string): Promise<Record<string, any>>;
+  /**
+   * Updates configuration values.
+   * @param configId Configuration ID
+   * @param values New configuration values
+   */
+  updateConfigurationValues(configId: string, values: Record<string, any>): Promise<Record<string, any>>;
+  /**
+   * Enables or disables configuration.
+   * @param configId Configuration ID
+   * @param enabled Enabled status
+   */
+  updateConfigurationStatus(configId: string, enabled: boolean): Promise<Configuration>;
+  /**
+   * Creates new configuration record.
+   * @param data Configuration data
+   */
+  createConfiguration(data: ConfigurationCreate): Promise<Configuration>;
+  /**
+   * Deletes configuration.
+   * @param configId Configuration ID
+   */
+  deleteConfiguration(configId: string): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Lists all available provider definitions.
+   * @param category Optional category filter
+   */
+  listProviders(category?: string): Promise<ProviderDefinition[]>;
+  /**
+   * Returns JSON schema for provider configuration.
+   * @param category Provider category
+   * @param providerName Provider name
+   */
+  getProviderSchema(category: string, providerName: string): Promise<Record<string, any>>;
+  /**
+   * Tests provider connection.
+   * @param category Provider category
+   * @param providerName Provider name
+   * @param config Configuration values to test
+   */
+  testConnection(category: string, providerName: string, config: Record<string, any>): Promise<ConnectionTestResult>;
+}
+//#endregion
+//#region src/types/email-template.d.ts
+/**
+ * Email template type.
+ */
+type EmailTemplateType = 'verification' | 'reset_password' | 'invitation' | string;
+/**
+ * Email template interface.
+ */
+interface EmailTemplate {
+  id: string;
+  template_type: EmailTemplateType;
+  locale: string;
+  subject: string;
+  html_body: string;
+  text_body: string;
+  enabled: boolean;
+  account_id?: string;
+  created_at: string;
+  updated_at: string;
+}
+/**
+ * Data for updating an email template.
+ */
+interface EmailTemplateUpdate {
+  subject?: string;
+  html_body?: string;
+  text_body?: string;
+  enabled?: boolean;
+}
+/**
+ * Filters for listing email templates.
+ */
+interface EmailTemplateFilters {
+  [key: string]: string | number | boolean | undefined;
+  template_type?: EmailTemplateType;
+  locale?: string;
+  account_id?: string;
+  enabled?: boolean;
+}
+/**
+ * Request for rendering an email template.
+ */
+interface EmailTemplateRenderRequest {
+  template_type: EmailTemplateType;
+  locale: string;
+  variables: Record<string, any>;
+  subject_override?: string;
+  html_body_override?: string;
+  text_body_override?: string;
+}
+/**
+ * Response from rendering an email template.
+ */
+interface EmailTemplateRenderResponse {
+  subject: string;
+  html_body: string;
+  text_body: string;
+}
+/**
+ * Email log interface.
+ */
+interface EmailLog {
+  id: string;
+  account_id: string;
+  template_type: EmailTemplateType;
+  recipient: string;
+  subject: string;
+  status: 'sent' | 'failed' | 'pending';
+  provider: string;
+  error?: string;
+  sent_at: string;
+  metadata?: Record<string, any>;
+}
+/**
+ * Filters for listing email logs.
+ */
+interface EmailLogFilters {
+  [key: string]: string | number | boolean | undefined;
+  status?: string;
+  template_type?: EmailTemplateType;
+  start_date?: string;
+  end_date?: string;
+  page?: number;
+  limit?: number;
+}
+/**
+ * Paginated response for email logs.
+ */
+interface EmailLogListResponse {
+  data: EmailLog[];
+  total: number;
+  page: number;
+  limit: number;
+  last_page: number;
+}
+//#endregion
+//#region src/core/email-template-service.d.ts
+/**
+ * Service for managing email templates and logs.
+ */
+declare class EmailTemplateService {
+  private http;
+  constructor(http: HttpClient);
+  /**
+   * Returns a list of email templates.
+   * @param filters Optional filters for listing templates
+   */
+  list(filters?: EmailTemplateFilters): Promise<EmailTemplate[]>;
+  /**
+   * Returns email template details.
+   * @param templateId Template ID
+   */
+  get(templateId: string): Promise<EmailTemplate>;
+  /**
+   * Updates an email template.
+   * @param templateId Template ID
+   * @param data Update data
+   */
+  update(templateId: string, data: EmailTemplateUpdate): Promise<EmailTemplate>;
+  /**
+   * Renders an email template with provided variables.
+   * @param request Render request data
+   */
+  render(request: EmailTemplateRenderRequest): Promise<EmailTemplateRenderResponse>;
+  /**
+   * Sends a test email using the specified template.
+   * @param templateId Template ID
+   * @param recipientEmail Recipient email address
+   * @param variables Template variables
+   * @param provider Optional provider override
+   */
+  sendTest(templateId: string, recipientEmail: string, variables?: Record<string, any>, provider?: string): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Returns a paginated list of email logs.
+   * @param filters Optional filters for listing logs
+   */
+  listLogs(filters?: EmailLogFilters): Promise<EmailLogListResponse>;
+  /**
+   * Returns single email log details.
+   * @param logId Log ID
+   */
+  getLog(logId: string): Promise<EmailLog>;
+}
+//#endregion
+//#region src/types/file.d.ts
+/**
+ * Metadata for a file.
+ */
+interface FileMetadata {
+  /**
+   * Safe filename.
+   */
+  filename: string;
+  /**
+   * MIME type of the file.
+   */
+  contentType: string;
+  /**
+   * File size in bytes.
+   */
+  size: number;
+  /**
+   * Server path to the file.
+   */
+  path: string;
+  /**
+   * Upload timestamp.
+   */
+  created_at: string;
+}
+/**
+ * Options for file upload.
+ */
+interface FileUploadOptions {
+  /**
+   * Custom filename for the upload.
+   */
+  filename?: string;
+  /**
+   * Custom content type for the upload.
+   */
+  contentType?: string;
+}
+//#endregion
+//#region src/core/file-service.d.ts
+/**
+ * Service for working with files (upload, download, delete).
+ */
+declare class FileService {
+  private http;
+  private getBaseUrl;
+  private getToken;
+  constructor(http: HttpClient, getBaseUrl: () => string, getToken: () => string | null);
+  /**
+   * Upload a file to the server.
+   * @param file The file or blob to upload
+   * @param options Optional upload options (filename, contentType)
+   */
+  upload(file: File | Blob, options?: FileUploadOptions): Promise<FileMetadata>;
+  /**
+   * Get the download URL for a file.
+   * @param path The server path to the file
+   */
+  getDownloadUrl(path: string): string;
+  /**
+   * Delete a file from the server.
+   * @param path The server path to the file
+   */
+  delete(path: string): Promise<{
+    success: boolean;
+  }>;
+}
+//#endregion
+//#region src/types/realtime.d.ts
+type RealTimeState = 'disconnected' | 'connecting' | 'connected' | 'error';
+type RealTimeEvent = 'connecting' | 'connected' | 'disconnected' | 'error' | 'message';
+type WebSocketAction = 'subscribe' | 'unsubscribe' | 'ping';
+interface WebSocketMessage {
+  action: WebSocketAction;
+  collection?: string;
+  operations?: string[];
+}
+interface ServerMessage {
+  type: string | 'heartbeat' | 'pong' | 'subscribed' | 'unsubscribed';
+  timestamp: string;
+  data?: any;
+  collection?: string;
+}
+/**
+ * Real-time event object structure
+ * @template T - Type of the event data
+ */
+interface RealtimeEvent<T = any> {
+  /** Event type in format: {collection}.{operation} (e.g., "posts.create") */
+  type: string;
+  /** ISO 8601 timestamp */
+  timestamp: string;
+  /** Event data - full record for create/update, ID only for delete */
+  data: T;
+}
+interface RealTimeConfig {
+  maxReconnectionAttempts?: number;
+  heartbeatInterval?: number;
+  reconnectionDelay?: (attempt: number) => number;
+}
+type RealTimeEventHandler = (data?: any) => void;
+/**
+ * Real-time event handlers
+ *
+ * Event type formats:
+ * - Connection events: 'connecting', 'connected', 'disconnected', 'error'
+ * - Message event: 'message' - receives full ServerMessage
+ * - Specific events: '{collection}.{operation}' (e.g., 'posts.create')
+ * - Collection wildcard: '{collection}.*' (e.g., 'posts.*') - all events for a collection
+ * - Global wildcard: '*' - all events
+ */
+interface RealTimeEvents {
+  connecting: () => void;
+  connected: () => void;
+  disconnected: () => void;
+  error: (error: Error) => void;
+  auth_error: (error: Error) => void;
+  message: (data: ServerMessage) => void;
+  [key: string]: RealTimeEventHandler;
+}
+//#endregion
+//#region src/core/realtime-service.d.ts
+interface RealTimeOptions {
+  baseUrl: string;
+  getToken: () => string | null;
+  authManager?: AuthManager;
+  maxRetries?: number;
+  reconnectionDelay?: number;
+  logger?: Logger;
+}
+declare class RealTimeService {
+  private options;
+  private state;
+  private socket;
+  private sse;
+  private listeners;
+  private retryCount;
+  private reconnectTimer;
+  private heartbeatTimer;
+  private subscriptions;
+  private subscriptionRequests;
+  private pendingSubscriptions;
+  private authUnsubscribe?;
+  private isReconnectingForAuth;
+  constructor(options: RealTimeOptions);
+  connect(): Promise<void>;
+  disconnect(): void;
+  getState(): RealTimeState;
+  on<K extends keyof RealTimeEvents>(event: K, handler: RealTimeEvents[K]): () => void;
+  off<K extends keyof RealTimeEvents>(event: K, handler: RealTimeEvents[K]): void;
+  subscribe(collection: string, operations?: string[]): Promise<void>;
+  unsubscribe(collection: string): Promise<void>;
+  getSubscriptions(): string[];
+  private doConnect;
+  private connectWebSocket;
+  private connectSSE;
+  private handleMessage;
+  private handleReconnect;
+  private handleError;
+  private setState;
+  private emit;
+  private send;
+  private startHeartbeat;
+  private resubscribe;
+  private clearTimers;
+  private closeConnections;
+  /**
+   * Handle token refresh by reconnecting with new token
+   */
+  private handleTokenRefresh;
+}
+//#endregion
+//#region src/types/migration.d.ts
+/**
+ * Migration-related type definitions.
+ */
+/**
+ * Represents a single migration revision.
+ */
+interface MigrationRevision {
+  /** The revision identifier (e.g., "001_abc123") */
+  revision: string;
+  /** Human-readable description of the migration */
+  description: string;
+  /** Whether this revision has been applied to the database */
+  isApplied: boolean;
+  /** Whether this is a dynamic collection migration */
+  isDynamic: boolean;
+}
+/**
+ * Response from listing all migrations.
+ */
+interface MigrationListResponse {
+  /** All available migration revisions */
+  revisions: MigrationRevision[];
+  /** Total number of revisions */
+  total: number;
+  /** The currently applied revision (if any) */
+  currentRevision: string | null;
+}
+/**
+ * Response from getting the current migration.
+ */
+interface CurrentRevisionResponse {
+  /** The current revision identifier */
+  revision: string;
+  /** Human-readable description of the migration */
+  description: string;
+  /** Timestamp when this revision was applied */
+  appliedAt: string;
+  /** Whether this is a dynamic collection migration */
+  isDynamic: boolean;
+}
+/**
+ * A single item in the migration history.
+ */
+interface MigrationHistoryItem {
+  /** The revision identifier */
+  revision: string;
+  /** Human-readable description of the migration */
+  description: string;
+  /** Whether this is a dynamic collection migration */
+  isDynamic: boolean;
+  /** Timestamp when this revision was applied */
+  createdAt: string;
+}
+/**
+ * Response from getting migration history.
+ */
+interface MigrationHistoryResponse {
+  /** Applied migrations in chronological order */
+  history: MigrationHistoryItem[];
+  /** Total number of applied migrations */
+  total: number;
+}
+//#endregion
+//#region src/core/migration-service.d.ts
+/**
+ * Service for viewing migration status and history.
+ * Requires superadmin authentication.
+ */
+declare class MigrationService {
+  private http;
+  constructor(http: HttpClient);
+  /**
+   * List all Alembic migration revisions.
+   * Returns all migrations with their application status.
+   */
+  list(): Promise<MigrationListResponse>;
+  /**
+   * Get the current database revision.
+   * Returns the currently applied migration.
+   */
+  getCurrent(): Promise<CurrentRevisionResponse | null>;
+  /**
+   * Get full migration history.
+   * Returns all applied migrations in chronological order.
+   */
+  getHistory(): Promise<MigrationHistoryResponse>;
+}
+//#endregion
+//#region src/core/client.d.ts
+/**
+ * Main SDK client for interacting with SnackBase API.
+ */
+declare class SnackBaseClient {
+  private config;
+  private http;
+  private logger;
+  private authManager;
+  private authService;
+  private accountService;
+  private userService;
+  private collectionService;
+  private recordService;
+  private groupsService;
+  private invitationService;
+  private apiKeyService;
+  private auditLogService;
+  private roleService;
+  private collectionRuleService;
+  private macroService;
+  private dashboardService;
+  private adminService;
+  private emailTemplateService;
+  private fileService;
+  private realtimeService;
+  private migrationService;
+  /**
+   * Initialize a new SnackBaseClient instance.
+   * @param config Configuration options
+   */
+  constructor(config: SnackBaseConfig);
+  /**
+   * Returns the current client configuration.
+   */
+  getConfig(): Required<SnackBaseConfig>;
+  /**
+   * Internal helper to access the HTTP client.
+   * @internal
+   */
+  get httpClient(): HttpClient;
+  /**
+   * Sets up the default interceptors for the HTTP client.
+   */
+  private setupInterceptors;
+  /**
+   * Returns the current authenticated user.
+   */
+  get user(): User$1 | null;
+  /**
+   * Returns the current account.
+   */
+  get account(): Account$1 | null;
+  /**
+   * Returns whether the client is currently authenticated.
+   */
+  get isAuthenticated(): boolean;
+  /**
+   * Access to authentication methods.
+   */
+  get auth(): AuthService;
+  /**
+   * Access to account management methods.
+   */
+  get accounts(): AccountService;
+  /**
+   * Access to user management methods.
+   */
+  get users(): UserService;
+  /**
+   * Access to collection management methods.
+   */
+  get collections(): CollectionService;
+  /**
+   * Access to record management methods (CRUD on dynamic collections).
+   */
+  get records(): RecordService;
+  /**
+   * Access to group management methods.
+   */
+  get groups(): GroupsService;
+  /**
+   * Access to invitation management methods.
+   */
+  get invitations(): InvitationService;
+  /**
+   * Access to API key management methods.
+   */
+  get apiKeys(): ApiKeyService;
+  /**
+   * Access to audit log management methods.
+   */
+  get auditLogs(): AuditLogService;
+  /**
+   * Access to role management methods.
+   */
+  get roles(): RoleService;
+  /**
+   * Access to collection rule management methods.
+   */
+  get collectionRules(): CollectionRuleService;
+  /**
+   * Access to macro management methods.
+   */
+  get macros(): MacroService;
+  /**
+   * Access to dashboard statistics and monitoring.
+   */
+  get dashboard(): DashboardService;
+  /**
+   * Access to system administration and configuration methods.
+   */
+  get admin(): AdminService;
+  /**
+   * Access to email template management methods.
+   */
+  get emailTemplates(): EmailTemplateService;
+  /**
+   * Access to file management methods.
+   */
+  get files(): FileService;
+  /**
+   * Access to real-time features and subscriptions.
+   */
+  get realtime(): RealTimeService;
+  /**
+   * Access to migration status and history.
+   */
+  get migrations(): MigrationService;
+  /**
+   * Subscribe to authentication events.
+   * @param event Event name
+   * @param listener Callback function
+   */
+  on<K extends keyof AuthEvents>(event: K, listener: AuthEvents[K]): () => void;
+  /**
+   * Authenticate a user with email and password.
+   */
+  login(credentials: LoginCredentials): Promise<AuthResponse>;
+  /**
+   * Log out the current user.
+   */
+  logout(): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Register a new user and account.
+   */
+  register(data: RegisterData): Promise<AuthResponse>;
+  /**
+   * Refresh the access token using the refresh token.
+   */
+  refreshToken(): Promise<AuthResponse>;
+  /**
+   * Get the current authenticated user profile.
+   */
+  getCurrentUser(): Promise<AuthResponse>;
+  /**
+   * Initiate password reset flow.
+   */
+  forgotPassword(data: PasswordResetRequest): Promise<{
+    message: string;
+  }>;
+  /**
+   * Reset password using a token.
+   */
+  resetPassword(data: PasswordResetConfirm): Promise<{
+    message: string;
+  }>;
+  /**
+   * Verify email using a token.
+   */
+  verifyEmail(token: string): Promise<{
+    message: string;
+  }>;
+  /**
+   * Resend the verification email to the current user.
+   */
+  resendVerificationEmail(): Promise<{
+    message: string;
+  }>;
+  /**
+   * Generate SAML SSO authorization URL.
+   */
+  getSAMLUrl(provider: SAMLProvider, account: string, relayState?: string): Promise<SAMLUrlResponse>;
+  /**
+   * Handle SAML callback.
+   */
+  handleSAMLCallback(params: SAMLCallbackParams): Promise<SAMLResponse>;
+  /**
+   * Get SAML metadata.
+   */
+  getSAMLMetadata(provider: SAMLProvider, account: string): Promise<string>;
+  /**
+   * Internal access to AuthManager.
+   * @internal
+   */
+  get internalAuthManager(): AuthManager;
+  /**
+   * Validates the configuration object.
+   * Throws descriptive errors for invalid options.
+   */
+  private validateConfig;
+}
+//#endregion
+//#region src/types/utils.d.ts
+/**
+ * Generic record type with system fields.
+ * Use this to define your record interfaces.
+ *
+ * @example
+ * interface Post {
+ *   title: string;
+ *   content: string;
+ *   views: number;
+ * }
+ * type PostRecord = CollectionRecord<Post>;
+ */
+type CollectionRecord<T> = T & BaseRecord;
+/**
+ * Paginated list response type alias.
+ */
+type ListResponse<T> = RecordListResponse<T>;
+/**
+ * Filter object type for a collection.
+ * Allows filtering by fields of T.
+ *
+ * This is a basic typed filter. For complex MongoDB-style queries,
+ * you might need more flexible types.
+ */
+type Filter<T> = { [P in keyof T]?: any } & {
+  [key: string]: any;
+};
+/**
+ * Helper to map FieldType strings to TypeScript types.
+ */
+type FieldTypeToTs<T extends string> = T extends 'text' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : T extends 'date' ? string : T extends 'datetime' ? string : T extends 'email' ? string : T extends 'url' ? string : T extends 'phone' ? string : T extends 'select' ? string : T extends 'multi_select' ? string[] : T extends 'relation' ? string | string[] : T extends 'json' ? any : any;
+/**
+ * Infers a record type from a schema definition (array of FieldDefinition).
+ * Note: The schema array must be defined `as const` to work correctly.
+ *
+ * @example
+ * const postSchema = [
+ *   { name: 'title', type: 'text' },
+ *   { name: 'views', type: 'number' }
+ * ] as const;
+ *
+ * type Post = InferSchema<typeof postSchema>;
+ * // Result: { title: string; views: number }
+ */
+type InferSchema<T extends readonly FieldDefinition[]> = { [K in T[number] as K['name']]: FieldTypeToTs<K['type']> | (K['required'] extends true ? never : undefined | null) };
+//#endregion
+//#region src/utils/platform.d.ts
+/**
+ * Detects the platform and returns the recommended storage backend.
+ * - Web: localStorage
+ * - React Native: asyncStorage
+ */
+declare function getAutoDetectedStorage(): StorageBackend;
+//#endregion
+export { AuditLogFilters as $, EmailTemplateRenderResponse as A, OAuthCallbackParams as At, SystemHealth as B, SAMLUrlResponse as Bt, FileUploadOptions as C, FieldDefinition as Ct, EmailTemplate as D, AuthResponse as Dt, EmailLogListResponse as E, AuthEvents as Et, ConfigurationStats as F, PasswordResetRequest as Ft, RoleCreate as G, UserUpdate as Gt, CollectionRuleUpdate as H, UserCreate as Ht, ConnectionTestResult as I, RegisterData as It, RuleTestResult as J, LogLevel$1 as Jt, RoleListResponse as K, Account$1 as Kt, ProviderDefinition as L, SAMLCallbackParams as Lt, EmailTemplateUpdate as M, OAuthResponse as Mt, Configuration as N, OAuthUrlResponse as Nt, EmailTemplateFilters as O, AuthState as Ot, ConfigurationCreate as P, PasswordResetConfirm as Pt, AuditLogExportFormat as Q, RecentConfiguration as R, SAMLProvider as Rt, FileMetadata as S, CollectionUpdate as St, EmailLogFilters as T, AuthEvent as Tt, Permission as U, UserListParams as Ut, CollectionRule as V, User$1 as Vt, Role as W, UserListResponse as Wt, RuleValidationResult as X, StorageBackend as Xt, RuleValidationParams as Y, SnackBaseConfig as Yt, AuditLog as Z, RealTimeState as _, BaseRecord as _t, InferSchema as a, InvitationListParams as at, WebSocketAction as b, Collection as bt, CurrentRevisionResponse as c, GroupListParams as ct, MigrationListResponse as d, QueryBuilder as dt, AuditLogListResponse as et, MigrationRevision as f, FilterExpression as ft, RealTimeEvents as g, SortExpression as gt, RealTimeEventHandler as h, SortDirection as ht, Filter as i, InvitationCreate as it, EmailTemplateType as j, OAuthProvider as jt, EmailTemplateRenderRequest as k, LoginCredentials as kt, MigrationHistoryItem as l, GroupListResponse as lt, RealTimeEvent as m, QueryParams as mt, CollectionRecord as n, ApiKeyCreate as nt, ListResponse as o, Group as ot, RealTimeConfig as p, FilterOperator as pt, RoleUpdate as q, DEFAULT_CONFIG as qt, FieldTypeToTs as r, Invitation as rt, SnackBaseClient as s, GroupCreate as st, getAutoDetectedStorage as t, ApiKey as tt, MigrationHistoryResponse as u, GroupUpdate as ut, RealtimeEvent as v, RecordListParams as vt, EmailLog as w, FieldType as wt, WebSocketMessage as x, CollectionCreate as xt, ServerMessage as y, RecordListResponse as yt, DashboardStats as z, SAMLResponse as zt };