@baasix/types 1.0.1

package/dist/index.d.mts

@@ -0,0 +1,2065 @@
+import { Request as Request$1, Response as Response$1, NextFunction as NextFunction$1, Express as Express$1, Router as Router$1 } from 'express';
+
+/**
+ * Authentication & Authorization Types
+ * Shared across core, sdk, cli, and app packages
+ */
+/**
+ * Base user interface
+ */
+interface User {
+    id: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    avatar?: string;
+    role?: Role;
+    role_Id?: string;
+    tenant_Id?: string;
+    status?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+/**
+ * User with password (internal use only)
+ */
+interface UserWithPassword extends User {
+    password?: string;
+}
+/**
+ * User with expanded roles and permissions
+ */
+interface UserWithRolesAndPermissions {
+    id: string | number;
+    email?: string;
+    roles: string[];
+    permissions: string[];
+    tenantId?: string | number;
+    [key: string]: unknown;
+}
+/**
+ * Role interface
+ */
+interface Role {
+    id: string;
+    name: string;
+    description?: string;
+    isTenantSpecific?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Permission action types
+ */
+type PermissionAction = "create" | "read" | "update" | "delete";
+/**
+ * Permission interface
+ */
+interface Permission {
+    id: string;
+    role_Id: string;
+    collection: string;
+    action: PermissionAction;
+    fields?: string[] | null;
+    conditions?: Record<string, unknown>;
+    defaultValues?: Record<string, unknown>;
+    relConditions?: Record<string, unknown>;
+}
+/**
+ * Permission data structure (internal to PermissionService)
+ */
+interface PermissionData {
+    fields: string[] | null;
+    conditions: Record<string, unknown>;
+    relConditions: Record<string, unknown>;
+    defaultValues: Record<string, unknown>;
+}
+/**
+ * Data for creating a new permission
+ */
+interface CreatePermissionData {
+    role_Id: string;
+    collection: string;
+    action: PermissionAction;
+    fields?: string[];
+    conditions?: Record<string, unknown>;
+    defaultValues?: Record<string, unknown>;
+    relConditions?: Record<string, unknown>;
+}
+/**
+ * Tenant interface
+ */
+interface Tenant {
+    id: string;
+    name: string;
+    [key: string]: unknown;
+}
+/**
+ * Session interface
+ */
+interface Session {
+    id: string;
+    token: string;
+    user_Id: string;
+    expiresAt: Date | string;
+    ipAddress?: string;
+    userAgent?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/**
+ * Auth tokens
+ */
+interface AuthTokens {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    expiresIn?: number;
+}
+/**
+ * JWT payload interface
+ */
+interface JWTPayload {
+    id: string;
+    email: string;
+    role: string;
+    sessionToken: string;
+    tenant_Id?: string | number | null;
+}
+/**
+ * Accountability object interface - used for permission checking
+ */
+interface Accountability {
+    user?: {
+        id: string | number;
+        email?: string;
+        isAdmin?: boolean;
+        [key: string]: any;
+    };
+    role?: {
+        id: string | number;
+        name?: string;
+        isTenantSpecific?: boolean;
+    } | string | number;
+    permissions?: any[];
+    tenant?: string | number;
+    ipaddress?: string;
+}
+/**
+ * Login credentials
+ */
+interface LoginCredentials {
+    email: string;
+    password: string;
+    tenantId?: string;
+}
+/**
+ * Registration data
+ */
+interface RegisterData {
+    email: string;
+    password: string;
+    firstName?: string;
+    lastName?: string;
+    [key: string]: unknown;
+}
+/**
+ * Auth response
+ */
+interface AuthResponse {
+    token: string;
+    refreshToken?: string;
+    user: User;
+    role?: Role;
+    expiresIn?: number;
+}
+/**
+ * Auth state events
+ */
+type AuthStateEvent = "SIGNED_IN" | "SIGNED_OUT" | "TOKEN_REFRESHED" | "USER_UPDATED" | "TENANT_SWITCHED";
+/**
+ * Auth state
+ */
+interface AuthState {
+    user: User | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: Error | null;
+}
+/**
+ * Magic link options
+ */
+interface MagicLinkOptions {
+    email: string;
+    redirectUrl?: string;
+    mode?: "link" | "code";
+}
+/**
+ * Password reset options
+ */
+interface PasswordResetOptions {
+    email: string;
+    redirectUrl?: string;
+}
+/**
+ * Authentication mode for the SDK/app
+ * - 'jwt': Use JWT tokens stored in the configured storage adapter (default)
+ * - 'cookie': Use HTTP-only cookies (server handles token storage)
+ */
+type AuthMode = "jwt" | "cookie";
+/**
+ * OAuth2 tokens
+ */
+interface OAuth2Tokens {
+    accessToken: string;
+    refreshToken?: string;
+    idToken?: string;
+    expiresAt?: Date;
+    tokenType?: string;
+    scope?: string;
+}
+/**
+ * OAuth2 user info
+ */
+interface OAuth2UserInfo {
+    id: string;
+    email: string;
+    name?: string;
+    firstName?: string;
+    lastName?: string;
+    picture?: string;
+    [key: string]: unknown;
+}
+
+/**
+ * Schema & Field Types
+ * Shared across core, sdk, cli, and app packages
+ */
+/**
+ * Supported field types in Baasix
+ */
+type FieldType = "String" | "Text" | "HTML" | "Integer" | "BigInt" | "Float" | "Real" | "Double" | "Decimal" | "Boolean" | "Date" | "DateTime" | "Time" | "UUID" | "SUID" | "JSON" | "JSONB" | "Array" | "Geometry" | "Point" | "LineString" | "Polygon" | "Enum";
+/**
+ * Default value types supported by Baasix
+ */
+type DefaultValueType = {
+    type: "UUIDV4";
+} | {
+    type: "SUID";
+} | {
+    type: "NOW";
+} | {
+    type: "AUTOINCREMENT";
+} | {
+    type: "SQL";
+    value: string;
+} | {
+    type: "CURRENT_USER";
+} | {
+    type: "CURRENT_TENANT";
+};
+/**
+ * Field validation rules
+ */
+interface FieldValidationRules {
+    /** Minimum value for numeric fields */
+    min?: number;
+    /** Maximum value for numeric fields */
+    max?: number;
+    /** Validate as integer */
+    isInt?: boolean;
+    /** Validate email format */
+    isEmail?: boolean;
+    /** Validate URL format */
+    isUrl?: boolean;
+    /** Validate IP address format */
+    isIP?: boolean;
+    /** Validate UUID format */
+    isUUID?: boolean;
+    /** String must not be empty */
+    notEmpty?: boolean;
+    /** String length range [min, max] */
+    len?: [number, number];
+    /** Pattern matching with regex */
+    is?: string;
+    /** Pattern matching with regex (alias for is) */
+    matches?: string;
+    /** @deprecated Use 'is' or 'matches' instead */
+    regex?: string;
+}
+/**
+ * Field values configuration (for type-specific options)
+ */
+interface FieldValues {
+    /** String length (varchar) */
+    length?: number;
+    /** String length (alias for length) */
+    stringLength?: number;
+    /** Decimal precision */
+    precision?: number;
+    /** Decimal scale */
+    scale?: number;
+    /** Array element type */
+    type?: string;
+    /** Enum values */
+    values?: string[];
+    /** Spatial reference system identifier (for geometry types) */
+    srid?: number;
+}
+/**
+ * Field definition
+ * Note: `type` is optional because relation fields use `relType` instead
+ */
+interface FieldDefinition {
+    /** Field type (required for data fields, not used for relation fields) */
+    type?: FieldType | string;
+    primaryKey?: boolean;
+    allowNull?: boolean;
+    unique?: boolean;
+    /**
+     * Default value for the field
+     * Can be a static value or a dynamic type
+     */
+    defaultValue?: DefaultValueType | string | number | boolean | null | unknown[] | Record<string, unknown>;
+    /** Field values configuration (for type-specific options like length, precision, enum values) */
+    values?: FieldValues;
+    validate?: FieldValidationRules;
+    comment?: string;
+    /** Field description for documentation */
+    description?: string;
+    /** Relation type (if this is a relation field) */
+    relType?: RelationshipType | string;
+    /** Target collection for relations */
+    target?: string;
+    /** Alias for relation (used in queries) */
+    as?: string;
+    /** Display format for relations */
+    showAs?: string;
+    /** Foreign key field name or boolean indicating it's a foreign key */
+    foreignKey?: string | boolean;
+    /** Target key for relations */
+    targetKey?: string;
+    /** Junction table name for M2M (or junction config object) */
+    through?: string | Record<string, unknown>;
+    /** Other key in junction table */
+    otherKey?: string;
+    /** Display format string */
+    displayFormat?: string;
+    /** Display options */
+    displayOptions?: Record<string, unknown>;
+    /** Calculated field expression */
+    calculated?: string;
+    /** Hide field from API responses */
+    hidden?: boolean;
+    /** Mark field as system-generated (not user-editable) */
+    SystemGenerated?: string | boolean;
+    /** Whether to add constraints */
+    constraints?: boolean;
+    /** Delete behavior for relations */
+    onDelete?: "CASCADE" | "RESTRICT" | "SET NULL" | string;
+    /** Update behavior for relations */
+    onUpdate?: "CASCADE" | "RESTRICT" | "SET NULL" | string;
+    /** Whether this is a polymorphic relation (M2A) */
+    polymorphic?: boolean;
+    /** Target tables for polymorphic (M2A) relations */
+    tables?: string[];
+}
+/**
+ * Flattened field info (used in core services)
+ */
+interface FlattenedField {
+    name: string;
+    type: FieldType;
+    allowNull?: boolean;
+    unique?: boolean;
+    primaryKey?: boolean;
+    defaultValue?: unknown;
+    validate?: FieldValidationRules;
+    relType?: RelationshipType;
+    target?: string;
+}
+/**
+ * Field info with full metadata
+ */
+interface FieldInfo extends FlattenedField {
+    path: string;
+    isRelation: boolean;
+    isNested: boolean;
+}
+/**
+ * Index definition
+ */
+interface IndexDefinition {
+    /** Index name (auto-generated if not provided) */
+    name?: string;
+    fields: string[];
+    unique?: boolean;
+    /** When true, NULL values are considered equal for unique indexes (PostgreSQL 15+) */
+    nullsNotDistinct?: boolean;
+    type?: "btree" | "hash" | "gin" | "gist";
+}
+/**
+ * Schema definition
+ */
+interface SchemaDefinition {
+    name: string;
+    timestamps?: boolean;
+    paranoid?: boolean;
+    sortEnabled?: boolean;
+    /**
+     * Track user who created/updated records (adds createdBy_Id, updatedBy_Id)
+     */
+    usertrack?: boolean;
+    /**
+     * True for M2M/M2A junction tables (system-generated)
+     */
+    isJunction?: boolean;
+    fields: Record<string, FieldDefinition>;
+    indexes?: IndexDefinition[];
+}
+/**
+ * Schema info (full schema with collection name)
+ */
+interface SchemaInfo {
+    collectionName: string;
+    schema: SchemaDefinition;
+    relationships?: RelationshipDefinition[];
+}
+/**
+ * Validation result (generic base)
+ */
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Field validation result
+ */
+interface FieldValidation extends ValidationResult {
+    fieldName: string;
+}
+/**
+ * Schema validation result
+ */
+interface SchemaValidation extends ValidationResult {
+    collectionName: string;
+    fieldValidations?: FieldValidation[];
+}
+/**
+ * Relationship types
+ * - M2O: Many-to-One (creates foreign key with auto-index)
+ * - O2M: One-to-Many (virtual reverse of M2O)
+ * - O2O: One-to-One (creates foreign key with unique constraint)
+ * - M2M: Many-to-Many (creates junction table)
+ * - M2A: Many-to-Any (polymorphic junction table)
+ *
+ * Legacy aliases (deprecated, use M2O/O2M/M2M/O2O instead):
+ * - BelongsTo: alias for M2O
+ * - HasMany: alias for O2M
+ * - HasOne: alias for O2O
+ * - BelongsToMany: alias for M2M
+ */
+type RelationshipType = "M2O" | "O2M" | "M2M" | "M2A" | "O2O" | "BelongsTo" | "HasMany" | "HasOne" | "BelongsToMany";
+/**
+ * Association type (alias for RelationshipType)
+ */
+type AssociationType = RelationshipType;
+/**
+ * Relationship definition
+ */
+interface RelationshipDefinition {
+    type: RelationshipType;
+    target: string;
+    name: string;
+    alias?: string;
+    /**
+     * Custom junction table name for M2M/M2A relationships
+     */
+    through?: string;
+    onDelete?: "CASCADE" | "RESTRICT" | "SET NULL";
+    onUpdate?: "CASCADE" | "RESTRICT" | "SET NULL";
+    /** Target tables for M2A (polymorphic) relationships */
+    tables?: string[];
+}
+/**
+ * Association definition (used internally in core)
+ */
+interface AssociationDefinition {
+    type: AssociationType;
+    foreignKey?: string;
+    sourceKey?: string;
+    targetKey?: string;
+    through?: string;
+    as?: string;
+    target: string;
+    onDelete?: "CASCADE" | "RESTRICT" | "SET NULL";
+    onUpdate?: "CASCADE" | "RESTRICT" | "SET NULL";
+}
+/**
+ * Include configuration for relation fetching
+ */
+interface IncludeConfig {
+    model: string;
+    as?: string;
+    attributes?: string[];
+    where?: Record<string, unknown>;
+    required?: boolean;
+    include?: IncludeConfig[];
+}
+/**
+ * Processed include (after parsing)
+ */
+interface ProcessedInclude {
+    association: string;
+    as: string;
+    attributes?: string[];
+    where?: Record<string, unknown>;
+    required?: boolean;
+    include?: ProcessedInclude[];
+}
+
+/**
+ * Query & Filter Types
+ * Shared across core, sdk, cli, and app packages
+ */
+/**
+ * Filter operators supported by Baasix
+ * Also known as OperatorName in core (alias provided for backward compatibility)
+ */
+type FilterOperator = "eq" | "ne" | "neq" | "gt" | "gte" | "lt" | "lte" | "is" | "not" | "in" | "notIn" | "nin" | "like" | "notLike" | "iLike" | "notILike" | "ilike" | "contains" | "icontains" | "ncontains" | "startsWith" | "startsWiths" | "endsWith" | "endsWiths" | "nstartsWith" | "nstartsWiths" | "nendsWith" | "nendsWiths" | "regex" | "between" | "notBetween" | "nbetween" | "isNull" | "isNotNull" | "empty" | "arraycontains" | "arraycontainsany" | "arraycontained" | "arrayoverlap" | "arraylength" | "arrayempty" | "jsoncontains" | "jsonbContains" | "jsonbContainedBy" | "jsonbNotContains" | "jsonhaskey" | "jsonbHasKey" | "jsonhasanykeys" | "jsonbHasAnyKeys" | "jsonhasallkeys" | "jsonbHasAllKeys" | "jsonpath" | "jsonbKeyEquals" | "jsonbKeyNotEquals" | "jsonbKeyGt" | "jsonbKeyGte" | "jsonbKeyLt" | "jsonbKeyLte" | "jsonbKeyIn" | "jsonbKeyNotIn" | "jsonbKeyLike" | "jsonbKeyIsNull" | "jsonbKeyIsNotNull" | "jsonbPathExists" | "jsonbPathMatch" | "jsonbDeepValue" | "jsonbArrayLength" | "jsonbTypeOf" | "within" | "containsGEO" | "contains" | "intersects" | "nIntersects" | "dwithin" | "overlaps";
+/**
+ * Operator name type (alias for FilterOperator)
+ * Used internally in core for the OPERATOR_MAP keys
+ * @see FilterOperator
+ */
+type OperatorName = FilterOperator;
+/**
+ * Filter value with operator
+ */
+type FilterValue<T = unknown> = T | {
+    [K in FilterOperator]?: T | T[];
+} | {
+    cast?: string;
+};
+/**
+ * Filter condition for a field
+ */
+type FilterCondition = {
+    [field: string]: FilterValue | FilterCondition;
+};
+/**
+ * Logical filter operators
+ */
+interface LogicalFilter {
+    AND?: (FilterCondition | LogicalFilter)[];
+    OR?: (FilterCondition | LogicalFilter)[];
+    NOT?: FilterCondition | LogicalFilter;
+}
+/**
+ * Complete filter type
+ */
+type Filter = FilterCondition | LogicalFilter;
+/**
+ * Filter object (used internally in core)
+ */
+interface FilterObject {
+    field: string;
+    operator: FilterOperator;
+    value: unknown;
+    cast?: string;
+}
+/**
+ * Sort direction
+ */
+type SortDirection = "asc" | "desc" | "ASC" | "DESC";
+/**
+ * Sort configuration - supports multiple formats
+ */
+type Sort = string | string[] | Record<string, SortDirection> | {
+    column: string;
+    order: SortDirection;
+}[] | {
+    field: string;
+    order: SortDirection;
+}[];
+/**
+ * Sort item (normalized)
+ */
+interface SortItem {
+    field: string;
+    direction: SortDirection;
+}
+/**
+ * Sort object structure (Sequelize-style)
+ * Example: { name: 'ASC', createdAt: 'DESC' }
+ */
+interface SortObject {
+    [field: string]: SortDirection;
+}
+/**
+ * Pagination options
+ */
+interface PaginationOptions {
+    page?: number;
+    limit?: number;
+    offset?: number;
+    pageSize?: number;
+}
+/**
+ * Pagination metadata in response
+ */
+interface PaginationMetadata {
+    total: number;
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    /** @deprecated Use total instead */
+    totalCount?: number;
+    /** @deprecated Use pageCount instead */
+    totalPages?: number;
+    /** @deprecated Use pageSize instead */
+    limit?: number;
+}
+/**
+ * Aggregation function
+ */
+type AggregateFunction = "count" | "sum" | "avg" | "min" | "max" | "distinct" | "array_agg";
+/**
+ * Aggregation configuration
+ */
+interface AggregateConfig {
+    function: AggregateFunction;
+    field: string;
+    alias?: string;
+}
+/**
+ * Aggregate mapping (general form)
+ */
+type Aggregate = Record<string, AggregateConfig | AggregateFunction>;
+/**
+ * Aggregate result mapping (strict form - always uses AggregateConfig)
+ * Example: { totalUsers: { function: 'count', field: 'id' } }
+ */
+interface AggregateMapping {
+    [alias: string]: AggregateConfig;
+}
+/**
+ * Date part for date extraction
+ */
+type DatePart = "year" | "month" | "week" | "day" | "hour" | "minute" | "second" | "dow" | "isodow" | "quarter";
+/**
+ * Date truncation precision
+ */
+type DateTruncPrecision = "day" | "week" | "month" | "year" | "hour" | "minute" | "second";
+/**
+ * Query parameters for listing items
+ * Used by SDK, app, and can be extended by core for internal use
+ */
+interface QueryParams<T = unknown> {
+    /**
+     * Fields to return
+     * @example ['*'], ['id', 'name'], ['*', 'author.*']
+     */
+    fields?: string[];
+    /**
+     * Filter conditions
+     */
+    filter?: Filter;
+    /**
+     * Sorting configuration
+     */
+    sort?: Sort;
+    /**
+     * Number of items per page (-1 for all)
+     * @default 10
+     */
+    limit?: number;
+    /**
+     * Page number (1-indexed)
+     * @default 1
+     */
+    page?: number;
+    /**
+     * Number of items to skip
+     */
+    offset?: number;
+    /**
+     * Full-text search query
+     */
+    search?: string;
+    /**
+     * Fields to search in
+     */
+    searchFields?: string[];
+    /**
+     * Sort results by search relevance
+     * @default false
+     */
+    sortByRelevance?: boolean;
+    /**
+     * Aggregation configuration
+     */
+    aggregate?: Aggregate;
+    /**
+     * Fields to group by (used with aggregate)
+     */
+    groupBy?: string[];
+    /**
+     * Include soft-deleted items
+     * @default false
+     */
+    paranoid?: boolean;
+    /**
+     * Filter conditions for related items (O2M/M2M)
+     */
+    relConditions?: Record<string, Filter>;
+    /**
+     * Additional metadata
+     */
+    meta?: T;
+}
+/**
+ * Query options for read operations (alias for QueryParams)
+ * Core-compatible naming
+ */
+type QueryOptions = QueryParams;
+/**
+ * Query context (used internally in core)
+ */
+interface QueryContext {
+    collection: string;
+    filter?: Filter;
+    sort?: Sort;
+    fields?: string[];
+    limit?: number;
+    page?: number;
+    offset?: number;
+    aggregate?: Aggregate;
+    groupBy?: string[];
+}
+/**
+ * Report configuration
+ */
+interface ReportConfig {
+    collection: string;
+    filter?: Record<string, unknown>;
+    groupBy?: string;
+    aggregate?: Record<string, unknown>;
+    dateRange?: {
+        start: string;
+        end: string;
+        field?: string;
+    };
+}
+/**
+ * Report result
+ */
+interface ReportResult {
+    data: Record<string, unknown>[];
+    summary?: Record<string, unknown>;
+}
+/**
+ * Report query parameters
+ */
+interface ReportQuery {
+    fields?: string[];
+    filter?: Record<string, any>;
+    sort?: string[];
+    limit?: number;
+    page?: number;
+    aggregate?: Record<string, any>;
+    groupBy?: string[];
+}
+/**
+ * Stats query
+ */
+interface StatsQuery {
+    name: string;
+    query: Record<string, unknown>;
+    collection: string;
+}
+/**
+ * Stats result
+ */
+interface StatsResult {
+    data: Record<string, unknown>;
+    totalStats: number;
+    successfulStats: number;
+}
+
+/**
+ * Response Types
+ * Shared across core, sdk, cli, and app packages
+ */
+/**
+ * Paginated response
+ */
+interface PaginatedResponse<T> {
+    data: T[];
+    totalCount?: number;
+    page?: number;
+    limit?: number;
+    totalPages?: number;
+}
+/**
+ * Single item response
+ */
+interface SingleResponse<T> {
+    data: T;
+}
+/**
+ * Create/Update response
+ */
+interface MutationResponse<T = string> {
+    data: T;
+    message?: string;
+}
+/**
+ * Delete response
+ */
+interface DeleteResponse {
+    data: {
+        deleted: boolean;
+        count?: number;
+    };
+    message?: string;
+}
+/**
+ * Bulk operation response
+ */
+interface BulkResponse<T = string[]> {
+    data: T;
+    message?: string;
+    errors?: Array<{
+        index: number;
+        error: string;
+    }>;
+}
+/**
+ * Read result (used internally in services)
+ */
+interface ReadResult<T = any> {
+    data: T[];
+    totalCount: number;
+    page?: number;
+    limit?: number;
+}
+/**
+ * Error response
+ */
+interface ErrorResponse {
+    error: string;
+    message: string;
+    status: number;
+    details?: unknown[];
+}
+
+/**
+ * File & Asset Types
+ * Shared across core, sdk, and app packages
+ */
+/**
+ * File metadata
+ */
+interface FileMetadata {
+    id: string;
+    title?: string;
+    description?: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    width?: number;
+    height?: number;
+    duration?: number;
+    storage: string;
+    path: string;
+    isPublic?: boolean;
+    uploadedBy?: string;
+    tenant_Id?: string;
+    createdAt: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+/**
+ * File data (internal use)
+ */
+interface FileData {
+    buffer: Buffer;
+    filename: string;
+    mimetype: string;
+    size: number;
+}
+/**
+ * Upload options
+ */
+interface UploadOptions {
+    title?: string;
+    description?: string;
+    folder?: string;
+    storage?: "local" | "s3";
+    isPublic?: boolean;
+    metadata?: Record<string, unknown>;
+    onProgress?: (progress: number) => void;
+    /** Request timeout in milliseconds (default: 30000). Set to 0 for no timeout. */
+    timeout?: number;
+}
+/**
+ * Internal uploaded file (from express-fileupload)
+ */
+interface InternalUploadedFile {
+    name: string;
+    data: Buffer;
+    size: number;
+    encoding: string;
+    tempFilePath: string;
+    truncated: boolean;
+    mimetype: string;
+    md5: string;
+    mv: (path: string) => Promise<void>;
+}
+/**
+ * Asset transform options
+ */
+interface AssetTransformOptions {
+    width?: number;
+    height?: number;
+    fit?: "cover" | "contain" | "fill" | "inside" | "outside";
+    quality?: number;
+    format?: "jpeg" | "png" | "webp" | "avif";
+}
+/**
+ * Asset query parameters (from HTTP query string)
+ * Values can be string | number since they come from query params
+ */
+interface AssetQuery {
+    width?: string | number;
+    height?: string | number;
+    fit?: "cover" | "contain" | "fill" | "inside" | "outside" | string;
+    quality?: string | number;
+    format?: string;
+    withoutEnlargement?: string | boolean;
+}
+/**
+ * Processed image result
+ */
+interface ProcessedImage {
+    buffer: Buffer;
+    /** Content type (e.g., 'image/jpeg') or format (e.g., 'jpeg') */
+    contentType?: string;
+    format?: string;
+    width?: number;
+    height?: number;
+}
+/**
+ * Storage provider type
+ */
+type StorageProvider = "local" | "s3" | "gcs" | "azure";
+/**
+ * Storage adapter interface
+ */
+interface StorageAdapter {
+    getItem(key: string): string | null | Promise<string | null>;
+    setItem(key: string, value: string): void | Promise<void>;
+    removeItem(key: string): void | Promise<void>;
+}
+/**
+ * Uploaded file interface (from multipart form)
+ */
+interface UploadedFile {
+    originalname: string;
+    mimetype: string;
+    buffer: Buffer;
+    size: number;
+}
+/**
+ * Import options
+ */
+interface ImportOptions {
+    collection: string;
+    file?: UploadedFile;
+    data?: unknown[];
+    format?: "csv" | "json";
+    mapping?: Record<string, string>;
+    skipValidation?: boolean;
+    batchSize?: number;
+    onProgress?: (processed: number, total: number) => void;
+    onError?: (error: Error, row: unknown, index: number) => void;
+}
+/**
+ * Export options
+ */
+interface ExportOptions {
+    collection: string;
+    format?: "csv" | "json";
+    fields?: string[];
+    filter?: Record<string, unknown>;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Import result
+ */
+interface ImportResult {
+    success: boolean;
+    imported: number;
+    failed: number;
+    errors: Array<{
+        row: number;
+        error: string;
+        data?: unknown;
+    }>;
+    duration: number;
+}
+/**
+ * Export result
+ */
+interface ExportResult {
+    success: boolean;
+    data: string | unknown[];
+    count: number;
+    format: string;
+}
+
+/**
+ * Workflow Types
+ * Shared across core, sdk, and app packages
+ */
+/**
+ * Workflow trigger types
+ */
+type WorkflowTriggerType = "manual" | "webhook" | "schedule" | "hook" | "cron";
+/**
+ * Workflow status
+ */
+type WorkflowStatus = "draft" | "active" | "inactive" | "archived";
+/**
+ * Workflow definition
+ */
+interface Workflow {
+    id: string;
+    name: string;
+    description?: string;
+    status: WorkflowStatus;
+    /** @deprecated Use status instead. Kept for backward compatibility. */
+    isActive?: boolean;
+    trigger_type?: WorkflowTriggerType;
+    /** Alternative trigger format used by SDK */
+    trigger?: WorkflowTrigger;
+    trigger_cron?: string;
+    trigger_webhook_path?: string;
+    trigger_webhook_method?: string;
+    trigger_hook_collection?: string;
+    trigger_hook_action?: string;
+    allowed_roles?: string[];
+    flow_data?: WorkflowFlowData;
+    /** Alternative format: nodes at top level */
+    nodes?: WorkflowNode[];
+    /** Alternative format: edges at top level */
+    edges?: WorkflowEdge[];
+    variables?: Record<string, unknown>;
+    options?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/**
+ * Workflow flow data (React Flow format)
+ */
+interface WorkflowFlowData {
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+    viewport?: {
+        x: number;
+        y: number;
+        zoom: number;
+    };
+}
+/**
+ * Workflow trigger configuration
+ */
+interface WorkflowTrigger {
+    type: WorkflowTriggerType;
+    config?: Record<string, unknown>;
+}
+/**
+ * Workflow node
+ */
+interface WorkflowNode {
+    id: string;
+    type: string;
+    data: WorkflowNodeData;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Workflow node data
+ */
+interface WorkflowNodeData {
+    label?: string;
+    [key: string]: unknown;
+}
+/**
+ * Workflow edge
+ */
+interface WorkflowEdge {
+    id: string;
+    source: string;
+    target: string;
+    sourceHandle?: string;
+    targetHandle?: string;
+    condition?: string;
+    label?: string;
+}
+/**
+ * Workflow execution status
+ */
+type WorkflowExecutionStatus = "queued" | "pending" | "running" | "completed" | "failed" | "cancelled";
+/**
+ * Workflow execution
+ */
+interface WorkflowExecution {
+    id: string;
+    workflow_Id: string;
+    status: WorkflowExecutionStatus;
+    triggeredBy?: string;
+    triggerData?: Record<string, unknown>;
+    result?: Record<string, unknown>;
+    error?: string;
+    durationMs?: number;
+    startedAt?: string;
+    completedAt?: string;
+    createdAt: string;
+    updatedAt?: string;
+}
+/**
+ * Workflow execution log
+ */
+interface WorkflowExecutionLog {
+    id: string;
+    execution_Id: string;
+    nodeId: string;
+    nodeType: string;
+    status: "pending" | "running" | "completed" | "failed" | "skipped";
+    input?: Record<string, unknown>;
+    output?: Record<string, unknown>;
+    error?: string;
+    durationMs?: number;
+    startedAt?: string;
+    completedAt?: string;
+}
+
+/**
+ * Notification Types
+ * Shared across core, sdk, and app packages
+ */
+/**
+ * Notification type
+ */
+type NotificationType = "info" | "success" | "warning" | "error" | string;
+/**
+ * Notification
+ */
+interface Notification {
+    id: string;
+    type: NotificationType;
+    title: string;
+    message: string;
+    data?: Record<string, unknown>;
+    seen: boolean;
+    user_Id: string;
+    tenant_Id?: string;
+    createdAt: string;
+    updatedAt?: string;
+}
+/**
+ * Notification options (for creating)
+ */
+interface NotificationOptions {
+    type?: NotificationType;
+    title: string;
+    message: string;
+    data?: Record<string, unknown>;
+    userIds?: string[];
+    tenant_Id?: string;
+}
+/**
+ * Send notification data
+ */
+interface SendNotificationData {
+    type?: NotificationType;
+    title: string;
+    message: string;
+    data?: Record<string, unknown>;
+    userIds: string[];
+}
+
+/**
+ * Spatial/GeoJSON Types
+ * Types for geospatial data (PostGIS compatible)
+ */
+/**
+ * GeoJSON Point
+ */
+interface GeoJSONPoint {
+    type: "Point";
+    coordinates: [number, number];
+}
+/**
+ * GeoJSON LineString
+ */
+interface GeoJSONLineString {
+    type: "LineString";
+    coordinates: [number, number][];
+}
+/**
+ * GeoJSON Polygon
+ */
+interface GeoJSONPolygon {
+    type: "Polygon";
+    coordinates: [number, number][][];
+}
+/**
+ * GeoJSON Geometry (union type)
+ */
+type GeoJSONGeometry = GeoJSONPoint | GeoJSONLineString | GeoJSONPolygon;
+
+/**
+ * Cache Types
+ * Types for caching functionality
+ */
+/**
+ * Cache configuration (SDK/app level)
+ */
+interface CacheConfig {
+    enabled?: boolean;
+    ttl?: number;
+    prefix?: string;
+}
+/**
+ * Cache set options (Redis-style options for cache.set operations)
+ */
+interface CacheSetOptions {
+    /** Expiration in seconds */
+    ex?: number;
+    [key: string]: unknown;
+}
+/**
+ * Cache strategy
+ */
+type CacheStrategy = "explicit" | "all";
+/**
+ * Cache entry structure
+ */
+interface CacheEntry {
+    value: any;
+    expiry: number;
+    tables: string[];
+    tags: string[];
+    tenant?: string | null;
+}
+/**
+ * Base interface for all cache adapters
+ * Implement this interface to create custom cache adapters
+ */
+interface ICacheAdapter {
+    get(key: string): Promise<any | null>;
+    set(key: string, value: any, ttl?: number, metadata?: {
+        tables: string[];
+        tags: string[];
+        tenant?: string | null;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    invalidateByPattern(pattern: string): Promise<void>;
+    invalidateByTables(tables: string[], tenant?: string | null): Promise<void>;
+    invalidateByTags(tags: string[], tenant?: string | null): Promise<void>;
+    getStats(): Promise<{
+        keys: number;
+        size?: number;
+    }>;
+    close(): Promise<void>;
+}
+
+/**
+ * Common/Utility Types
+ * Shared across all packages
+ */
+/**
+ * Generic record type with ID
+ */
+interface BaseItem {
+    id: string;
+    createdAt?: string;
+    updatedAt?: string;
+    deletedAt?: string;
+    [key: string]: unknown;
+}
+/**
+ * Timestamped item
+ */
+interface TimestampedItem {
+    createdAt: string;
+    updatedAt?: string;
+}
+/**
+ * Soft deletable item
+ */
+interface SoftDeletableItem {
+    deletedAt?: string | null;
+}
+/**
+ * Make all properties of T optional recursively
+ */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/**
+ * Extract the item type from a collection
+ */
+type CollectionItem<T> = T extends Array<infer U> ? U : T;
+/**
+ * Make specific properties required
+ */
+type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+/**
+ * Make specific properties optional
+ */
+type WithOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * Extract keys of T that have values of type V
+ */
+type KeysOfType<T, V> = {
+    [K in keyof T]: T[K] extends V ? K : never;
+}[keyof T];
+/**
+ * Record with string keys and unknown values
+ */
+type AnyRecord = Record<string, unknown>;
+/**
+ * Generic settings
+ */
+interface Settings {
+    [key: string]: unknown;
+}
+/**
+ * Tenant settings
+ */
+interface TenantSettings {
+    tenant_Id?: string | number | null;
+    project_name?: string;
+    title?: string;
+    project_url?: string | null;
+    app_url?: string | null;
+    project_color?: string;
+    secondary_color?: string;
+    description?: string;
+    keywords?: string;
+    from_email_name?: string;
+    smtp_enabled?: boolean;
+    smtp_host?: string;
+    smtp_port?: number;
+    smtp_secure?: boolean;
+    smtp_user?: string;
+    smtp_pass?: string;
+    smtp_from_address?: string;
+    timezone?: string;
+    language?: string;
+    date_format?: string;
+    currency?: string;
+    email_signature?: string;
+    email_icon?: any;
+    metadata?: Record<string, any>;
+    modules?: Record<string, any>;
+    [key: string]: any;
+}
+/**
+ * Background task
+ */
+interface BackgroundTask {
+    id: string | number;
+    task_status: string;
+    scheduled_time: Date;
+    [key: string]: unknown;
+}
+/**
+ * Hook events
+ */
+type HookEvent = "items.create" | "items.read" | "items.update" | "items.delete" | "auth.login" | "auth.logout" | "auth.register";
+/**
+ * Hook handler context
+ */
+interface HookContext {
+    event: HookEvent;
+    collection?: string;
+    payload?: unknown;
+    keys?: string[];
+    accountability?: {
+        user?: {
+            id: string;
+        };
+        role?: {
+            id: string;
+            name: string;
+        };
+        tenant?: {
+            id: string;
+        };
+    };
+}
+/**
+ * Hook handler function
+ */
+type HookHandler = (context: HookContext) => void | Promise<void>;
+/**
+ * Hook definition
+ */
+interface Hook {
+    event: HookEvent;
+    collection?: string;
+    handler: HookHandler;
+}
+/**
+ * HTTP methods
+ */
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD";
+/**
+ * Mail options for sending emails
+ */
+interface MailOptions {
+    to: string | string[];
+    subject: string;
+    html?: string;
+    text?: string;
+    from?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+    replyTo?: string;
+    attachments?: Array<{
+        filename: string;
+        content?: string | Buffer;
+        path?: string;
+        contentType?: string;
+    }>;
+}
+/**
+ * Sender configuration for email
+ */
+interface SenderConfig {
+    from: string;
+    name?: string;
+    replyTo?: string;
+}
+/**
+ * Seed data configuration
+ */
+interface SeedData {
+    collection: string;
+    data: Record<string, unknown> | Record<string, unknown>[];
+    /** Whether to clear existing data before seeding */
+    clearBefore?: boolean;
+    /** Whether to skip if data already exists (check by unique fields) */
+    skipDuplicates?: boolean;
+}
+/**
+ * Seed operation result
+ */
+interface SeedResult {
+    collection: string;
+    created: number;
+    skipped: number;
+    errors: number;
+    errorDetails?: Array<{
+        item: unknown;
+        error: string;
+    }>;
+}
+
+/**
+ * Plugin System Types
+ * Shared types for Baasix plugin development
+ */
+
+/** Express Request type */
+type Request = Request$1;
+/** Express Response type */
+type Response = Response$1;
+/** Express NextFunction type */
+type NextFunction = NextFunction$1;
+/** Express Application type */
+type Express = Express$1;
+/** Express Router type */
+type Router = Router$1;
+/** Type aliases for clarity */
+type ExpressRequest = Request$1;
+type ExpressResponse = Response$1;
+type ExpressNextFunction = NextFunction$1;
+type ExpressApp = Express$1;
+type ExpressRouter = Router$1;
+/**
+ * Generic request type (compatible with Express Request)
+ */
+interface PluginRequest {
+    params: Record<string, string>;
+    query: Record<string, any>;
+    body: any;
+    headers: Record<string, string | string[] | undefined>;
+    method: string;
+    path: string;
+    url: string;
+    originalUrl: string;
+    baseUrl: string;
+    cookies?: Record<string, string>;
+    signedCookies?: Record<string, string>;
+    ip?: string;
+    ips?: string[];
+    hostname?: string;
+    protocol?: string;
+    secure?: boolean;
+    xhr?: boolean;
+    accountability?: Accountability;
+    get(header: string): string | undefined;
+    header(header: string): string | undefined;
+    accepts(...types: string[]): string | false;
+    is(type: string): string | false | null;
+    [key: string]: any;
+}
+/**
+ * Generic response type (compatible with Express Response)
+ */
+interface PluginResponse {
+    status(code: number): PluginResponse;
+    sendStatus(code: number): PluginResponse;
+    json(data: any): PluginResponse;
+    send(data: any): PluginResponse;
+    end(data?: any): PluginResponse;
+    set(header: string, value: string | string[]): PluginResponse;
+    set(headers: Record<string, string | string[]>): PluginResponse;
+    header(header: string, value: string | string[]): PluginResponse;
+    get(header: string): string | undefined;
+    type(type: string): PluginResponse;
+    contentType(type: string): PluginResponse;
+    redirect(url: string): void;
+    redirect(status: number, url: string): void;
+    cookie(name: string, value: string, options?: Record<string, any>): PluginResponse;
+    clearCookie(name: string, options?: Record<string, any>): PluginResponse;
+    attachment(filename?: string): PluginResponse;
+    download(path: string, filename?: string): void;
+    locals: Record<string, any>;
+    headersSent: boolean;
+    statusCode: number;
+    [key: string]: any;
+}
+/**
+ * Generic next function type (compatible with Express NextFunction)
+ */
+type PluginNextFunction = (error?: any) => void;
+/**
+ * Generic Express application type
+ */
+interface PluginApp {
+    use(...handlers: any[]): PluginApp;
+    get(path: string, ...handlers: any[]): PluginApp;
+    post(path: string, ...handlers: any[]): PluginApp;
+    put(path: string, ...handlers: any[]): PluginApp;
+    patch(path: string, ...handlers: any[]): PluginApp;
+    delete(path: string, ...handlers: any[]): PluginApp;
+    options(path: string, ...handlers: any[]): PluginApp;
+    all(path: string, ...handlers: any[]): PluginApp;
+    listen(port: number, callback?: () => void): any;
+    set(setting: string, value: any): PluginApp;
+    get(setting: string): any;
+    locals: Record<string, any>;
+    [key: string]: any;
+}
+/**
+ * Generic Router type (compatible with Express Router)
+ */
+interface PluginRouter {
+    use(...handlers: any[]): PluginRouter;
+    get(path: string, ...handlers: any[]): PluginRouter;
+    post(path: string, ...handlers: any[]): PluginRouter;
+    put(path: string, ...handlers: any[]): PluginRouter;
+    patch(path: string, ...handlers: any[]): PluginRouter;
+    delete(path: string, ...handlers: any[]): PluginRouter;
+    options(path: string, ...handlers: any[]): PluginRouter;
+    all(path: string, ...handlers: any[]): PluginRouter;
+    [key: string]: any;
+}
+/**
+ * Base service options with accountability
+ */
+interface ServiceOptions {
+    accountability?: Accountability;
+    [key: string]: any;
+}
+/**
+ * Items service interface for CRUD operations
+ * Note: Actual implementations may have additional methods and different signatures.
+ * The index signature provides flexibility for all implementations.
+ */
+interface IItemsService {
+    [key: string]: any;
+}
+/**
+ * Permission service interface
+ */
+interface IPermissionService {
+    [key: string]: any;
+}
+/**
+ * Mail service interface
+ */
+interface IMailService {
+    [key: string]: any;
+}
+/**
+ * Storage service interface
+ */
+interface IStorageService {
+    [key: string]: any;
+}
+/**
+ * Settings service interface
+ */
+interface ISettingsService {
+    [key: string]: any;
+}
+/**
+ * Socket service interface
+ */
+interface ISocketService {
+    [key: string]: any;
+}
+/**
+ * Realtime service interface
+ */
+interface IRealtimeService {
+    [key: string]: any;
+}
+/**
+ * Tasks service interface
+ */
+interface ITasksService {
+    [key: string]: any;
+}
+/**
+ * Workflow service interface
+ */
+interface IWorkflowService {
+    [key: string]: any;
+}
+/**
+ * Migration service interface
+ */
+interface IMigrationService {
+    [key: string]: any;
+}
+/**
+ * Hook function type - called during lifecycle events
+ */
+type HookFunction = (context: PluginHookContext) => Promise<PluginHookContext> | PluginHookContext;
+/**
+ * Hooks manager interface - manages lifecycle hooks for collections
+ */
+interface IHooksManager {
+    /**
+     * Register a hook for a collection and event
+     * @param collection - Collection name (use '*' for all collections)
+     * @param event - Event name (e.g., 'items.create', 'items.update')
+     * @param hookFunction - Function to execute
+     */
+    registerHook(collection: string, event: string, hookFunction: HookFunction): void;
+    /**
+     * Get hooks for a collection and event
+     * @param collection - Collection name
+     * @param event - Event name
+     * @returns Array of registered hook functions
+     */
+    getHooks(collection: string, event: string): HookFunction[];
+    /**
+     * Execute hooks for a collection and event
+     * @param collection - Collection name
+     * @param event - Event name
+     * @param accountability - User/role accountability info
+     * @param context - Hook context with data
+     * @returns Modified context after all hooks execute
+     */
+    executeHooks(collection: string, event: string, accountability: Accountability | undefined, context: PluginHookContext): Promise<PluginHookContext>;
+    /**
+     * Load hooks from extensions directory
+     * @param context - Plugin context
+     * @param directory - Optional directory path
+     */
+    loadHooksFromDirectory?(context: any, directory?: string): Promise<void>;
+    /**
+     * Load schedules from extensions directory
+     * @param context - Plugin context
+     * @param schedule - Schedule manager
+     * @param directory - Optional directory path
+     */
+    loadSchedulesFromDirectory?(context: any, schedule: any, directory?: string): Promise<void>;
+    /** Allow additional methods/properties */
+    [key: string]: any;
+}
+/**
+ * Cache service interface
+ */
+interface ICacheService {
+    [key: string]: any;
+}
+/**
+ * Files service interface
+ */
+interface IFilesService {
+    [key: string]: any;
+}
+/**
+ * Assets service interface
+ */
+interface IAssetsService {
+    [key: string]: any;
+}
+/**
+ * Notification service interface
+ */
+interface INotificationService {
+    [key: string]: any;
+}
+/**
+ * Report service interface
+ */
+interface IReportService {
+    [key: string]: any;
+}
+/**
+ * Stats service interface
+ */
+interface IStatsService {
+    [key: string]: any;
+}
+/**
+ * Plugin types categorize plugins by their primary function
+ */
+type PluginType = "feature" | "auth" | "payment" | "storage" | "ai" | "notification" | "integration";
+/**
+ * Plugin metadata - information about the plugin
+ */
+interface PluginMeta {
+    /** Unique plugin name (used as identifier) */
+    name: string;
+    /** Plugin version (semver) */
+    version: string;
+    /** Plugin type/category */
+    type: PluginType;
+    /** Human-readable description */
+    description?: string;
+    /** Plugin author */
+    author?: string;
+    /** Plugin dependencies (names of other plugins that must be loaded first) */
+    dependencies?: string[];
+}
+/**
+ * Schema definition for plugin collections
+ */
+interface PluginSchemaDefinition {
+    collectionName: string;
+    schema: SchemaDefinition;
+}
+/**
+ * Plugin route handler context - available in route handlers
+ */
+interface PluginRouteContext {
+    /** Database connection */
+    db: any;
+    /** ItemsService class for CRUD operations */
+    ItemsService: new (...args: any[]) => IItemsService;
+    /** Registered plugin services */
+    services: Record<string, any>;
+    /** Permission service (singleton) */
+    permissionService?: IPermissionService;
+    /** Mail service (singleton) */
+    mailService?: IMailService;
+    /** Storage service (singleton) */
+    storageService?: IStorageService;
+    /** Settings service (singleton) */
+    settingsService?: ISettingsService;
+    /** Socket service (singleton) */
+    socketService?: ISocketService;
+    /** Realtime service (singleton) */
+    realtimeService?: IRealtimeService;
+    /** Tasks service (singleton) */
+    tasksService?: ITasksService;
+    /** Workflow service (singleton) */
+    workflowService?: IWorkflowService;
+    /** Migration service (singleton) */
+    migrationService?: IMigrationService;
+    /** Get cache service instance */
+    getCacheService?: () => ICacheService;
+    /** FilesService class */
+    FilesService?: new (...args: any[]) => IFilesService;
+    /** AssetsService class */
+    AssetsService?: new (...args: any[]) => IAssetsService;
+    /** NotificationService class */
+    NotificationService?: new (...args: any[]) => INotificationService;
+    /** ReportService class */
+    ReportService?: new (...args: any[]) => IReportService;
+    /** StatsService class */
+    StatsService?: new (...args: any[]) => IStatsService;
+    /** Plugin configuration */
+    config: Record<string, any>;
+}
+/**
+ * Plugin route handler function
+ */
+type PluginRouteHandler<TReq = PluginRequest, TRes = PluginResponse> = (req: TReq, res: TRes, context: PluginRouteContext) => Promise<any> | any;
+/**
+ * Plugin route definition
+ */
+interface PluginRoute<TReq = PluginRequest, TRes = PluginResponse> {
+    /** Route path (e.g., '/payments/stripe/checkout') */
+    path: string;
+    /** HTTP method */
+    method: HttpMethod;
+    /** Route handler */
+    handler: PluginRouteHandler<TReq, TRes>;
+    /** Whether authentication is required */
+    requireAuth?: boolean;
+    /** Whether to parse raw body (for webhooks) */
+    rawBody?: boolean;
+    /** Custom middleware for this route */
+    middleware?: Array<(req: TReq, res: TRes, next: PluginNextFunction) => void>;
+    /** Route description for documentation */
+    description?: string;
+}
+/**
+ * Plugin hook event types
+ */
+type PluginHookEvent = "items.create" | "items.read" | "items.update" | "items.delete" | "items.create.after" | "items.read.after" | "items.update.after" | "items.delete.after";
+/**
+ * Plugin hook context - passed to hook handlers
+ * All properties are optional to allow flexibility in different contexts
+ */
+interface PluginHookContext {
+    collection?: string;
+    accountability?: Accountability;
+    db?: any;
+    data?: any;
+    id?: string | number;
+    query?: any;
+    schema?: any;
+    transaction?: any;
+    [key: string]: any;
+}
+/**
+ * Plugin hook handler function
+ */
+type PluginHookHandler = (context: PluginHookContext) => Promise<PluginHookContext> | PluginHookContext;
+/**
+ * Plugin hook definition
+ */
+interface PluginHook {
+    /** Collection name (use '*' for all collections) */
+    collection: string;
+    /** Hook event */
+    event: PluginHookEvent;
+    /** Hook handler */
+    handler: PluginHookHandler;
+    /** Hook priority (lower runs first) */
+    priority?: number;
+}
+/**
+ * Plugin context - passed to lifecycle hooks and service factories
+ */
+interface PluginContext extends PluginRouteContext {
+    /** Hooks manager (singleton) */
+    hooksManager?: IHooksManager;
+    /** Invalidate cache for a collection */
+    invalidateCache?: (collection?: string) => Promise<void>;
+    /** Express app instance (when available) */
+    app?: PluginApp;
+    /** Get another plugin's service */
+    getPluginService: (pluginName: string, serviceName: string) => any;
+}
+/**
+ * Plugin service factory function
+ */
+type PluginServiceFactory = (context: PluginContext) => any;
+/**
+ * Plugin service definition
+ */
+interface PluginService {
+    /** Service name (used to access via context.services.name) */
+    name: string;
+    /** Service factory function */
+    factory: PluginServiceFactory;
+}
+/**
+ * Plugin auth provider type
+ */
+type AuthProviderType = "oauth2" | "otp" | "passkey" | "custom";
+/**
+ * OAuth2 configuration
+ */
+interface OAuth2Config {
+    authorizationUrl: string;
+    tokenUrl: string;
+    userInfoUrl: string;
+    clientId: string;
+    clientSecret: string;
+    scope?: string[];
+}
+/**
+ * Plugin auth provider definition
+ */
+interface PluginAuthProvider {
+    /** Provider identifier (e.g., 'github', 'otp') */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Provider type */
+    type: AuthProviderType;
+    /** OAuth2 configuration (for oauth2 type) */
+    oauth2Config?: OAuth2Config;
+    /** Custom authentication handler */
+    authenticate?: (credentials: Record<string, any>, context: PluginContext) => Promise<{
+        user: any;
+        account?: any;
+    } | null>;
+    /** Custom routes for this provider */
+    routes?: PluginRoute[];
+}
+/**
+ * Plugin middleware definition
+ */
+interface PluginMiddleware<TReq = PluginRequest, TRes = PluginResponse> {
+    /** Middleware name (for debugging) */
+    name: string;
+    /** Path pattern (optional, defaults to all routes) */
+    path?: string;
+    /** Middleware handler */
+    handler: (req: TReq, res: TRes, next: PluginNextFunction) => void;
+    /** Priority (lower runs first) */
+    priority?: number;
+}
+/**
+ * Plugin schedule definition
+ */
+interface PluginSchedule {
+    /** Schedule name */
+    name: string;
+    /** Cron expression */
+    cron: string;
+    /** Schedule handler */
+    handler: (context: PluginContext) => Promise<void> | void;
+    /** Whether to run immediately on startup */
+    runOnStart?: boolean;
+}
+/**
+ * Plugin definition - what a plugin provides
+ */
+interface PluginDefinition {
+    /** Plugin metadata */
+    meta: PluginMeta;
+    /** Schema extensions - new collections/tables */
+    schemas?: PluginSchemaDefinition[];
+    /** Route extensions - new API endpoints */
+    routes?: PluginRoute[];
+    /** Hook extensions - lifecycle hooks */
+    hooks?: PluginHook[];
+    /** Service extensions - new services */
+    services?: PluginService[];
+    /** Auth provider extensions */
+    authProviders?: PluginAuthProvider[];
+    /** Middleware extensions */
+    middleware?: PluginMiddleware[];
+    /** Scheduled tasks */
+    schedules?: PluginSchedule[];
+    /** Called when the plugin is initialized */
+    onInit?: (context: PluginContext) => Promise<void>;
+    /** Called when all plugins are loaded and server is ready */
+    onReady?: (context: PluginContext) => Promise<void>;
+    /** Called when the server is shutting down */
+    onShutdown?: (context: PluginContext) => Promise<void>;
+}
+/**
+ * Plugin factory function - creates a plugin with configuration
+ */
+type PluginFactory<TConfig = Record<string, any>> = (config: TConfig) => PluginDefinition;
+/**
+ * Baasix plugin type
+ */
+type BaasixPlugin = PluginDefinition;
+/**
+ * Loaded plugin - plugin with runtime state
+ */
+interface LoadedPlugin {
+    /** Plugin definition */
+    definition: PluginDefinition;
+    /** Plugin configuration */
+    config: Record<string, any>;
+    /** Plugin services (instantiated) */
+    services: Record<string, any>;
+    /** Whether the plugin has been initialized */
+    initialized: boolean;
+    /** Whether the plugin is ready */
+    ready: boolean;
+}
+/**
+ * Plugin manager options
+ */
+interface PluginManagerOptions {
+    /** Whether to log plugin loading */
+    verbose?: boolean;
+}
+/**
+ * Start server options with plugin support
+ */
+interface StartServerOptions {
+    /** Server port */
+    port?: number;
+    /** Plugins to load */
+    plugins?: BaasixPlugin[];
+    /** Plugin manager options */
+    pluginOptions?: PluginManagerOptions;
+}
+/**
+ * Plugin route handler function with Express types
+ */
+type ExpressPluginRouteHandler = (req: Request, res: Response, context: PluginRouteContext) => Promise<any> | any;
+/**
+ * Plugin route definition with Express types
+ */
+interface ExpressPluginRoute extends Omit<PluginRoute, 'handler' | 'middleware'> {
+    /** Route handler */
+    handler: ExpressPluginRouteHandler;
+    /** Custom middleware for this route */
+    middleware?: Array<(req: Request, res: Response, next: NextFunction) => void>;
+}
+/**
+ * Plugin middleware definition with Express types
+ */
+interface ExpressPluginMiddleware extends Omit<PluginMiddleware, 'handler'> {
+    /** Middleware handler */
+    handler: (req: Request, res: Response, next: NextFunction) => void;
+}
+/**
+ * Plugin context with Express types
+ */
+interface ExpressPluginContext extends PluginRouteContext {
+    /** Hooks manager (singleton) - lifecycle hooks for collections */
+    hooksManager?: IHooksManager;
+    /** Invalidate cache for a collection */
+    invalidateCache?: (collection?: string) => Promise<void>;
+    /** Express app instance */
+    app?: Express;
+    /** Get another plugin's service */
+    getPluginService: (pluginName: string, serviceName: string) => any;
+}
+
+export type { Accountability, Aggregate, AggregateConfig, AggregateFunction, AggregateMapping, AnyRecord, AssetQuery, AssetTransformOptions, AssociationDefinition, AssociationType, AuthMode, AuthProviderType, AuthResponse, AuthState, AuthStateEvent, AuthTokens, BaasixPlugin, BackgroundTask, BaseItem, BulkResponse, CacheConfig, CacheEntry, CacheSetOptions, CacheStrategy, CollectionItem, CreatePermissionData, DatePart, DateTruncPrecision, DeepPartial, DefaultValueType, DeleteResponse, ErrorResponse, ExportOptions, ExportResult, Express, ExpressApp, ExpressNextFunction, ExpressPluginContext, ExpressPluginMiddleware, ExpressPluginRoute, ExpressPluginRouteHandler, ExpressRequest, ExpressResponse, ExpressRouter, FieldDefinition, FieldInfo, FieldType, FieldValidation, FieldValidationRules, FieldValues, FileData, FileMetadata, Filter, FilterCondition, FilterObject, FilterOperator, FilterValue, FlattenedField, GeoJSONGeometry, GeoJSONLineString, GeoJSONPoint, GeoJSONPolygon, Hook, HookContext, HookEvent, HookFunction, HookHandler, HttpMethod, IAssetsService, ICacheAdapter, ICacheService, IFilesService, IHooksManager, IItemsService, IMailService, IMigrationService, INotificationService, IPermissionService, IRealtimeService, IReportService, ISettingsService, ISocketService, IStatsService, IStorageService, ITasksService, IWorkflowService, ImportOptions, ImportResult, IncludeConfig, IndexDefinition, InternalUploadedFile, JWTPayload, KeysOfType, LoadedPlugin, LogicalFilter, LoginCredentials, MagicLinkOptions, MailOptions, MutationResponse, NextFunction, Notification, NotificationOptions, NotificationType, OAuth2Config, OAuth2Tokens, OAuth2UserInfo, OperatorName, PaginatedResponse, PaginationMetadata, PaginationOptions, PasswordResetOptions, Permission, PermissionAction, PermissionData, PluginApp, PluginAuthProvider, PluginContext, PluginDefinition, PluginFactory, PluginHook, PluginHookContext, PluginHookEvent, PluginHookHandler, PluginManagerOptions, PluginMeta, PluginMiddleware, PluginNextFunction, PluginRequest, PluginResponse, PluginRoute, PluginRouteContext, PluginRouteHandler, PluginRouter, PluginSchedule, PluginSchemaDefinition, PluginService, PluginServiceFactory, PluginType, ProcessedImage, ProcessedInclude, QueryContext, QueryOptions, QueryParams, ReadResult, RegisterData, RelationshipDefinition, RelationshipType, ReportConfig, ReportQuery, ReportResult, Request, Response, Role, Router, SchemaDefinition, SchemaInfo, SchemaValidation, SeedData, SeedResult, SendNotificationData, SenderConfig, ServiceOptions, Session, Settings, SingleResponse, SoftDeletableItem, Sort, SortDirection, SortItem, SortObject, StartServerOptions, StatsQuery, StatsResult, StorageAdapter, StorageProvider, Tenant, TenantSettings, TimestampedItem, UploadOptions, UploadedFile, User, UserWithPassword, UserWithRolesAndPermissions, ValidationResult, WithOptional, WithRequired, Workflow, WorkflowEdge, WorkflowExecution, WorkflowExecutionLog, WorkflowExecutionStatus, WorkflowFlowData, WorkflowNode, WorkflowNodeData, WorkflowStatus, WorkflowTrigger, WorkflowTriggerType };