@centrali-io/centrali-sdk 5.2.0 → 5.4.0

package/dist/index.d.ts

@@ -0,0 +1,4918 @@
+import { AxiosRequestConfig, Method } from 'axios';
+/**
+ * Error thrown by the Centrali SDK when an HTTP request fails.
+ * Wraps the underlying HTTP error to avoid leaking transport details.
+ *
+ * @example
+ * ```ts
+ * import { CentraliSDK, CentraliError } from '@centrali-io/centrali-sdk';
+ *
+ * try {
+ *   await client.records.create(structureId, data);
+ * } catch (err) {
+ *   if (err instanceof CentraliError) {
+ *     console.log(err.status);  // 400
+ *     console.log(err.code);    // 'VALIDATION_ERROR'
+ *     console.log(err.message); // 'structureSlug is required'
+ *   }
+ * }
+ * ```
+ */
+export declare class CentraliError extends Error {
+    /** HTTP status code (e.g. 400, 401, 404, 500). Undefined for network errors. */
+    readonly status: number | undefined;
+    /** HTTP status text (e.g. "Bad Request"). Undefined for network errors. */
+    readonly statusText: string | undefined;
+    /** Machine-readable error code in SCREAMING_SNAKE_CASE (e.g. 'VALIDATION_ERROR', 'NOT_FOUND'). Undefined for network errors. */
+    readonly code: string | undefined;
+    /** Field-level validation errors. Present when code is 'VALIDATION_ERROR' and the server included per-field details. */
+    readonly fieldErrors: {
+        field: string;
+        message: string;
+    }[] | undefined;
+    /** Parsed response body from the server. Undefined if no response was received. */
+    readonly body: unknown;
+    constructor(message: string, status?: number, statusText?: string, body?: unknown, code?: string, fieldErrors?: {
+        field: string;
+        message: string;
+    }[]);
+}
+/**
+ * Type guard to check if a value is a CentraliError.
+ *
+ * @example
+ * ```ts
+ * } catch (err) {
+ *   if (isCentraliError(err)) {
+ *     console.log(err.status);
+ *   }
+ * }
+ * ```
+ */
+export declare function isCentraliError(err: unknown): err is CentraliError;
+/**
+ * Record event types emitted by the realtime service.
+ */
+export type RecordEventType = 'record_created' | 'record_updated' | 'record_deleted' | 'records_bulk_created';
+/**
+ * Validation event types emitted by the realtime service.
+ */
+export type ValidationEventType = 'validation_suggestion_created' | 'validation_batch_completed';
+/**
+ * Anomaly event types emitted by the realtime service.
+ */
+export type AnomalyEventType = 'anomaly_insight_created' | 'anomaly_detection_completed';
+/**
+ * Compute function event types emitted by the realtime service.
+ */
+export type ComputeEventType = 'function_run_completed' | 'function_run_failed';
+/**
+ * Orchestration run event types emitted by the realtime service.
+ */
+export type OrchestrationEventType = 'orchestration_run_started' | 'orchestration_run_completed' | 'orchestration_run_failed';
+/**
+ * All event types emitted by the realtime service.
+ * Matches: services/backend/realtime/internal/redis/message.go
+ */
+export type RealtimeEventType = RecordEventType | ValidationEventType | AnomalyEventType | ComputeEventType | OrchestrationEventType;
+/**
+ * Record event payload from the realtime service.
+ * Matches: services/backend/realtime/internal/redis/message.go RecordEvent
+ */
+export interface RealtimeRecordEvent {
+    /** Event type */
+    event: RecordEventType;
+    /** Workspace slug where the event occurred */
+    workspaceSlug: string;
+    /** Structure's record slug (e.g., "order") */
+    recordSlug: string;
+    /** Record ID */
+    recordId: string;
+    /** Record data. For updates, contains "before" and "after" fields */
+    data?: Record<string, unknown>;
+    /** ISO timestamp when the event occurred */
+    timestamp: string;
+    /** User who created the record (for create events) */
+    createdBy?: string;
+    /** User who updated the record (for update events) */
+    updatedBy?: string;
+    /** User who deleted the record (for delete events) */
+    deletedBy?: string;
+}
+/**
+ * Validation suggestion data nested in the event.
+ */
+export interface ValidationSuggestionData {
+    /** Structure slug */
+    structureSlug: string;
+    /** Field with the issue */
+    field: string;
+    /** Type of issue */
+    issueType: 'format' | 'typo' | 'duplicate' | 'semantic';
+    /** Original value */
+    originalValue: string | null;
+    /** Suggested value */
+    suggestedValue: string | null;
+    /** Confidence score 0-1 */
+    confidence: number;
+    /** Suggestion status */
+    status: 'pending' | 'auto-applied';
+    /** Batch ID if from a batch scan */
+    batchId: string | null;
+}
+/**
+ * Validation suggestion created event payload.
+ * Matches the format published by process_validation_events.ts
+ */
+export interface RealtimeValidationSuggestionEvent {
+    /** Event type */
+    event: 'validation_suggestion_created';
+    /** Workspace slug */
+    workspaceSlug: string;
+    /** Record slug (structure slug for filtering) */
+    recordSlug: string;
+    /** Record ID the suggestion applies to */
+    recordId: string;
+    /** ISO timestamp */
+    timestamp: string;
+    /** Validation-specific data */
+    data: ValidationSuggestionData;
+}
+/**
+ * Validation batch data nested in the event.
+ */
+export interface ValidationBatchData {
+    /** Structure slug that was scanned */
+    structureSlug: string;
+    /** Batch ID */
+    batchId: string;
+    /** Total records processed */
+    processed: number;
+    /** Issues found */
+    issuesFound: number;
+    /** Issues auto-applied */
+    autoApplied: number;
+    /** Final status */
+    status: 'completed' | 'failed';
+    /** Error message if failed */
+    error?: string;
+    /** When scan started */
+    startedAt: string;
+    /** When scan completed */
+    completedAt: string;
+}
+/**
+ * Validation batch completed event payload.
+ * Matches the format published by process_validation_events.ts
+ */
+export interface RealtimeValidationBatchEvent {
+    /** Event type */
+    event: 'validation_batch_completed';
+    /** Workspace slug */
+    workspaceSlug: string;
+    /** Record slug (structure slug for filtering) */
+    recordSlug: string;
+    /** Record ID (batch ID for tracking) */
+    recordId: string;
+    /** ISO timestamp */
+    timestamp: string;
+    /** Batch-specific data */
+    data: ValidationBatchData;
+}
+/**
+ * Anomaly insight data nested in the event.
+ */
+export interface AnomalyInsightData {
+    /** Structure ID */
+    structureId: string;
+    /** Structure slug */
+    structureSlug: string;
+    /** Insight ID */
+    insightId: string;
+    /** Type of anomaly detected */
+    insightType: 'time_series_anomaly' | 'statistical_outlier' | 'pattern_deviation' | 'volume_spike' | 'missing_data' | 'orphaned_reference' | 'reference_integrity';
+    /** Severity level */
+    severity: 'info' | 'warning' | 'critical';
+    /** Short title */
+    title: string;
+    /** Detailed description */
+    description: string;
+    /** Affected field if applicable */
+    affectedField?: string;
+    /** IDs of affected records */
+    affectedRecordIds?: string[];
+    /** Confidence score 0-1 */
+    confidence: number;
+    /** Batch ID if from batch analysis */
+    batchId?: string;
+}
+/**
+ * Anomaly insight created event payload.
+ * Matches the format published by process_anomaly_events.ts
+ */
+export interface RealtimeAnomalyInsightEvent {
+    /** Event type */
+    event: 'anomaly_insight_created';
+    /** Workspace slug */
+    workspaceSlug: string;
+    /** Record slug (structure slug for filtering) */
+    recordSlug: string;
+    /** Record ID (insight ID for tracking) */
+    recordId: string;
+    /** ISO timestamp */
+    timestamp: string;
+    /** Anomaly insight data */
+    data: AnomalyInsightData;
+}
+/**
+ * Anomaly detection batch data nested in the event.
+ */
+export interface AnomalyDetectionData {
+    /** Structure ID */
+    structureId: string;
+    /** Structure slug */
+    structureSlug: string;
+    /** Batch ID */
+    batchId: string;
+    /** Number of insights created */
+    insightsCreated: number;
+    /** Number of records analyzed */
+    recordsAnalyzed: number;
+    /** Types of analysis performed */
+    analysisTypes: string[];
+    /** Count of critical severity insights */
+    criticalCount: number;
+    /** Count of warning severity insights */
+    warningCount: number;
+    /** Count of info severity insights */
+    infoCount: number;
+    /** When analysis started */
+    startedAt: string;
+    /** When analysis completed */
+    completedAt: string;
+}
+/**
+ * Anomaly detection completed event payload.
+ * Matches the format published by process_anomaly_events.ts
+ */
+export interface RealtimeAnomalyDetectionEvent {
+    /** Event type */
+    event: 'anomaly_detection_completed';
+    /** Workspace slug */
+    workspaceSlug: string;
+    /** Record slug (structure slug for filtering) */
+    recordSlug: string;
+    /** Record ID (batch ID for tracking) */
+    recordId: string;
+    /** ISO timestamp */
+    timestamp: string;
+    /** Anomaly detection data */
+    data: AnomalyDetectionData;
+}
+/**
+ * Function run error details.
+ */
+export interface FunctionRunError {
+    /** Error message */
+    message: string;
+    /** Error code */
+    code?: string;
+    /** Stack trace */
+    stack?: string;
+}
+/**
+ * Memory usage metrics from function execution.
+ */
+export interface FunctionMemoryUsage {
+    /** Heap memory used in bytes */
+    heapUsed: number;
+    /** Resident set size in bytes */
+    rss: number;
+}
+/**
+ * Compute function run event payload.
+ * Matches the format published by handle_function_run_events.ts
+ */
+export interface RealtimeFunctionRunEvent {
+    /** Event type */
+    event: ComputeEventType;
+    /** Workspace slug */
+    workspaceSlug: string;
+    /** Unique job identifier (returned from execute call) */
+    jobId: string;
+    /** Function run record ID */
+    runId: string;
+    /** Trigger that initiated the run */
+    triggerId: string;
+    /** Function that was executed */
+    functionId: string;
+    /** Trigger type: on-demand, event-driven, scheduled, http-trigger */
+    triggerType: 'on-demand' | 'event-driven' | 'scheduled' | 'http-trigger';
+    /** Execution status */
+    status: 'completed' | 'failure';
+    /** Function return value (if completed) */
+    outputs?: unknown;
+    /** Error details (if failed) */
+    error?: FunctionRunError;
+    /** Execution time in milliseconds */
+    duration: number;
+    /** Memory usage metrics */
+    memoryUsage?: FunctionMemoryUsage;
+    /** User who triggered the run */
+    userId: string;
+    /** ISO timestamp when the function completed */
+    timestamp: string;
+}
+/**
+ * Orchestration failure reason details.
+ */
+export interface OrchestrationFailureReason {
+    /** Error code (e.g., "STEP_EXECUTION_FAILED") */
+    code: string;
+    /** Human-readable error message */
+    message: string;
+    /** ID of the step that failed */
+    stepId?: string;
+}
+/**
+ * Orchestration run event payload from the realtime service.
+ * Matches: services/backend/realtime/internal/redis/message.go OrchestrationRunEvent
+ */
+export interface RealtimeOrchestrationRunEvent {
+    /** Event type */
+    event: OrchestrationEventType;
+    /** Workspace slug */
+    workspaceSlug: string;
+    /** Orchestration run ID */
+    runId: string;
+    /** Orchestration definition ID */
+    orchestrationId: string;
+    /** Orchestration name */
+    orchestrationName: string;
+    /** Trigger type: on-demand, event-driven, scheduled, http-trigger */
+    triggerType: 'on-demand' | 'event-driven' | 'scheduled' | 'http-trigger';
+    /** Outputs from completed steps (for completed/failed events) */
+    stepOutputs?: Record<string, unknown>;
+    /** Execution time in milliseconds (for completed/failed events) */
+    duration?: number;
+    /** Failure details (for failed events only) */
+    failureReason?: OrchestrationFailureReason;
+    /** ISO timestamp when the event occurred */
+    timestamp: string;
+}
+/**
+ * Close event payload from the realtime service.
+ */
+export interface RealtimeCloseEvent {
+    /** Reason for the close */
+    reason: string;
+    /** Whether the client should attempt to reconnect */
+    reconnect: boolean;
+}
+/**
+ * Union type of all realtime events.
+ */
+export type RealtimeEvent = RealtimeRecordEvent | RealtimeValidationSuggestionEvent | RealtimeValidationBatchEvent | RealtimeAnomalyInsightEvent | RealtimeAnomalyDetectionEvent | RealtimeFunctionRunEvent | RealtimeOrchestrationRunEvent;
+/**
+ * Error object for realtime connection errors.
+ */
+export interface RealtimeError {
+    /** Error code from the server */
+    code: 'MISSING_TOKEN' | 'TOKEN_EXPIRED' | 'WORKSPACE_MISMATCH' | 'INVALID_TOKEN' | 'FORBIDDEN' | 'AUTH_ERROR' | 'RATE_LIMIT_EXCEEDED' | 'CONNECTION_ERROR' | 'PARSE_ERROR';
+    /** Human-readable error message */
+    message: string;
+    /** Whether the error is recoverable (client should retry) */
+    recoverable: boolean;
+}
+/**
+ * Options for subscribing to realtime events.
+ */
+export interface RealtimeSubscribeOptions {
+    /** Structure recordSlugs to filter events (e.g., ["order", "customer"]). Empty = all structures */
+    structures?: string[];
+    /** Collection recordSlugs to filter events (e.g., ["order", "customer"]). Empty = all collections */
+    collections?: string[];
+    /** Event types to filter (e.g., ["record_created"]). Empty = all events */
+    events?: RealtimeEventType[];
+    /** CFL (Centrali Filter Language) expression for data filtering (e.g., "status = 'active'") */
+    filter?: string;
+    /** Filter compute events to a specific job ID (only affects function_run_* events) */
+    jobId?: string;
+    /** Filter compute events by trigger type: on-demand, event-driven, scheduled, http-trigger */
+    triggerType?: 'on-demand' | 'event-driven' | 'scheduled' | 'http-trigger';
+    /** Filter compute events to a specific function ID */
+    functionId?: string;
+    /** Filter orchestration events to a specific orchestration ID */
+    orchestrationId?: string;
+    /** Filter orchestration events to a specific run ID */
+    runId?: string;
+    /** Callback for record events */
+    onEvent: (event: RealtimeEvent) => void;
+    /** Callback for errors */
+    onError?: (error: RealtimeError) => void;
+    /** Callback when connected */
+    onConnected?: () => void;
+    /** Callback when disconnected */
+    onDisconnected?: (reason?: string) => void;
+}
+/**
+ * Realtime subscription handle returned by subscribe().
+ */
+export interface RealtimeSubscription {
+    /** Unsubscribe and close the connection */
+    unsubscribe: () => void;
+    /** Whether the connection is currently open */
+    readonly connected: boolean;
+}
+/**
+ * Internal configuration for realtime connections.
+ */
+interface RealtimeConfig {
+    /** Maximum reconnection attempts (default: 10) */
+    maxReconnectAttempts: number;
+    /** Initial reconnect delay in ms (default: 1000) */
+    initialReconnectDelayMs: number;
+    /** Maximum reconnect delay in ms (default: 30000) */
+    maxReconnectDelayMs: number;
+}
+/**
+ * Options for initializing the Centrali SDK client.
+ */
+export interface CentraliSDKOptions {
+    /** Base URL of Centrali (e.g. https://centrali.io). The SDK automatically uses api.centrali.io for API calls. */
+    baseUrl: string;
+    workspaceId: string;
+    /** Publishable key for frontend access. Sent as x-api-key header. No token refresh needed. */
+    publishableKey?: string;
+    /** Optional initial bearer token for authentication */
+    token?: string;
+    /** Optional callback to dynamically fetch a fresh token before each request (e.g., for Clerk, Auth0) */
+    getToken?: () => Promise<string>;
+    /** Optional OAuth2 client credentials */
+    clientId?: string;
+    clientSecret?: string;
+    /** Optional custom axios config */
+    axiosConfig?: AxiosRequestConfig;
+}
+/**
+ * Generic API response wrapper.
+ */
+export interface ApiResponse<T> {
+    data: T;
+    meta?: Record<string, any>;
+    error?: any;
+    id?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/**
+ * Resource category for authorization.
+ * - 'workspace': Workspace-level resources (e.g., settings, members)
+ * - 'structure': Structure-level resources (e.g., specific records)
+ * - 'custom': Custom resources defined by the user for AuthZ-as-a-Service
+ */
+export type ResourceCategory = 'workspace' | 'structure' | 'custom';
+/**
+ * Options for authorization check.
+ * Use this when authorizing access using an external IdP token (BYOT).
+ */
+export interface CheckAuthorizationOptions {
+    /**
+     * The JWT token from your external identity provider (e.g., Clerk, Auth0, Okta).
+     * The token will be validated against the configured external auth provider.
+     */
+    token: string;
+    /**
+     * The resource being accessed.
+     * Can be a Centrali system resource (e.g., 'records', 'files') or a custom
+     * resource you've defined for AuthZ-as-a-Service (e.g., 'orders', 'invoices').
+     */
+    resource: string;
+    /**
+     * The action being performed on the resource.
+     * Common actions: 'create', 'read', 'update', 'delete', 'admin'
+     * You can also define custom actions (e.g., 'approve', 'publish').
+     */
+    action: string;
+    /**
+     * Resource category for authorization evaluation.
+     * - 'workspace': Workspace-level resources
+     * - 'structure': Structure-level resources
+     * - 'custom': Custom resources for AuthZ-as-a-Service
+     * @default 'custom'
+     */
+    resourceCategory?: ResourceCategory;
+    /**
+     * Optional context data for policy evaluation.
+     * This data becomes available as `request_metadata` in policies.
+     *
+     * @example
+     * // Policy can reference: request_metadata.orderId, request_metadata.amount
+     * context: {
+     *   orderId: 'order-123',
+     *   amount: 50000,
+     *   department: 'sales'
+     * }
+     */
+    context?: Record<string, unknown>;
+}
+/**
+ * Result of an authorization check.
+ */
+export interface AuthorizationResult {
+    /**
+     * Whether the action is allowed.
+     */
+    allowed: boolean;
+    /**
+     * The decision from the policy evaluator.
+     * - 'allow': Access granted
+     * - 'deny': Access denied
+     * - 'not_applicable': No matching policy found
+     */
+    decision: 'allow' | 'deny' | 'not_applicable';
+    /**
+     * Human-readable message explaining the decision.
+     */
+    message?: string;
+}
+/**
+ * Trigger execution types supported by Centrali.
+ */
+export type TriggerExecutionType = 'on-demand' | 'event-driven' | 'scheduled' | 'http-trigger';
+/**
+ * Function trigger definition.
+ */
+export interface FunctionTrigger {
+    id: string;
+    name: string;
+    description?: string;
+    workspaceSlug: string;
+    functionId: string;
+    executionType: TriggerExecutionType;
+    triggerMetadata: Record<string, any>;
+    schedulerJobId?: string;
+    enabled: boolean;
+    createdBy: string;
+    updatedBy: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/**
+ * Options for invoking an on-demand trigger.
+ */
+export interface InvokeTriggerOptions {
+    /** Custom payload/parameters to pass to the trigger execution */
+    payload?: Record<string, any>;
+}
+/**
+ * Options for invoking a synchronous compute endpoint.
+ */
+export interface InvokeEndpointOptions {
+    /** HTTP method (default: 'POST'). Must be in the trigger's allowedMethods. */
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    /** Request body payload (sent as JSON). Ignored for GET/DELETE. */
+    payload?: Record<string, any>;
+    /** Additional request headers (e.g., X-API-Key for apiKey auth). */
+    headers?: Record<string, string>;
+    /** Query string parameters. */
+    query?: Record<string, string>;
+}
+/**
+ * Response from a synchronous compute endpoint invocation.
+ */
+export interface EndpointResponse<T = any> {
+    /** HTTP status code from the compute function */
+    status: number;
+    /** Response body from the compute function */
+    data: T;
+    /** Response headers */
+    headers: Record<string, string>;
+}
+/**
+ * Options for deleting a record.
+ */
+export interface DeleteRecordOptions {
+    /** Perform a hard delete (permanent). Default: false (soft delete) */
+    hard?: boolean;
+}
+/**
+ * Options for setting TTL (Time-To-Live) on a record.
+ */
+export interface RecordTtlOptions {
+    /** TTL in seconds. Record expires after this duration. */
+    ttlSeconds?: number;
+    /** Explicit expiration timestamp (ISO 8601 string). */
+    expiresAt?: string;
+    /** Set to true to remove TTL and make record permanent. Only valid on update. */
+    clearTtl?: boolean;
+}
+/**
+ * An allowed domain entry for compute function external calls.
+ */
+export interface AllowedDomain {
+    id: string;
+    domain: string;
+    createdAt: string;
+    createdBy: string;
+}
+/**
+ * Response from listing allowed domains.
+ */
+export interface AllowedDomainsListResponse {
+    data: AllowedDomain[];
+    meta: {
+        total: number;
+    };
+}
+/**
+ * Options for adding an allowed domain.
+ */
+export interface AddAllowedDomainOptions {
+    /** The domain to allow (e.g., 'api.example.com'). No protocol prefix. */
+    domain: string;
+}
+/**
+ * Options for expanding reference fields when fetching records.
+ * Expanded data is placed in the `_expanded` object within the record's data.
+ */
+export interface ExpandOptions {
+    /**
+     * Comma-separated list of reference fields to expand.
+     * Supports nested expansion using dot notation (up to 3 levels deep).
+     *
+     * @example
+     * // Single field
+     * expand: 'customer'
+     *
+     * // Multiple fields
+     * expand: 'customer,product'
+     *
+     * // Nested expansion
+     * expand: 'customer,customer.address'
+     */
+    expand?: string;
+}
+/**
+ * Options for retrieving a single record.
+ */
+export interface GetRecordOptions extends ExpandOptions {
+}
+/**
+ * Filter operators for querying records.
+ * Pass filters at the TOP LEVEL of query params (not nested under 'filter').
+ * Use bracket notation for operators: 'data.field[operator]': value
+ *
+ * @example
+ * // Simple equality - just use the field name
+ * { 'data.status': 'active' }
+ *
+ * // With operators - use bracket notation
+ * { 'data.age[gte]': 18, 'data.age[lte]': 65 }
+ * { 'data.status[in]': 'pending,processing' }  // comma-separated for 'in'
+ * { 'data.email[contains]': '@gmail.com' }
+ */
+export interface FilterOperators {
+    /** Equal to (default if just a value is provided) */
+    eq?: string | number | boolean;
+    /** Not equal to */
+    ne?: string | number | boolean;
+    /** Greater than */
+    gt?: number | string;
+    /** Greater than or equal to */
+    gte?: number | string;
+    /** Less than */
+    lt?: number | string;
+    /** Less than or equal to */
+    lte?: number | string;
+    /** Value is in the provided array */
+    in?: (string | number)[];
+    /** Value is not in the provided array */
+    nin?: (string | number)[];
+    /** String contains substring (case-insensitive) */
+    contains?: string;
+    /** String starts with (case-insensitive) */
+    startswith?: string;
+    /** String ends with (case-insensitive) */
+    endswith?: string;
+    /** Array field contains any of the provided values */
+    hasAny?: (string | number)[];
+    /** Array field contains all of the provided values */
+    hasAll?: (string | number)[];
+}
+/**
+ * Filter value can be a direct value or an object with operators.
+ */
+export type FilterValue = string | number | boolean | null | FilterOperators;
+/**
+ * Date range filter for restricting results to a time window.
+ *
+ * @example
+ * // Records created in the last 30 days
+ * { field: 'createdAt', from: '2024-01-01T00:00:00Z' }
+ *
+ * // Records updated in a specific range
+ * { field: 'updatedAt', from: '2024-01-01T00:00:00Z', to: '2024-03-31T23:59:59Z' }
+ */
+export interface DateWindowOption {
+    /** The date field to filter on (e.g., 'createdAt', 'updatedAt', or a custom date field) */
+    field: string;
+    /** ISO 8601 date string — lower bound (inclusive, gte) */
+    from?: string;
+    /** ISO 8601 date string — upper bound (inclusive, lte) */
+    to?: string;
+}
+/**
+ * Options for querying records.
+ *
+ * Supports two filter styles:
+ *
+ * **Style 1 — Top-level filters (recommended for SDK):**
+ * Pass filter fields directly as top-level keys with `data.` prefix and bracket notation.
+ * ```ts
+ * { 'data.status': 'active', 'data.price[lte]': 100, pageSize: 10 }
+ * ```
+ *
+ * **Style 2 — Nested filter object (same syntax as compute functions):**
+ * Wrap filters in a `filter` object. Useful if you prefer the same syntax as `api.queryRecords` in compute functions.
+ * ```ts
+ * { filter: { 'data.status': 'active', 'data.price': { lte: 100 } }, pageSize: 10 }
+ * ```
+ *
+ * Both styles are supported and can be mixed. Use `data.` prefix for custom fields.
+ * System fields (`id`, `createdAt`, `updatedAt`, `status`) don't need the prefix.
+ *
+ * @example
+ * // Top-level filters with bracket notation
+ * { 'data.status': 'active', 'data.age[gte]': 18, sort: '-createdAt' }
+ *
+ * // Nested filter object
+ * { filter: { 'data.status': 'active', 'data.age': { gte: 18 } }, sort: '-createdAt' }
+ *
+ * // Date window
+ * { dateWindow: { field: 'createdAt', from: '2024-01-01T00:00:00Z' }, sort: '-createdAt' }
+ */
+export interface QueryRecordOptions extends ExpandOptions {
+    /**
+     * Structured filter object. Wrap your field filters here as an alternative to top-level keys.
+     * Uses the same syntax as compute function `api.queryRecords`.
+     *
+     * @example
+     * { filter: { 'data.status': 'active', 'data.age': { gte: 18 } } }
+     */
+    filter?: Record<string, any>;
+    /** Sort field with optional direction prefix (e.g., '-createdAt' for descending) */
+    sort?: string;
+    /** Page number (1-indexed, default: 1) */
+    page?: number;
+    /** Number of records per page (default: 50, max: 500) */
+    pageSize?: number;
+    /** Alias for pageSize */
+    limit?: number;
+    /** Include soft-deleted records */
+    includeDeleted?: boolean;
+    /** Include archived (soft-deleted) records. Alias for includeDeleted. */
+    includeArchived?: boolean;
+    /** Shorthand for includeDeleted (from HTTP query params) */
+    all?: boolean;
+    /** Include total count in response metadata */
+    includeTotal?: boolean;
+    /** Search query string */
+    search?: string;
+    /** Field(s) to search in (comma-separated or single field) */
+    searchField?: string;
+    /** Fields to search in (array format) */
+    searchFields?: string[];
+    /**
+     * Date range filter. Restricts results to records where the specified date field
+     * falls within the given range.
+     *
+     * @example
+     * { dateWindow: { field: 'createdAt', from: '2024-01-01T00:00:00Z', to: '2024-12-31T23:59:59Z' } }
+     */
+    dateWindow?: DateWindowOption;
+    /** Comma-separated fields to return (field selection) */
+    fields?: string;
+    /** Field selection (alias for fields) */
+    select?: string[];
+    /**
+     * Additional filter fields — pass at TOP LEVEL with 'data.' prefix for custom fields.
+     * Use bracket notation for operators: 'data.field[operator]': value
+     *
+     * Supported operators: eq, ne, gt, gte, lt, lte, in, nin, contains, startswith, endswith, hasAny, hasAll
+     */
+    [key: string]: any;
+}
+/**
+ * Response from invoking a trigger.
+ * Currently the API returns the queued job ID as a string.
+ */
+export type TriggerInvokeResponse = string;
+/**
+ * Orchestration trigger types.
+ */
+export type OrchestrationTriggerType = 'event-driven' | 'scheduled' | 'on-demand' | 'http-trigger';
+/**
+ * Schedule types for scheduled orchestrations.
+ */
+export type OrchestrationScheduleType = 'interval' | 'cron' | 'once';
+/**
+ * Orchestration lifecycle status.
+ */
+export type OrchestrationStatus = 'draft' | 'active' | 'paused';
+/**
+ * Orchestration run status.
+ */
+export type OrchestrationRunStatus = 'pending' | 'running' | 'waiting' | 'completed' | 'failed';
+/**
+ * Orchestration step types.
+ */
+export type OrchestrationStepType = 'compute' | 'decision' | 'delay';
+/**
+ * Run step status.
+ */
+export type OrchestrationStepStatus = 'pending' | 'running' | 'waiting' | 'succeeded' | 'failed';
+/**
+ * Condition operators for decision steps.
+ */
+export type ConditionOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'exists' | 'notExists' | 'in' | 'notIn';
+/**
+ * Orchestration trigger configuration.
+ */
+export interface OrchestrationTrigger {
+    /** Trigger type */
+    type: OrchestrationTriggerType;
+    /** Event type for event-driven triggers */
+    eventType?: string;
+    /** Structure slug to watch */
+    structureSlug?: string;
+    /** Schedule type for scheduled triggers */
+    scheduleType?: OrchestrationScheduleType;
+    /** Interval in seconds (for interval type) */
+    interval?: number;
+    /** Cron expression (for cron type) */
+    cronExpression?: string;
+    /** ISO datetime (for once type) */
+    scheduledAt?: string;
+    /** IANA timezone (default: UTC) */
+    timezone?: string;
+    /** Webhook path */
+    path?: string;
+    /** Whether to validate HMAC signature */
+    validateSignature?: boolean;
+    /** Signing secret for HMAC validation */
+    signingSecret?: string;
+    /** Header name for signature */
+    signatureHeaderName?: string;
+    /** Header name for message ID */
+    signatureIdHeaderName?: string;
+    /** Header name for timestamp (separate header format) */
+    timestampHeaderName?: string;
+    /** Regex to extract timestamp from signature header (compound format, e.g. Stripe) */
+    timestampExtractionPattern?: string;
+    /** HMAC algorithm (default: sha256) */
+    hmacAlgorithm?: string;
+    /** HMAC digest encoding (default: base64) */
+    hmacEncoding?: string;
+    /** Regex to extract signature value from header */
+    extractionPattern?: string;
+    /** Secret key encoding after prefix split (default: base64) */
+    encoding?: string;
+    /** How to derive HMAC key: 'raw' uses full string as UTF-8 (Stripe), 'prefixed-base64' strips prefix before _ and base64-decodes (Svix) */
+    secretEncoding?: 'raw' | 'prefixed-base64';
+}
+/**
+ * Retry configuration for compute steps.
+ */
+export interface OrchestrationRetryConfig {
+    /** Maximum retry attempts */
+    maxAttempts: number;
+    /** Backoff delay in milliseconds */
+    backoffMs: number;
+}
+/**
+ * On success configuration for compute steps.
+ */
+export interface OrchestrationOnSuccess {
+    /** Next step ID to execute on success */
+    nextStepId?: string;
+}
+/**
+ * On failure configuration for compute steps.
+ */
+export interface OrchestrationOnFailure {
+    /** Action to take on failure: 'fail' or 'end' */
+    action: 'fail' | 'end';
+}
+/**
+ * Condition in a decision case.
+ */
+export interface OrchestrationCondition {
+    /** Path to evaluate (e.g., 'input.data.status', 'steps.validate.output.isValid') */
+    path: string;
+    /** Comparison operator */
+    op: ConditionOperator;
+    /** Static value to compare against */
+    value?: unknown;
+    /** Path to dynamic value to compare against (alternative to value) */
+    valuePath?: string;
+}
+/**
+ * Decision case in a decision step.
+ */
+export interface OrchestrationDecisionCase {
+    /** Conditions to evaluate (AND logic) */
+    conditions: OrchestrationCondition[];
+    /** Next step ID if conditions match */
+    nextStepId: string;
+}
+/**
+ * Encrypted parameter for a compute step. To encrypt a new value, set encrypt=true and value=plaintext.
+ * Stored values have encrypted=true and value is masked in API responses.
+ */
+export interface StepEncryptedParam {
+    /** The parameter value (plaintext on create, masked as "********" on read) */
+    value: string;
+    /** True when the value is encrypted at rest */
+    encrypted?: boolean;
+    /** Encryption key version (for key rotation support) */
+    keyVersion?: number;
+    /** Client flag: set to true to encrypt this plaintext value */
+    encrypt?: boolean;
+}
+/**
+ * Orchestration step definition.
+ */
+export interface OrchestrationStep {
+    /** Unique step identifier */
+    id: string;
+    /** Human-readable step name */
+    name?: string;
+    /** Step type */
+    type: OrchestrationStepType;
+    /** Function ID to execute (for compute steps) */
+    functionId?: string;
+    /** Timeout in milliseconds (for compute steps) */
+    timeoutMs?: number;
+    /** Retry configuration (for compute steps) */
+    retry?: OrchestrationRetryConfig;
+    /** On success handler (for compute steps) */
+    onSuccess?: OrchestrationOnSuccess;
+    /** On failure handler (for compute steps) */
+    onFailure?: OrchestrationOnFailure;
+    /** Encrypted parameters for compute steps. Secrets are encrypted at rest and decrypted at execution time. */
+    encryptedParams?: Record<string, StepEncryptedParam>;
+    /** Decision cases (for decision steps) */
+    cases?: OrchestrationDecisionCase[];
+    /** Default next step if no case matches (for decision steps) */
+    defaultNextStepId?: string;
+    /** Delay duration in milliseconds (for delay steps) */
+    delayMs?: number;
+    /** Next step ID (for delay steps) */
+    nextStepId?: string;
+}
+/**
+ * Orchestration definition.
+ */
+export interface Orchestration {
+    /** Unique identifier */
+    id: string;
+    /** Workspace slug */
+    workspaceSlug: string;
+    /** URL-friendly slug */
+    slug: string;
+    /** Human-readable name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Version number (increments on update) */
+    version: number;
+    /** Lifecycle status */
+    status: OrchestrationStatus;
+    /** Trigger configuration */
+    trigger: OrchestrationTrigger;
+    /** Workflow steps */
+    steps: OrchestrationStep[];
+    /** ISO timestamp of creation */
+    createdAt: string;
+    /** User who created the orchestration */
+    createdBy: string;
+    /** ISO timestamp of last update */
+    updatedAt: string;
+    /** User who last updated the orchestration */
+    updatedBy: string;
+}
+/**
+ * Input for creating an orchestration.
+ */
+export interface CreateOrchestrationInput {
+    /** URL-friendly slug (unique within workspace) */
+    slug: string;
+    /** Human-readable name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Trigger configuration */
+    trigger: OrchestrationTrigger;
+    /** Workflow steps */
+    steps: OrchestrationStep[];
+}
+/**
+ * Input for updating an orchestration.
+ */
+export interface UpdateOrchestrationInput {
+    /** Updated name */
+    name?: string;
+    /** Updated description */
+    description?: string;
+    /** Updated status */
+    status?: OrchestrationStatus;
+    /** Updated trigger configuration */
+    trigger?: OrchestrationTrigger;
+    /** Updated workflow steps */
+    steps?: OrchestrationStep[];
+}
+/**
+ * Trigger metadata for a run.
+ */
+export interface OrchestrationTriggerMetadata {
+    /** Event type (for event-driven triggers) */
+    eventType?: string;
+    /** Schedule ID (for scheduled triggers) */
+    scheduleId?: string;
+    /** Principal ID who initiated the run (for manual triggers) */
+    initiatedByPrincipalId?: string;
+    /** Webhook path (for HTTP triggers) */
+    webhookPath?: string;
+}
+/**
+ * Orchestration run instance.
+ */
+export interface OrchestrationRun {
+    /** Unique run identifier */
+    id: string;
+    /** Parent orchestration ID */
+    orchestrationId: string;
+    /** Orchestration version at time of run */
+    orchestrationVersion: number;
+    /** Workspace slug */
+    workspaceSlug: string;
+    /** Run status */
+    status: OrchestrationRunStatus;
+    /** Current step being executed */
+    currentStepId?: string;
+    /** Input data that triggered the run */
+    input: Record<string, unknown>;
+    /** Shared context across steps */
+    context: Record<string, unknown>;
+    /** Outputs from completed steps */
+    stepOutputs: Record<string, unknown>;
+    /** Correlation ID for tracing */
+    correlationId?: string;
+    /** How the run was triggered */
+    triggerType: OrchestrationTriggerType;
+    /** Trigger-specific metadata */
+    triggerMetadata?: OrchestrationTriggerMetadata;
+    /** Whether any step has errors */
+    hasErrors: boolean;
+    /** Number of delay steps encountered */
+    delayStepCount: number;
+    /** Reason for failure (if failed) */
+    failureReason?: string;
+    /** ISO timestamp when run started */
+    startedAt: string;
+    /** ISO timestamp when run completed */
+    completedAt?: string;
+    /** ISO timestamp when run data expires */
+    ttlExpiresAt: string;
+}
+/**
+ * Decision result from a decision step.
+ */
+export interface OrchestrationDecisionResult {
+    /** Number of cases evaluated */
+    evaluatedCases: number;
+    /** Index of matched case (null if default) */
+    matchedCaseIndex?: number;
+    /** Selected next step ID */
+    selectedNextStepId: string;
+    /** Detailed evaluation of each case */
+    evaluations?: OrchestrationCaseEvaluation[];
+}
+/**
+ * Evaluation result for a single decision case.
+ */
+export interface OrchestrationCaseEvaluation {
+    /** Case index */
+    caseIndex: number;
+    /** Next step ID for this case */
+    nextStepId: string;
+    /** Condition evaluations */
+    conditions: OrchestrationConditionEvaluation[];
+    /** Whether this case matched */
+    matched: boolean;
+}
+/**
+ * Evaluation result for a single condition.
+ */
+export interface OrchestrationConditionEvaluation {
+    /** Path that was evaluated */
+    path: string;
+    /** Operator used */
+    operator: string;
+    /** Expected value */
+    expectedValue?: unknown;
+    /** Value path (if comparing against another path) */
+    valuePath?: string;
+    /** Actual value found at path */
+    actualValue?: unknown;
+    /** Whether the path exists */
+    pathExists: boolean;
+    /** Whether condition matched */
+    matched: boolean;
+    /** Error message if evaluation failed */
+    error?: string;
+}
+/**
+ * Delay configuration result from a delay step.
+ */
+export interface OrchestrationDelayConfig {
+    /** Delay duration in milliseconds */
+    delayMs: number;
+    /** ISO timestamp when step will resume */
+    resumeAt: string;
+    /** ISO timestamp when step actually resumed */
+    resumedAt?: string;
+}
+/**
+ * Error information from a failed step.
+ */
+export interface OrchestrationStepError {
+    /** Error message */
+    message: string;
+    /** Error code */
+    code?: string;
+    /** Stack trace */
+    stack?: string;
+}
+/**
+ * Run step execution record.
+ */
+export interface OrchestrationRunStep {
+    /** Unique step execution identifier */
+    id: string;
+    /** Parent run ID */
+    orchestrationRunId: string;
+    /** Step ID from orchestration definition */
+    stepId: string;
+    /** Step type */
+    stepType: OrchestrationStepType;
+    /** Attempt number (for retries) */
+    attempt: number;
+    /** Step execution status */
+    status: OrchestrationStepStatus;
+    /** Input data for this step */
+    input?: Record<string, unknown>;
+    /** Output data from this step */
+    output?: Record<string, unknown>;
+    /** Decision result (for decision steps) */
+    decisionResult?: OrchestrationDecisionResult;
+    /** Delay configuration (for delay steps) */
+    delayConfig?: OrchestrationDelayConfig;
+    /** Error information (if failed) */
+    error?: OrchestrationStepError;
+    /** ISO timestamp when step started */
+    startedAt?: string;
+    /** ISO timestamp when step completed */
+    completedAt?: string;
+    /** Compute gateway execution ID (for logs) */
+    executionId?: string;
+    /** Function run ID (for UI linking) */
+    functionRunId?: string;
+    /** Function ID that was executed */
+    functionId?: string;
+}
+/**
+ * Options for triggering an orchestration run.
+ */
+export interface TriggerOrchestrationRunOptions {
+    /** Input data for the run */
+    input?: Record<string, unknown>;
+    /** Correlation ID for tracing */
+    correlationId?: string;
+}
+/**
+ * Options for listing orchestrations.
+ */
+export interface ListOrchestrationsOptions {
+    /** Number of items per page (default: 20, max: 100) */
+    limit?: number;
+    /** Number of items to skip */
+    offset?: number;
+    /** Filter by status */
+    status?: OrchestrationStatus;
+}
+/**
+ * Options for listing orchestration runs.
+ */
+export interface ListOrchestrationRunsOptions {
+    /** Number of items per page (default: 20, max: 100) */
+    limit?: number;
+    /** Number of items to skip */
+    offset?: number;
+    /** Filter by run status */
+    status?: OrchestrationRunStatus;
+}
+/**
+ * Paginated response wrapper.
+ */
+export interface PaginatedResponse<T> {
+    /** Data items */
+    data: T[];
+    /** Pagination metadata */
+    meta: {
+        /** Total number of items */
+        total: number;
+        /** Current page number */
+        page: number;
+        /** Items per page */
+        pageSize: number;
+    };
+}
+/**
+ * Smart query definition stored in the database.
+ */
+export interface SmartQuery {
+    /** Unique identifier (UUID) */
+    id: string;
+    /** Workspace slug where the query belongs */
+    workspaceSlug: string;
+    /** Structure's record slug (e.g., "employee") */
+    recordSlug: string;
+    /** Human-readable name (unique within workspace) */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Query definition object */
+    queryDefinition: SmartQueryDefinition;
+    /** Status (active, archived) */
+    status: string;
+    /** User ID who created the query */
+    createdBy: string;
+    /** User ID who last updated the query */
+    updatedBy: string;
+    /** ISO timestamp of creation */
+    createdAt: string;
+    /** ISO timestamp of last update */
+    updatedAt: string;
+}
+/**
+ * Query definition format for smart queries.
+ * Supports filtering, selection, joins, sorting, and pagination.
+ */
+export interface SmartQueryDefinition {
+    /** Fields to select from the structure */
+    select?: string[];
+    /** Filter conditions */
+    where?: SmartQueryWhereClause;
+    /** Join to another structure */
+    join?: SmartQueryJoin;
+    /** Sorting specification */
+    sort?: SmartQuerySort[];
+    /** Maximum number of results */
+    limit?: number;
+    /** Number of results to skip */
+    skip?: number;
+}
+/**
+ * Where clause for smart query filtering.
+ * Supports comparison operators and logical operators.
+ */
+export interface SmartQueryWhereClause {
+    /** Field-level conditions */
+    [field: string]: SmartQueryFieldCondition | SmartQueryWhereClause[] | undefined;
+    /** Logical AND of multiple conditions */
+    $and?: SmartQueryWhereClause[];
+    /** Logical OR of multiple conditions */
+    $or?: SmartQueryWhereClause[];
+}
+/**
+ * Field-level condition operators for smart query filtering.
+ */
+export interface SmartQueryFieldCondition {
+    /** Equality */
+    $eq?: any;
+    /** Not equal */
+    $ne?: any;
+    /** Greater than */
+    $gt?: number;
+    /** Greater than or equal */
+    $gte?: number;
+    /** Less than */
+    $lt?: number;
+    /** Less than or equal */
+    $lte?: number;
+    /** String starts with */
+    $startsWith?: string;
+    /** String ends with */
+    $endsWith?: string;
+    /** String contains */
+    $contains?: string;
+    /** Regex pattern match */
+    $regex?: string;
+    /** Value in array */
+    $in?: any[];
+    /** Value not in array */
+    $nin?: any[];
+    /** Field exists check */
+    $exists?: boolean;
+    /** JSONB type check */
+    $type?: string;
+}
+/**
+ * Join definition for smart queries.
+ */
+export interface SmartQueryJoin {
+    /** Target structure slug to join */
+    foreignSlug: string;
+    /** Field in the main structure */
+    localField: string;
+    /** Field in the foreign structure */
+    foreignField: string;
+    /** Fields to select from the joined structure */
+    select?: string[];
+}
+/**
+ * Sort specification for smart queries.
+ */
+export interface SmartQuerySort {
+    /** Field to sort by */
+    field: string;
+    /** Sort direction */
+    direction: 'asc' | 'desc';
+}
+/**
+ * Options for listing smart queries.
+ */
+export interface ListSmartQueryOptions {
+    /** Page number (default: 1) */
+    page?: number;
+    /** Results per page (default: 20) */
+    limit?: number;
+    /** Search term */
+    search?: string;
+    /** Sort field */
+    sort?: string;
+    /** Sort direction */
+    sortDirection?: 'asc' | 'desc';
+}
+/**
+ * Options for executing a smart query.
+ */
+export interface ExecuteSmartQueryOptions {
+    /**
+     * Variables to substitute in the query.
+     * Use mustache-style {{variableName}} syntax in query conditions,
+     * then provide values here at execution time.
+     *
+     * @example
+     * ```ts
+     * // Query definition with variable: { where: { userId: { $eq: "{{currentUserId}}" } } }
+     * const results = await client.smartQueries.execute('orders', 'query-id', {
+     *   variables: { currentUserId: 'user_123' }
+     * });
+     * ```
+     */
+    variables?: Record<string, string>;
+}
+/**
+ * Result from executing a smart query with metadata.
+ */
+export interface SmartQueryExecuteResult<T = any> {
+    /** Query results */
+    result: T[];
+    /** Metadata about the execution */
+    meta?: {
+        /** Variables that were used in the query */
+        variablesUsed?: string[];
+    };
+}
+/**
+ * Property type identifiers for structure properties.
+ */
+export type PropertyType = 'string' | 'number' | 'boolean' | 'datetime' | 'array' | 'object' | 'reference';
+/**
+ * Schema discovery mode for a structure.
+ */
+export type SchemaDiscoveryMode = 'strict' | 'schemaless' | 'auto-evolving';
+/**
+ * Base property definition shared by all property types.
+ */
+export interface BasePropertyDefinition {
+    id?: string;
+    name: string;
+    type: PropertyType;
+    description?: string;
+    required?: boolean;
+    nullable?: boolean;
+    default?: any;
+    enum?: any[];
+    isUnique?: boolean;
+    immutable?: boolean;
+}
+/**
+ * String property definition.
+ */
+export interface StringPropertyDefinition extends BasePropertyDefinition {
+    type: 'string';
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    renderAs?: 'textarea' | 'secret' | 'color' | 'code' | 'html' | 'markdown';
+    not?: any[];
+    isSecret?: boolean;
+}
+/**
+ * Number property definition.
+ */
+export interface NumberPropertyDefinition extends BasePropertyDefinition {
+    type: 'number';
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: boolean;
+    exclusiveMaximum?: boolean;
+    multipleOf?: number;
+    expression?: string;
+    computedMode?: 'persisted' | 'virtual';
+    autoIncrement?: {
+        startAt: number;
+        incrementBy?: number;
+    };
+}
+/**
+ * Boolean property definition.
+ */
+export interface BooleanPropertyDefinition extends BasePropertyDefinition {
+    type: 'boolean';
+}
+/**
+ * DateTime property definition.
+ */
+export interface DateTimePropertyDefinition extends BasePropertyDefinition {
+    type: 'datetime';
+    earliestDate?: string;
+    latestDate?: string;
+    exclusiveEarliest?: boolean;
+    exclusiveLatest?: boolean;
+    expression?: string;
+    computedMode?: 'persisted' | 'virtual';
+}
+/**
+ * Array property definition.
+ */
+export interface ArrayPropertyDefinition extends BasePropertyDefinition {
+    type: 'array';
+    items: {
+        type: string;
+    };
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    itemSchema?: PropertyDefinition[];
+    strictProperties?: boolean;
+}
+/**
+ * Object property definition.
+ */
+export interface ObjectPropertyDefinition extends BasePropertyDefinition {
+    type: 'object';
+    properties?: PropertyDefinition[];
+    requiredProperties?: string[];
+    strictProperties?: boolean;
+}
+/**
+ * Reference property definition for foreign key-like relationships.
+ */
+export interface ReferencePropertyDefinition extends BasePropertyDefinition {
+    type: 'reference';
+    target: string;
+    targetField?: string;
+    displayField?: string;
+    relationship: 'many-to-one' | 'one-to-one' | 'many-to-many';
+    onDelete: 'restrict' | 'cascade' | 'set_null';
+}
+/**
+ * Union of all property definition types.
+ */
+export type PropertyDefinition = StringPropertyDefinition | NumberPropertyDefinition | BooleanPropertyDefinition | DateTimePropertyDefinition | ArrayPropertyDefinition | ObjectPropertyDefinition | ReferencePropertyDefinition;
+/**
+ * Full structure definition.
+ */
+export interface Structure {
+    id: string;
+    name: string;
+    workspaceSlug: string;
+    recordSlug: string;
+    description?: string;
+    properties: PropertyDefinition[];
+    defaultSearchField?: string;
+    metadata?: {
+        recordWritesLocked?: boolean;
+        structureWritesLocked?: boolean;
+        lastMigrationId?: string;
+        migrationInProgress?: boolean;
+        migrationJobId?: string;
+        migrationStartedAt?: string;
+        migrationStartedBy?: string;
+    };
+    status: 'active' | 'inactive';
+    schemaDiscoveryMode: SchemaDiscoveryMode;
+    enableVersioning: boolean;
+    isDeleted: boolean;
+    createdBy: string;
+    lastUpdatedBy: string;
+    createdAt: string;
+    updatedAt: string;
+    tags?: string[];
+}
+/**
+ * Input for creating a new structure.
+ */
+export interface CreateStructureInput {
+    name: string;
+    recordSlug: string;
+    description?: string;
+    properties?: PropertyDefinition[];
+    enableVersioning?: boolean;
+    schemaDiscoveryMode?: SchemaDiscoveryMode;
+    tags?: string[];
+}
+/**
+ * Input for updating an existing structure.
+ */
+export interface UpdateStructureInput {
+    name?: string;
+    description?: string;
+    properties?: PropertyDefinition[];
+    enableVersioning?: boolean;
+    tags?: string[];
+    /** Default TTL in seconds for new records in this structure. Set to null to clear. */
+    defaultTtlSeconds?: number | null;
+}
+/**
+ * Options for listing structures.
+ */
+export interface ListStructuresOptions {
+    page?: number;
+    limit?: number;
+}
+/**
+ * Options for listing collections (alias for ListStructuresOptions).
+ */
+export type ListCollectionsOptions = ListStructuresOptions;
+/**
+ * Input for validating a structure definition.
+ */
+export interface ValidateStructureInput {
+    name?: string;
+    slug?: string;
+    properties?: PropertyDefinition[];
+}
+/**
+ * Compute function definition.
+ */
+export interface ComputeFunction {
+    id: string;
+    name: string;
+    code: string;
+    description?: string;
+    workspaceSlug: string;
+    createdBy: string;
+    updatedBy?: string;
+    timeoutMs?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Input for creating a new compute function.
+ */
+export interface CreateComputeFunctionInput {
+    name: string;
+    code: string;
+    description?: string;
+    timeoutMs?: number;
+}
+/**
+ * Input for updating an existing compute function.
+ */
+export interface UpdateComputeFunctionInput {
+    name?: string;
+    description?: string;
+    code?: string;
+    timeoutMs?: number;
+}
+/**
+ * Options for listing compute functions.
+ */
+export interface ListComputeFunctionsOptions {
+    page?: number;
+    limit?: number;
+    search?: string;
+    searchField?: string;
+}
+/**
+ * Input for test-executing a compute function without saving.
+ */
+export interface TestComputeFunctionInput {
+    code: string;
+    params?: Record<string, any>;
+    timeoutMs?: number;
+}
+/**
+ * Result from test-executing a compute function.
+ */
+export interface TestComputeFunctionResult {
+    success: boolean;
+    output?: any;
+    duration_ms?: number;
+    logs?: string[];
+    error?: string;
+}
+/**
+ * Execution source for a function run.
+ */
+export type FunctionRunExecutionSource = 'trigger' | 'rerun' | 'manual' | 'scheduled' | 'http-trigger' | 'orchestration' | 'endpoint';
+/**
+ * Status of a function run.
+ */
+export type FunctionRunStatus = 'pending' | 'running' | 'completed' | 'failure' | 'timeout';
+/**
+ * A function run record representing a single execution of a compute function.
+ */
+export interface FunctionRun {
+    id: string;
+    createdBy: string;
+    functionId: string;
+    workspaceSlug: string;
+    jobId: string;
+    status: FunctionRunStatus;
+    runData: any | null;
+    startedAt: string;
+    endedAt?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+    executionId: string;
+    triggerId?: string | null;
+    triggerType?: string | null;
+    orchestrationRunId?: string | null;
+    orchestrationStepId?: string | null;
+    originalRunId?: string | null;
+    isRerun: boolean;
+    rerunCount: number;
+    rerunBy?: string | null;
+    rerunReason?: string | null;
+    functionCodeHash?: string | null;
+    functionVersion?: string | null;
+    executionSource: FunctionRunExecutionSource;
+    memoryUsageBytes?: number | null;
+    cpuUsageSeconds?: number | null;
+    errorCode?: string | null;
+    errorMessage?: string | null;
+    dataStrippedAt?: string | null;
+    archiveStorageAddress?: string | null;
+    archivedAt?: string | null;
+}
+/**
+ * Options for listing function runs by trigger or function.
+ */
+export interface ListFunctionRunsOptions {
+    page?: number;
+    limit?: number;
+    status?: FunctionRunStatus;
+}
+/**
+ * Status of a compute job in the execution pipeline.
+ */
+export type ComputeJobStatus = 'queued' | 'running' | 'completed' | 'failed';
+/**
+ * A compute job status response from the job status endpoint.
+ * Represents the state of an async compute execution.
+ */
+export interface ComputeJobStatusResponse {
+    jobId: string;
+    status: ComputeJobStatus;
+    returnValue?: any;
+    failedReason?: string | null;
+}
+/**
+ * Input for creating a new function trigger.
+ */
+export interface CreateTriggerInput {
+    name: string;
+    functionId: string;
+    executionType: TriggerExecutionType;
+    description?: string;
+    triggerMetadata?: Record<string, any>;
+    enabled?: boolean;
+}
+/**
+ * Input for updating an existing function trigger.
+ */
+export interface UpdateTriggerInput {
+    name?: string;
+    description?: string;
+    enabled?: boolean;
+    triggerMetadata?: Record<string, any>;
+}
+/**
+ * Options for listing all triggers (not filtered by type).
+ */
+export interface ListAllTriggersOptions {
+    page?: number;
+    limit?: number;
+    functionId?: string;
+    executionType?: TriggerExecutionType;
+    includeHealth?: boolean;
+}
+/**
+ * Health status of a trigger.
+ */
+export type TriggerHealthStatus = 'healthy' | 'warning' | 'error' | 'dead' | 'never_run' | 'paused';
+/**
+ * Health metrics for a trigger.
+ */
+export interface TriggerHealthMetrics {
+    lastRunAt: string | null;
+    successCount: number;
+    failureCount: number;
+    avgExecutionTimeMs: number;
+    totalRuns: number;
+}
+/**
+ * Trigger with health metrics included.
+ */
+export interface TriggerWithHealth extends FunctionTrigger {
+    health: TriggerHealthMetrics;
+    healthStatus: TriggerHealthStatus;
+}
+/**
+ * Input for creating a new smart query.
+ */
+export interface CreateSmartQueryInput {
+    name: string;
+    description?: string;
+    queryDefinition: SmartQueryDefinition;
+}
+/**
+ * Input for updating an existing smart query.
+ */
+export interface UpdateSmartQueryInput {
+    name?: string;
+    description?: string;
+    queryDefinition?: SmartQueryDefinition;
+}
+/**
+ * Input for test-executing a smart query definition without saving.
+ */
+export interface TestSmartQueryInput {
+    queryDefinition: SmartQueryDefinition;
+    variables?: Record<string, string>;
+}
+/**
+ * Options for searching records.
+ */
+export interface SearchOptions {
+    /** Filter by structure slug(s). Can be a single slug or array of slugs */
+    structures?: string | string[];
+    /** Filter by collection slug(s). Can be a single slug or array of slugs */
+    collections?: string | string[];
+    /** Maximum number of results to return (default: 20, max: 100) */
+    limit?: number;
+}
+/**
+ * A single search result hit.
+ */
+export interface SearchHit {
+    /** The record ID */
+    id: string;
+    /** The record slug (structure type) */
+    recordSlug: string;
+    /** The structure slug */
+    structureSlug: string;
+    /** The indexed record data */
+    [key: string]: unknown;
+}
+/**
+ * Response from a search query.
+ */
+export interface SearchResponse {
+    /** Array of matching records */
+    hits: SearchHit[];
+    /** Estimated total number of matching records */
+    totalHits: number;
+    /** Time taken to process the search in milliseconds */
+    processingTimeMs: number;
+    /** The original search query */
+    query: string;
+}
+/**
+ * Anomaly insight types.
+ */
+export type InsightType = 'time_series_anomaly' | 'statistical_outlier' | 'pattern_deviation' | 'volume_spike' | 'missing_data' | 'orphaned_reference' | 'reference_integrity';
+/**
+ * Anomaly insight severity levels.
+ */
+export type InsightSeverity = 'info' | 'warning' | 'critical';
+/**
+ * Anomaly insight status.
+ */
+export type InsightStatus = 'active' | 'acknowledged' | 'dismissed';
+/**
+ * Anomaly insight record.
+ */
+export interface AnomalyInsight {
+    /** Unique identifier */
+    id: string;
+    /** Workspace slug */
+    workspaceSlug: string;
+    /** Structure ID */
+    structureId: string;
+    /** Structure slug */
+    structureSlug: string;
+    /** Batch ID if created in batch */
+    batchId: string | null;
+    /** Type of insight */
+    insightType: InsightType;
+    /** Severity level */
+    severity: InsightSeverity;
+    /** Short title */
+    title: string;
+    /** Detailed description */
+    description: string;
+    /** Affected field if applicable */
+    affectedField: string | null;
+    /** IDs of affected records */
+    affectedRecordIds: string[] | null;
+    /** Additional metadata */
+    metadata: Record<string, any>;
+    /** Confidence score 0-1 */
+    confidence: number;
+    /** Current status */
+    status: InsightStatus;
+    /** When acknowledged */
+    acknowledgedAt: string | null;
+    /** Who acknowledged */
+    acknowledgedBy: string | null;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+/**
+ * Options for listing anomaly insights.
+ */
+export interface ListInsightsOptions {
+    /** Filter by severity */
+    severity?: InsightSeverity;
+    /** Filter by status */
+    status?: InsightStatus;
+    /** Filter by insight type */
+    type?: InsightType;
+    /** Filter by structure slug */
+    structureSlug?: string;
+    /** Maximum results */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+/**
+ * Result of triggering anomaly analysis.
+ */
+export interface AnomalyAnalysisResult {
+    /** Whether the analysis was triggered */
+    success: boolean;
+    /** Status message */
+    message: string;
+    /** Batch ID for tracking (if triggered) */
+    batchId?: string;
+}
+/**
+ * Summary of anomaly insights.
+ */
+export interface InsightsSummary {
+    /** Total insights */
+    total: number;
+    /** Active insights */
+    active: number;
+    /** Acknowledged insights */
+    acknowledged: number;
+    /** Dismissed insights */
+    dismissed: number;
+    /** Breakdown by severity */
+    bySeverity: {
+        critical: number;
+        warning: number;
+        info: number;
+    };
+    /** Breakdown by type */
+    byType: Record<string, number>;
+}
+/**
+ * Validation issue types.
+ * - 'type': Schema type mismatch (e.g., string where array expected) - rule-based
+ * - 'format': Format validation (email, phone, url patterns) - rule-based
+ * - 'typo': Spelling/typo detection - AI-based
+ * - 'duplicate': Duplicate record detection - rule-based
+ * - 'semantic': Logical/semantic issues - AI-based
+ */
+export type ValidationIssueType = 'type' | 'format' | 'typo' | 'duplicate' | 'semantic';
+/**
+ * Validation suggestion status.
+ */
+export type ValidationSuggestionStatus = 'pending' | 'accepted' | 'rejected' | 'auto-applied';
+/**
+ * A validation suggestion from the AI validation system.
+ */
+export interface ValidationSuggestion {
+    /** Unique identifier */
+    id: string;
+    /** Workspace slug */
+    workspaceSlug: string;
+    /** Structure ID */
+    structureId: string;
+    /** Record ID */
+    recordId: string;
+    /** Structure's record slug */
+    recordSlug: string;
+    /** Field name with the issue */
+    field: string;
+    /** Type of issue detected */
+    issueType: ValidationIssueType;
+    /** Original value in the field */
+    originalValue: string | null;
+    /** Suggested corrected value */
+    suggestedValue: string | null;
+    /** Confidence score 0-1 */
+    confidence: number;
+    /** Current status */
+    status: ValidationSuggestionStatus;
+    /** Batch ID if created during batch scan */
+    batchId: string | null;
+    /** Additional metadata */
+    metadata: Record<string, any>;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+    /** When resolved (accepted/rejected) */
+    resolvedAt: string | null;
+    /** Who resolved */
+    resolvedBy: string | null;
+}
+/**
+ * Options for listing validation suggestions.
+ */
+export interface ListValidationSuggestionsOptions {
+    /** Filter by structure slug (recordSlug) */
+    structureSlug?: string;
+    /** Filter by record ID */
+    recordId?: string;
+    /** Filter by status */
+    status?: ValidationSuggestionStatus;
+    /** Filter by issue type */
+    issueType?: ValidationIssueType;
+    /** Filter by batch ID */
+    batchId?: string;
+    /** Minimum confidence threshold */
+    minConfidence?: number;
+    /** Maximum results (default: 50, max: 100) */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+/**
+ * Batch scan status.
+ */
+export type BatchScanStatus = 'queued' | 'pending' | 'processing' | 'completed' | 'failed';
+/**
+ * Result from triggering a batch validation scan.
+ */
+export interface BatchScanResult {
+    /** Unique batch identifier */
+    batchId: string;
+    /** Current status */
+    status: BatchScanStatus;
+    /** Total records to scan */
+    total: number;
+    /** Records processed so far */
+    processed: number;
+    /** Issues found so far */
+    issuesFound: number;
+    /** When the scan started */
+    startedAt: string;
+    /** When the scan completed (if finished) */
+    completedAt?: string;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Options for triggering a batch scan.
+ */
+export interface TriggerScanOptions {
+    /** Validation types to run (defaults to structure config) */
+    validationTypes?: ValidationIssueType[];
+}
+/**
+ * Options for waiting for a scan to complete.
+ */
+export interface WaitForScanOptions {
+    /** Poll interval in milliseconds (default: 5000) */
+    pollInterval?: number;
+    /** Timeout in milliseconds (default: 300000 = 5 minutes) */
+    timeout?: number;
+}
+/**
+ * Summary of validation suggestions.
+ */
+export interface ValidationSummary {
+    /** Total suggestions */
+    total: number;
+    /** Pending suggestions */
+    pending: number;
+    /** Accepted suggestions */
+    accepted: number;
+    /** Rejected suggestions */
+    rejected: number;
+    /** Auto-applied suggestions */
+    autoApplied: number;
+    /** Breakdown by issue type */
+    byIssueType: Record<string, number>;
+}
+/**
+ * Result from accepting a suggestion.
+ */
+export interface AcceptSuggestionResult {
+    /** The updated suggestion */
+    suggestion: ValidationSuggestion;
+    /** Whether the record was updated */
+    recordUpdated: boolean;
+    /** Status message */
+    message: string;
+}
+/**
+ * Result from bulk operations.
+ */
+export interface BulkOperationResult {
+    /** Number of successful operations */
+    count: number;
+    /** Errors for failed operations */
+    errors?: Array<{
+        id: string;
+        error: string;
+    }>;
+    /** Status message */
+    message: string;
+}
+/**
+ * Record event name constants — use these when constructing `events` on a
+ * webhook subscription instead of hand-typing strings.
+ *
+ * @example
+ * ```ts
+ * await centrali.webhookSubscriptions.create({
+ *   name: 'Order created',
+ *   url: 'https://my-app.example.com/webhooks/centrali',
+ *   events: [RecordEvents.CREATED, RecordEvents.UPDATED],
+ * });
+ * ```
+ */
+export declare const RecordEvents: {
+    readonly CREATED: "record_created";
+    readonly UPDATED: "record_updated";
+    readonly DELETED: "record_deleted";
+    readonly BULK_CREATED: "records_bulk_created";
+};
+export type WebhookDeliveryStatus = 'success' | 'failed' | 'retrying';
+export interface WebhookSubscription {
+    id: string;
+    name: string;
+    url: string;
+    events: RecordEventType[];
+    /**
+     * Optional list of record slugs to scope the subscription to. When null or
+     * empty, the subscription receives events for all collections.
+     */
+    recordSlugs?: string[] | null;
+    active: boolean;
+    /**
+     * Signing secret (`whsec_` prefix). Returned by `create` and `rotateSecret`;
+     * undefined on subsequent reads so it is safe to pass subscriptions around.
+     */
+    secret?: string;
+    workspaceSlug: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/**
+ * Full webhook delivery record including request payload and response body.
+ * Returned by `deliveries.get()`.
+ */
+export interface WebhookDelivery {
+    id: string;
+    webhookSubscriptionId: string;
+    workspaceSlug: string;
+    event: string;
+    attemptCount: number;
+    status: WebhookDeliveryStatus;
+    lastError?: string | null;
+    httpStatus?: number | null;
+    lastAttemptAt: string;
+    nextAttemptAt?: string | null;
+    requestPayload?: any;
+    responseBody?: string | null;
+    /** Delivery ID the row was replayed from, or null for original deliveries. */
+    replayedFrom?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Trimmed delivery row returned by `deliveries.list()` — omits `requestPayload`
+ * and `responseBody`. Fetch individual deliveries with `deliveries.get()` to get
+ * the full payload and response body.
+ */
+export type WebhookDeliverySummary = Omit<WebhookDelivery, 'requestPayload' | 'responseBody'>;
+export interface CreateWebhookSubscriptionInput {
+    name: string;
+    url: string;
+    events: RecordEventType[];
+    /** Optional — restrict to a subset of collections. Omit for all collections. */
+    recordSlugs?: string[];
+    active?: boolean;
+}
+export interface UpdateWebhookSubscriptionInput {
+    name?: string;
+    url?: string;
+    events?: RecordEventType[];
+    /**
+     * Update the collection scope. Pass an empty array (`[]`) to clear the
+     * restriction so the subscription receives events for all collections.
+     * Omit the field to leave the scope unchanged.
+     */
+    recordSlugs?: string[];
+    active?: boolean;
+}
+export interface ListWebhookDeliveriesOptions {
+    status?: WebhookDeliveryStatus;
+    /** ISO 8601 datetime or Date — include deliveries created at or after this time. */
+    since?: string | Date;
+    /** ISO 8601 datetime or Date — include deliveries created at or before this time. */
+    until?: string | Date;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Pagination metadata returned alongside `deliveries.list()` rows. The backend
+ * surfaces `{ data, meta }` which the SDK normalizer passes through as the
+ * `ApiResponse` itself — so `result.data` is the array and `result.meta` is
+ * this object.
+ */
+export interface WebhookDeliveriesListMeta {
+    total: number;
+    limit: number;
+    offset: number;
+}
+export interface WebhookReplayResponse {
+    deliveryId: string;
+    replayedFrom: string | null;
+    status: WebhookDeliveryStatus;
+}
+export interface WebhookCancelResponse {
+    deliveryId: string;
+    status: WebhookDeliveryStatus;
+    lastError: string | null;
+}
+/**
+ * Generate the API URL from the base URL by adding the 'api.' subdomain.
+ * E.g., https://centrali.io -> https://api.centrali.io
+ */
+export declare function getApiUrl(baseUrl: string): string;
+/**
+ * Generate the auth server URL from the base URL.
+ * E.g., https://centrali.io -> https://auth.centrali.io
+ */
+export declare function getAuthUrl(baseUrl: string): string;
+/**
+ * Generate the realtime service URL from the base URL.
+ * E.g., https://centrali.io -> https://api.centrali.io/realtime
+ */
+export declare function getRealtimeUrl(baseUrl: string): string;
+/**
+ * RealtimeManager handles SSE connections to the Centrali Realtime Service.
+ * Provides automatic reconnection with exponential backoff.
+ *
+ * Usage:
+ * ```ts
+ * const realtime = new RealtimeManager(baseUrl, workspaceSlug, () => client.getToken());
+ * const sub = realtime.subscribe({
+ *   structures: ['order'],
+ *   events: ['record_created', 'record_updated'],
+ *   onEvent: (event) => console.log(event),
+ *   onError: (error) => console.error(error),
+ * });
+ * // Later: sub.unsubscribe();
+ * ```
+ */
+export declare class RealtimeManager {
+    private baseUrl;
+    private workspaceSlug;
+    private getToken;
+    private config;
+    constructor(baseUrl: string, workspaceSlug: string, getToken: () => string | null | Promise<string | null>, config?: Partial<RealtimeConfig>);
+    /**
+     * Subscribe to realtime events for the workspace.
+     *
+     * IMPORTANT: Initial Sync Pattern
+     * Realtime delivers only new events after connection. For dashboards and lists:
+     * 1. Fetch current records first
+     * 2. Subscribe to realtime
+     * 3. Apply diffs while UI shows the snapshot
+     *
+     * @param options - Subscription options
+     * @returns Subscription handle with unsubscribe() method
+     */
+    subscribe(options: RealtimeSubscribeOptions): RealtimeSubscription;
+}
+/**
+ * Retrieve an access token using the Client Credentials flow.
+ */
+export declare function fetchClientToken(clientId: string, clientSecret: string, baseUrl: string): Promise<string>;
+/**
+ * Generate Records API URL PATH.
+ */
+export declare function getRecordApiPath(workspaceId: string, recordSlug: string, id?: string): string;
+/**
+ * Generate File Upload API URL PATH.
+ * @param workspaceId
+ */
+export declare function getFileUploadApiPath(workspaceId: string): string;
+/**
+ * Generate Function Triggers base API URL PATH.
+ */
+export declare function getFunctionTriggersApiPath(workspaceId: string, triggerId?: string): string;
+/**
+ * Generate Function Trigger execute API URL PATH.
+ */
+export declare function getFunctionTriggerExecuteApiPath(workspaceId: string, triggerId: string): string;
+/**
+ * Generate Function Trigger pause API URL PATH.
+ */
+export declare function getFunctionTriggerPauseApiPath(workspaceId: string, triggerId: string): string;
+/**
+ * Generate Function Trigger resume API URL PATH.
+ */
+export declare function getFunctionTriggerResumeApiPath(workspaceId: string, triggerId: string): string;
+/**
+ * Generate Endpoint trigger invocation API URL PATH.
+ */
+export declare function getEndpointApiPath(workspaceId: string, path: string): string;
+/**
+ * Generate Smart Queries base API URL PATH for workspace-level operations.
+ */
+export declare function getSmartQueriesApiPath(workspaceId: string): string;
+/**
+ * Generate Smart Queries API URL PATH for structure-level operations.
+ */
+export declare function getSmartQueriesStructureApiPath(workspaceId: string, structureSlug: string, queryId?: string): string;
+/**
+ * Generate Smart Query by name API URL PATH.
+ */
+export declare function getSmartQueryByNameApiPath(workspaceId: string, structureSlug: string, name: string): string;
+/**
+ * Generate Smart Query execute API URL PATH.
+ */
+export declare function getSmartQueryExecuteApiPath(workspaceId: string, structureSlug: string, queryId: string): string;
+/**
+ * Generate Search API URL PATH.
+ */
+export declare function getSearchApiPath(workspaceId: string): string;
+/**
+ * Generate Anomaly Insights base API URL PATH.
+ */
+export declare function getAnomalyInsightsApiPath(workspaceId: string, insightId?: string): string;
+/**
+ * Generate Anomaly Insights summary API URL PATH.
+ */
+export declare function getAnomalyInsightsSummaryApiPath(workspaceId: string): string;
+/**
+ * Generate Anomaly Insights acknowledge API URL PATH.
+ */
+export declare function getAnomalyInsightAcknowledgeApiPath(workspaceId: string, insightId: string): string;
+/**
+ * Generate Anomaly Insights dismiss API URL PATH.
+ */
+export declare function getAnomalyInsightDismissApiPath(workspaceId: string, insightId: string): string;
+/**
+ * Generate Anomaly Insights bulk acknowledge API URL PATH.
+ */
+export declare function getAnomalyInsightsBulkAcknowledgeApiPath(workspaceId: string): string;
+/**
+ * Generate Anomaly analysis trigger API URL PATH.
+ */
+export declare function getAnomalyAnalysisTriggerApiPath(workspaceId: string): string;
+/**
+ * Generate structure-scoped anomaly insights API URL PATH.
+ */
+export declare function getStructureInsightsApiPath(workspaceId: string, structureSlug: string): string;
+/**
+ * Generate Structures base API URL PATH.
+ */
+export declare function getStructuresApiPath(workspaceId: string, structureId?: string): string;
+/**
+ * Generate Structure by slug API URL PATH.
+ */
+export declare function getStructureBySlugApiPath(workspaceId: string, recordSlug: string): string;
+/**
+ * Generate Structure validate API URL PATH.
+ */
+export declare function getStructureValidateApiPath(workspaceId: string): string;
+/**
+ * Generate collection-scoped anomaly insights API URL PATH.
+ */
+export declare function getCollectionInsightsApiPath(workspaceId: string, collectionSlug: string): string;
+/**
+ * Generate Collections base API URL PATH.
+ */
+export declare function getCollectionsApiPath(workspaceId: string, collectionId?: string): string;
+/**
+ * Generate Collection by slug API URL PATH.
+ */
+export declare function getCollectionBySlugApiPath(workspaceId: string, recordSlug: string): string;
+/**
+ * Generate Collection validate API URL PATH.
+ */
+export declare function getCollectionValidateApiPath(workspaceId: string): string;
+/**
+ * Generate Compute Functions base API URL PATH.
+ */
+export declare function getComputeFunctionsApiPath(workspaceId: string, functionId?: string): string;
+/**
+ * Generate Compute Function test execution API URL PATH.
+ */
+export declare function getComputeFunctionTestApiPath(workspaceId: string): string;
+/**
+ * Generate Function Runs base API URL PATH.
+ */
+export declare function getFunctionRunsApiPath(workspaceId: string, runId?: string): string;
+/**
+ * Generate Function Runs by trigger API URL PATH.
+ */
+export declare function getFunctionRunsByTriggerApiPath(workspaceId: string, triggerId: string): string;
+/**
+ * Generate Function Runs by function API URL PATH.
+ */
+export declare function getFunctionRunsByFunctionApiPath(workspaceId: string, functionId: string): string;
+/**
+ * Generate Compute Job Status API URL PATH.
+ */
+export declare function getComputeJobStatusApiPath(workspaceId: string, jobId: string): string;
+/**
+ * Generate Smart Query test execution API URL PATH.
+ */
+export declare function getSmartQueryTestApiPath(workspaceId: string, structureSlug: string): string;
+/**
+ * Generate Validation suggestions base API URL PATH.
+ */
+export declare function getValidationSuggestionsApiPath(workspaceId: string, suggestionId?: string): string;
+/**
+ * Generate Validation suggestion accept API URL PATH.
+ */
+export declare function getValidationSuggestionAcceptApiPath(workspaceId: string, suggestionId: string): string;
+/**
+ * Generate Validation suggestion reject API URL PATH.
+ */
+export declare function getValidationSuggestionRejectApiPath(workspaceId: string, suggestionId: string): string;
+/**
+ * Generate Validation bulk accept API URL PATH.
+ */
+export declare function getValidationBulkAcceptApiPath(workspaceId: string): string;
+/**
+ * Generate Validation bulk reject API URL PATH.
+ */
+export declare function getValidationBulkRejectApiPath(workspaceId: string): string;
+/**
+ * Generate Validation summary API URL PATH.
+ */
+export declare function getValidationSummaryApiPath(workspaceId: string): string;
+/**
+ * Generate Validation record suggestions API URL PATH.
+ */
+export declare function getValidationRecordSuggestionsApiPath(workspaceId: string, recordId: string): string;
+/**
+ * Generate Validation structure pending count API URL PATH.
+ */
+export declare function getValidationPendingCountApiPath(workspaceId: string, structureSlug: string): string;
+/**
+ * Generate Validation batch scan API URL PATH (AI Service).
+ * Note: This routes to the AI service, not the Data service.
+ */
+export declare function getValidationScanApiPath(workspaceId: string, batchId?: string): string;
+/**
+ * Generate Orchestrations API URL PATH.
+ * Routes to the orchestration service.
+ */
+export declare function getOrchestrationsApiPath(workspaceId: string, orchestrationId?: string): string;
+/**
+ * Generate Orchestration Runs API URL PATH.
+ */
+export declare function getOrchestrationRunsApiPath(workspaceId: string, orchestrationId: string, runId?: string): string;
+/**
+ * Generate Orchestration Run Steps API URL PATH.
+ */
+export declare function getOrchestrationRunStepsApiPath(workspaceId: string, orchestrationId: string, runId: string): string;
+/**
+ * Generate Allowed Domains API URL PATH.
+ */
+export declare function getAllowedDomainsApiPath(workspaceId: string, domainId?: string): string;
+/**
+ * Generate Webhook Subscriptions API URL PATH.
+ */
+export declare function getWebhookSubscriptionsApiPath(workspaceId: string, subscriptionId?: string): string;
+/**
+ * Generate rotate-secret API URL PATH for a webhook subscription.
+ */
+export declare function getWebhookSubscriptionRotateSecretApiPath(workspaceId: string, subscriptionId: string): string;
+/**
+ * Generate deliveries API URL PATH scoped to a webhook subscription.
+ */
+export declare function getWebhookSubscriptionDeliveriesApiPath(workspaceId: string, subscriptionId: string, deliveryId?: string): string;
+/**
+ * Generate retry API URL PATH for a webhook delivery.
+ * Retry is workspace-scoped (not nested under a subscription) — only the delivery ID is needed.
+ */
+export declare function getWebhookDeliveryRetryApiPath(workspaceId: string, deliveryId: string): string;
+/**
+ * Generate cancel API URL PATH for a webhook delivery retry.
+ * Cancel is workspace-scoped — only the delivery ID is needed.
+ */
+export declare function getWebhookDeliveryCancelApiPath(workspaceId: string, deliveryId: string): string;
+/**
+ * OrchestrationsManager provides methods for managing orchestrations and triggering runs.
+ * Access via `client.orchestrations`.
+ *
+ * Orchestrations are multi-step workflows that chain compute functions together
+ * with conditional logic, delays, and decision branches.
+ *
+ * Usage:
+ * ```ts
+ * // List all orchestrations
+ * const orchestrations = await client.orchestrations.list();
+ *
+ * // Get an orchestration by ID
+ * const orch = await client.orchestrations.get('orch-id');
+ *
+ * // Trigger an on-demand orchestration
+ * const run = await client.orchestrations.trigger('orch-id', {
+ *   input: { orderId: '12345' }
+ * });
+ *
+ * // Get run status
+ * const runStatus = await client.orchestrations.getRun('orch-id', run.data.id);
+ *
+ * // List runs for an orchestration
+ * const runs = await client.orchestrations.listRuns('orch-id');
+ * ```
+ */
+export declare class OrchestrationsManager {
+    private requestFn;
+    private workspaceId;
+    constructor(workspaceId: string, requestFn: <T>(method: Method, path: string, data?: any, queryParams?: Record<string, any>) => Promise<ApiResponse<T>>);
+    /**
+     * List all orchestrations in the workspace.
+     *
+     * @param options - Optional pagination and filtering options
+     * @returns Paginated list of orchestrations
+     *
+     * @example
+     * ```ts
+     * // List all orchestrations
+     * const result = await client.orchestrations.list();
+     * console.log('Total:', result.data.meta.total);
+     *
+     * // With pagination and status filter
+     * const result = await client.orchestrations.list({
+     *   limit: 10,
+     *   offset: 0,
+     *   status: 'active'
+     * });
+     * ```
+     */
+    list(options?: ListOrchestrationsOptions): Promise<ApiResponse<PaginatedResponse<Orchestration>>>;
+    /**
+     * Get an orchestration by ID.
+     *
+     * @param orchestrationId - The orchestration ID
+     * @returns The orchestration details including all steps
+     *
+     * @example
+     * ```ts
+     * const orch = await client.orchestrations.get('orch-id');
+     * console.log('Name:', orch.data.name);
+     * console.log('Steps:', orch.data.steps.length);
+     * ```
+     */
+    get(orchestrationId: string): Promise<ApiResponse<Orchestration>>;
+    /**
+     * Create a new orchestration.
+     *
+     * @param input - The orchestration definition
+     * @returns The created orchestration
+     *
+     * @example
+     * ```ts
+     * const orch = await client.orchestrations.create({
+     *   slug: 'order-processing',
+     *   name: 'Order Processing Workflow',
+     *   trigger: { type: 'on-demand' },
+     *   steps: [
+     *     {
+     *       id: 'validate',
+     *       type: 'compute',
+     *       functionId: 'func_validate',
+     *       onSuccess: { nextStepId: 'process' }
+     *     },
+     *     {
+     *       id: 'process',
+     *       type: 'compute',
+     *       functionId: 'func_process'
+     *     }
+     *   ]
+     * });
+     * ```
+     */
+    create(input: CreateOrchestrationInput): Promise<ApiResponse<Orchestration>>;
+    /**
+     * Update an existing orchestration.
+     *
+     * Updates increment the orchestration version. Running instances use the
+     * version at the time they started.
+     *
+     * @param orchestrationId - The orchestration ID
+     * @param input - Fields to update
+     * @returns The updated orchestration
+     *
+     * @example
+     * ```ts
+     * // Activate an orchestration
+     * await client.orchestrations.update('orch-id', { status: 'active' });
+     *
+     * // Update steps
+     * await client.orchestrations.update('orch-id', {
+     *   steps: [...]
+     * });
+     * ```
+     */
+    update(orchestrationId: string, input: UpdateOrchestrationInput): Promise<ApiResponse<Orchestration>>;
+    /**
+     * Delete an orchestration.
+     *
+     * This also deletes all runs associated with the orchestration.
+     *
+     * @param orchestrationId - The orchestration ID
+     *
+     * @example
+     * ```ts
+     * await client.orchestrations.delete('orch-id');
+     * ```
+     */
+    delete(orchestrationId: string): Promise<ApiResponse<void>>;
+    /**
+     * Trigger an orchestration run.
+     *
+     * This creates a new run instance and starts executing the workflow.
+     * Can be used on on-demand, draft, or active orchestrations.
+     * Paused orchestrations cannot be triggered.
+     *
+     * @param orchestrationId - The orchestration ID
+     * @param options - Optional input data and correlation ID
+     * @returns The created run
+     *
+     * @example
+     * ```ts
+     * // Simple trigger
+     * const run = await client.orchestrations.trigger('orch-id');
+     *
+     * // With input data
+     * const run = await client.orchestrations.trigger('orch-id', {
+     *   input: {
+     *     orderId: '12345',
+     *     customerId: 'cust_abc'
+     *   }
+     * });
+     *
+     * // With correlation ID for tracing
+     * const run = await client.orchestrations.trigger('orch-id', {
+     *   input: { orderId: '12345' },
+     *   correlationId: 'req-123'
+     * });
+     * ```
+     */
+    trigger(orchestrationId: string, options?: TriggerOrchestrationRunOptions): Promise<ApiResponse<OrchestrationRun>>;
+    /**
+     * List runs for an orchestration.
+     *
+     * @param orchestrationId - The orchestration ID
+     * @param options - Optional pagination and filtering options
+     * @returns Paginated list of runs
+     *
+     * @example
+     * ```ts
+     * // List all runs
+     * const runs = await client.orchestrations.listRuns('orch-id');
+     *
+     * // Filter by status
+     * const failedRuns = await client.orchestrations.listRuns('orch-id', {
+     *   status: 'failed'
+     * });
+     * ```
+     */
+    listRuns(orchestrationId: string, options?: ListOrchestrationRunsOptions): Promise<ApiResponse<PaginatedResponse<OrchestrationRun>>>;
+    /**
+     * Get a specific run by ID.
+     *
+     * @param orchestrationId - The orchestration ID
+     * @param runId - The run ID
+     * @param includeSteps - Whether to include step execution history
+     * @returns The run details
+     *
+     * @example
+     * ```ts
+     * // Get basic run info
+     * const run = await client.orchestrations.getRun('orch-id', 'run-id');
+     * console.log('Status:', run.data.status);
+     *
+     * // Include step history
+     * const run = await client.orchestrations.getRun('orch-id', 'run-id', true);
+     * console.log('Steps:', run.data.steps);
+     * ```
+     */
+    getRun(orchestrationId: string, runId: string, includeSteps?: boolean): Promise<ApiResponse<OrchestrationRun & {
+        steps?: OrchestrationRunStep[];
+    }>>;
+    /**
+     * Get step execution history for a run.
+     *
+     * @param orchestrationId - The orchestration ID
+     * @param runId - The run ID
+     * @returns List of step executions
+     *
+     * @example
+     * ```ts
+     * const steps = await client.orchestrations.getRunSteps('orch-id', 'run-id');
+     * for (const step of steps.data.data) {
+     *   console.log(`${step.stepId}: ${step.status}`);
+     * }
+     * ```
+     */
+    getRunSteps(orchestrationId: string, runId: string): Promise<ApiResponse<{
+        data: OrchestrationRunStep[];
+        meta: {
+            total: number;
+        };
+    }>>;
+    /**
+     * Activate an orchestration.
+     *
+     * Convenience method to set status to 'active'.
+     * Active orchestrations can be triggered by scheduled events, record events, and webhooks.
+     *
+     * @param orchestrationId - The orchestration ID
+     * @returns The updated orchestration
+     *
+     * @example
+     * ```ts
+     * await client.orchestrations.activate('orch-id');
+     * ```
+     */
+    activate(orchestrationId: string): Promise<ApiResponse<Orchestration>>;
+    /**
+     * Pause an orchestration.
+     *
+     * Convenience method to set status to 'paused'.
+     * Paused orchestrations cannot be triggered by any mechanism.
+     *
+     * @param orchestrationId - The orchestration ID
+     * @returns The updated orchestration
+     *
+     * @example
+     * ```ts
+     * await client.orchestrations.pause('orch-id');
+     * ```
+     */
+    pause(orchestrationId: string): Promise<ApiResponse<Orchestration>>;
+}
+/**
+ * TriggersManager provides methods for working with on-demand function triggers.
+ * Access via `client.triggers`.
+ *
+ * Note: This manager only works with on-demand triggers. Scheduled, event-driven,
+ * and webhook triggers are managed through other mechanisms.
+ *
+ * Usage:
+ * ```ts
+ * // Invoke an on-demand trigger
+ * const result = await client.triggers.invoke('trigger-id');
+ *
+ * // Invoke with custom payload
+ * const result = await client.triggers.invoke('trigger-id', {
+ *   payload: { customData: 'value' }
+ * });
+ *
+ * // Get an on-demand trigger by ID
+ * const trigger = await client.triggers.get('trigger-id');
+ *
+ * // List all on-demand triggers
+ * const triggers = await client.triggers.list();
+ * ```
+ */
+export declare class TriggersManager {
+    private requestFn;
+    private workspaceId;
+    constructor(workspaceId: string, requestFn: <T>(method: Method, path: string, data?: any, queryParams?: Record<string, any>) => Promise<ApiResponse<T>>);
+    /**
+     * Invoke an on-demand trigger by ID.
+     *
+     * @param triggerId - The ID of the trigger to invoke
+     * @param options - Optional invoke options including custom payload
+     * @returns The queued job ID for tracking the execution
+     *
+     * @example
+     * ```ts
+     * // Simple invocation
+     * const job = await client.triggers.invoke('trigger-id');
+     * console.log('Job queued:', job.data);
+     *
+     * // With custom payload
+     * const job = await client.triggers.invoke('trigger-id', {
+     *   payload: { orderId: '12345', action: 'process' }
+     * });
+     * ```
+     */
+    invoke(triggerId: string, options?: InvokeTriggerOptions): Promise<ApiResponse<TriggerInvokeResponse>>;
+    /**
+     * Get an on-demand trigger by ID.
+     *
+     * Note: This method validates that the trigger is an on-demand trigger.
+     * If the trigger exists but is not on-demand, an error will be thrown.
+     *
+     * @param triggerId - The ID of the on-demand trigger to retrieve
+     * @returns The trigger details
+     * @throws Error if the trigger is not an on-demand trigger
+     *
+     * @example
+     * ```ts
+     * const trigger = await client.triggers.get('trigger-id');
+     * console.log('Trigger name:', trigger.data.name);
+     * ```
+     */
+    get(triggerId: string): Promise<ApiResponse<FunctionTrigger>>;
+    /**
+     * List all on-demand triggers in the workspace.
+     *
+     * This method automatically filters to only return triggers with executionType 'on-demand'.
+     *
+     * @param queryParams - Optional query parameters for pagination, search, etc.
+     * @returns List of on-demand triggers with pagination metadata
+     *
+     * @example
+     * ```ts
+     * // List all on-demand triggers
+     * const triggers = await client.triggers.list();
+     *
+     * // With pagination
+     * const triggers = await client.triggers.list({ limit: 10, page: 1 });
+     *
+     * // With search
+     * const triggers = await client.triggers.list({ search: 'process-order' });
+     * ```
+     */
+    list(queryParams?: Record<string, any>): Promise<ApiResponse<FunctionTrigger[]>>;
+    /**
+     * Pause a function trigger.
+     *
+     * Pauses an event-driven or scheduled trigger to temporarily disable it from firing.
+     * When paused, the trigger will not execute until resumed.
+     *
+     * For scheduled triggers, this also pauses the underlying scheduler job.
+     *
+     * @param triggerId - The ID of the trigger to pause
+     * @returns The updated trigger with enabled = false
+     *
+     * @example
+     * ```ts
+     * // Pause a trigger
+     * const result = await client.triggers.pauseTrigger('trigger-id');
+     * console.log('Trigger paused:', result.data.enabled === false);
+     * ```
+     */
+    pauseTrigger(triggerId: string): Promise<ApiResponse<FunctionTrigger>>;
+    /**
+     * Resume a paused function trigger.
+     *
+     * Resumes a paused event-driven or scheduled trigger to re-enable it.
+     * Once resumed, the trigger will start firing again on matching events or schedules.
+     *
+     * For scheduled triggers, this also resumes the underlying scheduler job.
+     *
+     * @param triggerId - The ID of the trigger to resume
+     * @returns The updated trigger with enabled = true
+     *
+     * @example
+     * ```ts
+     * // Resume a paused trigger
+     * const result = await client.triggers.resumeTrigger('trigger-id');
+     * console.log('Trigger resumed:', result.data.enabled === true);
+     * ```
+     */
+    resumeTrigger(triggerId: string): Promise<ApiResponse<FunctionTrigger>>;
+    /**
+     * Create a new function trigger.
+     *
+     * @param input - The trigger definition
+     * @returns The created trigger
+     *
+     * @example
+     * ```ts
+     * // Create an event-driven trigger
+     * const trigger = await client.triggers.create({
+     *   name: 'On Order Created',
+     *   functionId: 'function-uuid',
+     *   executionType: 'event-driven',
+     *   triggerMetadata: { event: 'record.created', recordSlug: 'orders' }
+     * });
+     *
+     * // Create a scheduled trigger
+     * const scheduled = await client.triggers.create({
+     *   name: 'Daily Report',
+     *   functionId: 'function-uuid',
+     *   executionType: 'scheduled',
+     *   triggerMetadata: { scheduleType: 'cron', cronExpression: '0 9 * * *', timezone: 'America/New_York' }
+     * });
+     * ```
+     */
+    create(input: CreateTriggerInput): Promise<ApiResponse<FunctionTrigger>>;
+    /**
+     * Update an existing function trigger.
+     *
+     * @param triggerId - The trigger UUID
+     * @param input - The fields to update
+     * @returns The updated trigger
+     *
+     * @example
+     * ```ts
+     * const updated = await client.triggers.update('trigger-uuid', {
+     *   name: 'Updated Trigger Name',
+     *   enabled: false
+     * });
+     * ```
+     */
+    update(triggerId: string, input: UpdateTriggerInput): Promise<ApiResponse<FunctionTrigger>>;
+    /**
+     * Delete a function trigger.
+     *
+     * @param triggerId - The trigger UUID
+     *
+     * @example
+     * ```ts
+     * await client.triggers.delete('trigger-uuid');
+     * ```
+     */
+    delete(triggerId: string): Promise<ApiResponse<void>>;
+    /**
+     * List all triggers in the workspace (not filtered by execution type).
+     * Unlike `list()` which only returns on-demand triggers, `listAll()` returns
+     * triggers of all types with optional filtering.
+     *
+     * @param options - Optional list parameters (pagination, filtering, health)
+     * @returns List of triggers
+     *
+     * @example
+     * ```ts
+     * // List all triggers
+     * const all = await client.triggers.listAll();
+     *
+     * // Filter by execution type
+     * const scheduled = await client.triggers.listAll({ executionType: 'scheduled' });
+     *
+     * // Include health metrics
+     * const withHealth = await client.triggers.listAll({ includeHealth: true });
+     * ```
+     */
+    listAll(options?: ListAllTriggersOptions): Promise<ApiResponse<(FunctionTrigger | TriggerWithHealth)[]>>;
+    /**
+     * Get a trigger by ID with full details (no on-demand type restriction).
+     * Unlike `get()` which validates on-demand type, `getDetails()` returns
+     * any trigger type.
+     *
+     * @param triggerId - The trigger UUID
+     * @param options - Optional parameters (includeHealth)
+     * @returns The trigger details
+     *
+     * @example
+     * ```ts
+     * const trigger = await client.triggers.getDetails('trigger-uuid');
+     *
+     * // With health metrics
+     * const withHealth = await client.triggers.getDetails('trigger-uuid', { includeHealth: true });
+     * ```
+     */
+    getDetails(triggerId: string, options?: {
+        includeHealth?: boolean;
+    }): Promise<ApiResponse<FunctionTrigger | TriggerWithHealth>>;
+    /**
+     * Invoke a synchronous compute endpoint by its path.
+     *
+     * Unlike `invoke()` (which is async and returns a job ID), endpoint triggers
+     * execute the function and return the result inline. Max 30 second timeout.
+     *
+     * @param endpointPath - The endpoint path (e.g., 'create-order')
+     * @param options - Optional method, payload, headers, query params
+     * @returns The function's response (status, data, headers)
+     *
+     * @example
+     * ```ts
+     * // POST to an endpoint
+     * const result = await client.triggers.invokeEndpoint('create-order', {
+     *   payload: { product: 'Widget', quantity: 5 }
+     * });
+     * console.log('Status:', result.data.status);
+     * console.log('Response:', result.data.data);
+     *
+     * // GET with query params
+     * const users = await client.triggers.invokeEndpoint('list-users', {
+     *   method: 'GET',
+     *   query: { role: 'admin' }
+     * });
+     *
+     * // With API key auth
+     * const result = await client.triggers.invokeEndpoint('webhook/stripe', {
+     *   payload: stripeEvent,
+     *   headers: { 'X-API-Key': 'your-api-key' }
+     * });
+     * ```
+     */
+    invokeEndpoint<T = any>(endpointPath: string, options?: InvokeEndpointOptions): Promise<ApiResponse<T>>;
+}
+/**
+ * SmartQueriesManager provides methods for listing and executing smart queries.
+ * Smart queries are reusable, parameterized queries defined in the console
+ * that can be executed programmatically via the SDK.
+ * Access via `client.smartQueries`.
+ *
+ * Usage:
+ * ```ts
+ * // List smart queries for a structure
+ * const queries = await client.smartQueries.list('employee');
+ *
+ * // Execute a smart query by ID
+ * const results = await client.smartQueries.execute('employee', 'query-uuid');
+ *
+ * // Get a smart query by name
+ * const query = await client.smartQueries.getByName('employee', 'Active Employees');
+ * ```
+ */
+export declare class SmartQueriesManager {
+    private requestFn;
+    private workspaceId;
+    constructor(workspaceId: string, requestFn: <T>(method: Method, path: string, data?: any, queryParams?: Record<string, any>) => Promise<ApiResponse<T>>);
+    /**
+     * List all smart queries in the workspace.
+     *
+     * @param options - Optional list parameters (pagination, search, etc.)
+     * @returns List of smart queries with pagination metadata
+     *
+     * @example
+     * ```ts
+     * // List all smart queries
+     * const queries = await client.smartQueries.listAll();
+     *
+     * // With pagination
+     * const queries = await client.smartQueries.listAll({ page: 1, limit: 20 });
+     * ```
+     */
+    listAll(options?: ListSmartQueryOptions): Promise<ApiResponse<SmartQuery[]>>;
+    /**
+     * List smart queries for a specific structure.
+     *
+     * @param structureSlug - The structure's record slug (e.g., "employee")
+     * @param options - Optional list parameters (pagination, search, etc.)
+     * @returns List of smart queries for the structure
+     *
+     * @example
+     * ```ts
+     * // List queries for employee structure
+     * const queries = await client.smartQueries.list('employee');
+     *
+     * // With pagination and search
+     * const queries = await client.smartQueries.list('employee', {
+     *   page: 1,
+     *   limit: 10,
+     *   search: 'active'
+     * });
+     * ```
+     */
+    list(structureSlug: string, options?: ListSmartQueryOptions): Promise<ApiResponse<SmartQuery[]>>;
+    /**
+     * Get a smart query by ID.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param queryId - The smart query UUID
+     * @returns The smart query details
+     *
+     * @example
+     * ```ts
+     * const query = await client.smartQueries.get('employee', 'query-uuid');
+     * console.log('Query name:', query.data.name);
+     * ```
+     */
+    get(structureSlug: string, queryId: string): Promise<ApiResponse<SmartQuery>>;
+    /**
+     * Get a smart query by name.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param name - The smart query name
+     * @returns The smart query details
+     *
+     * @example
+     * ```ts
+     * const query = await client.smartQueries.getByName('employee', 'Active Employees');
+     * console.log('Query ID:', query.data.id);
+     * ```
+     */
+    getByName(structureSlug: string, name: string): Promise<ApiResponse<SmartQuery>>;
+    /**
+     * Execute a smart query and return results.
+     *
+     * Note: Pagination (limit/skip) is defined in the query definition itself,
+     * not at execution time.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param queryId - The smart query UUID
+     * @param options - Optional execution options including variables
+     * @returns Query results
+     *
+     * @example
+     * ```ts
+     * // Simple execution without variables
+     * const results = await client.smartQueries.execute('employee', 'query-uuid');
+     * console.log('Found:', results.data.length, 'records');
+     *
+     * // Execution with variables
+     * // Query definition: { where: { status: { $eq: "{{statusFilter}}" } } }
+     * const filtered = await client.smartQueries.execute('orders', 'query-id', {
+     *   variables: { statusFilter: 'active' }
+     * });
+     *
+     * // Accessing joined data (nested under _joined)
+     * // Query with join: { join: { foreignSlug: "products", ... } }
+     * const items = await client.smartQueries.execute('order-items', 'items-with-products');
+     * items.data.forEach(item => {
+     *   console.log('Item:', item.name);
+     *   console.log('Product:', item._joined?.products?.title);
+     * });
+     * ```
+     */
+    execute<T = any>(structureSlug: string, queryId: string, options?: ExecuteSmartQueryOptions): Promise<ApiResponse<T[]>>;
+    /**
+     * Create a new smart query for a structure.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param input - The smart query definition
+     * @returns The created smart query
+     *
+     * @example
+     * ```ts
+     * const query = await client.smartQueries.create('orders', {
+     *   name: 'Active Orders',
+     *   description: 'All orders with active status',
+     *   queryDefinition: {
+     *     where: { status: { $eq: 'active' } },
+     *     sort: [{ field: 'createdAt', direction: 'desc' }],
+     *     limit: 100
+     *   }
+     * });
+     * ```
+     */
+    create(structureSlug: string, input: CreateSmartQueryInput): Promise<ApiResponse<SmartQuery>>;
+    /**
+     * Update an existing smart query.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param queryId - The smart query UUID
+     * @param input - The fields to update
+     * @returns The updated smart query
+     *
+     * @example
+     * ```ts
+     * const updated = await client.smartQueries.update('orders', 'query-uuid', {
+     *   name: 'Active Orders v2',
+     *   queryDefinition: {
+     *     where: { status: { $in: ['active', 'processing'] } },
+     *     limit: 200
+     *   }
+     * });
+     * ```
+     */
+    update(structureSlug: string, queryId: string, input: UpdateSmartQueryInput): Promise<ApiResponse<SmartQuery>>;
+    /**
+     * Delete a smart query.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param queryId - The smart query UUID
+     *
+     * @example
+     * ```ts
+     * await client.smartQueries.delete('orders', 'query-uuid');
+     * ```
+     */
+    delete(structureSlug: string, queryId: string): Promise<ApiResponse<void>>;
+    /**
+     * Test execute a query definition without saving it.
+     * Useful for validating query syntax and previewing results before creating.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param input - The query definition to test and optional variables
+     * @returns Test execution results
+     *
+     * @example
+     * ```ts
+     * const result = await client.smartQueries.test('orders', {
+     *   queryDefinition: {
+     *     where: { amount: { $gte: 100 } },
+     *     select: ['id', 'amount', 'status'],
+     *     limit: 5
+     *   }
+     * });
+     * console.log('Preview results:', result.data);
+     * ```
+     */
+    test<T = any>(structureSlug: string, input: TestSmartQueryInput): Promise<ApiResponse<T[]>>;
+}
+/**
+ * AnomalyInsightsManager provides methods for querying and managing AI-generated anomaly insights.
+ * Access via `client.anomalyInsights`.
+ *
+ * Usage:
+ * ```ts
+ * // List all active insights
+ * const insights = await client.anomalyInsights.list({ status: 'active' });
+ *
+ * // Get insights for a specific structure
+ * const orderInsights = await client.anomalyInsights.listByStructure('orders');
+ *
+ * // Get insight summary
+ * const summary = await client.anomalyInsights.getSummary();
+ *
+ * // Acknowledge an insight
+ * await client.anomalyInsights.acknowledge('insight-id');
+ *
+ * // Dismiss an insight
+ * await client.anomalyInsights.dismiss('insight-id');
+ * ```
+ */
+export declare class AnomalyInsightsManager {
+    private requestFn;
+    private workspaceId;
+    constructor(workspaceId: string, requestFn: <T>(method: Method, path: string, data?: any, queryParams?: Record<string, any>) => Promise<ApiResponse<T>>);
+    /**
+     * List anomaly insights with optional filters.
+     *
+     * @param options - Optional filter and pagination options
+     * @returns List of anomaly insights
+     *
+     * @example
+     * ```ts
+     * // List all active critical insights
+     * const insights = await client.anomalyInsights.list({
+     *   status: 'active',
+     *   severity: 'critical'
+     * });
+     *
+     * // List insights for a specific structure
+     * const orderInsights = await client.anomalyInsights.list({
+     *   structureSlug: 'orders'
+     * });
+     * ```
+     */
+    list(options?: ListInsightsOptions): Promise<ApiResponse<AnomalyInsight[]>>;
+    /**
+     * List insights for a specific structure.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param options - Optional filter options
+     * @returns List of insights for the structure
+     *
+     * @example
+     * ```ts
+     * const insights = await client.anomalyInsights.listByStructure('orders');
+     * ```
+     */
+    listByStructure(structureSlug: string, options?: Omit<ListInsightsOptions, 'structureSlug'>): Promise<ApiResponse<AnomalyInsight[]>>;
+    /**
+     * Get a single insight by ID.
+     *
+     * @param insightId - The insight UUID
+     * @returns The insight details
+     *
+     * @example
+     * ```ts
+     * const insight = await client.anomalyInsights.get('insight-id');
+     * console.log('Insight:', insight.data.title);
+     * ```
+     */
+    get(insightId: string): Promise<ApiResponse<AnomalyInsight>>;
+    /**
+     * Acknowledge an insight.
+     * Marks the insight as reviewed/handled.
+     *
+     * @param insightId - The insight UUID
+     * @returns The updated insight
+     *
+     * @example
+     * ```ts
+     * await client.anomalyInsights.acknowledge('insight-id');
+     * ```
+     */
+    acknowledge(insightId: string): Promise<ApiResponse<AnomalyInsight>>;
+    /**
+     * Dismiss an insight.
+     * Marks the insight as not relevant/false positive.
+     *
+     * @param insightId - The insight UUID
+     * @returns The updated insight
+     *
+     * @example
+     * ```ts
+     * await client.anomalyInsights.dismiss('insight-id');
+     * ```
+     */
+    dismiss(insightId: string): Promise<ApiResponse<AnomalyInsight>>;
+    /**
+     * Bulk acknowledge multiple insights.
+     *
+     * @param ids - Array of insight IDs to acknowledge
+     * @returns Result with count of updated insights
+     *
+     * @example
+     * ```ts
+     * const result = await client.anomalyInsights.bulkAcknowledge(['id1', 'id2']);
+     * console.log('Acknowledged:', result.data.updated);
+     * ```
+     */
+    bulkAcknowledge(ids: string[]): Promise<ApiResponse<{
+        updated: number;
+        message: string;
+    }>>;
+    /**
+     * Get insights summary/statistics.
+     *
+     * @param structureSlug - Optional structure to filter summary
+     * @returns Summary of insights by status and severity
+     *
+     * @example
+     * ```ts
+     * // Get overall summary
+     * const summary = await client.anomalyInsights.getSummary();
+     * console.log('Critical insights:', summary.data.bySeverity.critical);
+     *
+     * // Get summary for a specific structure
+     * const orderSummary = await client.anomalyInsights.getSummary('orders');
+     * ```
+     */
+    getSummary(structureSlug?: string): Promise<ApiResponse<InsightsSummary>>;
+    /**
+     * Trigger anomaly analysis for a structure.
+     * Starts an AI-powered analysis to detect anomalies in the structure's data.
+     *
+     * @param structureSlug - The structure's record slug to analyze
+     * @returns Result indicating if analysis was triggered and the batch ID
+     *
+     * @example
+     * ```ts
+     * const result = await client.anomalyInsights.triggerAnalysis('orders');
+     * if (result.data.success) {
+     *   console.log('Analysis started:', result.data.batchId);
+     * }
+     * ```
+     */
+    triggerAnalysis(structureSlug: string): Promise<ApiResponse<AnomalyAnalysisResult>>;
+}
+/**
+ * ValidationManager provides methods for AI-powered data quality validation.
+ * Access via `client.validation`.
+ *
+ * Features:
+ * - Trigger batch validation scans on structures
+ * - List and manage validation suggestions (typos, format issues, duplicates)
+ * - Accept or reject suggestions to fix data
+ * - Get validation summaries and statistics
+ *
+ * Usage:
+ * ```ts
+ * // Trigger a batch scan
+ * const batch = await client.validation.triggerScan('orders');
+ * console.log('Scan started:', batch.data.batchId);
+ *
+ * // Wait for completion
+ * const result = await client.validation.waitForScan(batch.data.batchId);
+ *
+ * // List pending suggestions
+ * const suggestions = await client.validation.listSuggestions({ status: 'pending' });
+ *
+ * // Accept a suggestion (applies the fix)
+ * await client.validation.accept('suggestion-id');
+ *
+ * // Bulk accept high-confidence suggestions
+ * const highConfidence = suggestions.data.filter(s => s.confidence >= 0.95);
+ * await client.validation.bulkAccept(highConfidence.map(s => s.id));
+ * ```
+ */
+export declare class ValidationManager {
+    private requestFn;
+    private workspaceId;
+    constructor(workspaceId: string, requestFn: <T>(method: Method, path: string, data?: any, queryParams?: Record<string, any>) => Promise<ApiResponse<T>>);
+    /**
+     * Trigger a batch validation scan on a structure.
+     *
+     * @param structureSlug - The structure's slug to scan
+     * @param options - Optional scan configuration
+     * @returns The batch scan result with batchId for tracking
+     *
+     * @example
+     * ```ts
+     * const batch = await client.validation.triggerScan('orders');
+     * console.log('Batch ID:', batch.data.batchId);
+     * console.log('Records to scan:', batch.data.total);
+     * ```
+     */
+    triggerScan(structureSlug: string, options?: TriggerScanOptions): Promise<ApiResponse<BatchScanResult>>;
+    /**
+     * Get the status of a batch validation scan.
+     *
+     * @param batchId - The batch scan ID
+     * @returns Current scan status and progress
+     *
+     * @example
+     * ```ts
+     * const status = await client.validation.getScanStatus('batch-id');
+     * console.log('Progress:', status.data.processed, '/', status.data.total);
+     * ```
+     */
+    getScanStatus(batchId: string): Promise<ApiResponse<BatchScanResult>>;
+    /**
+     * Wait for a batch scan to complete with polling.
+     *
+     * @param batchId - The batch scan ID
+     * @param options - Polling configuration
+     * @returns The final scan result
+     * @throws Error if scan fails or times out
+     *
+     * @example
+     * ```ts
+     * const result = await client.validation.waitForScan('batch-id', {
+     *   pollInterval: 5000,  // 5 seconds
+     *   timeout: 300000      // 5 minutes
+     * });
+     * console.log('Scan complete:', result.data.issuesFound, 'issues found');
+     * ```
+     */
+    waitForScan(batchId: string, options?: WaitForScanOptions): Promise<ApiResponse<BatchScanResult>>;
+    /**
+     * List validation suggestions with optional filters.
+     *
+     * @param options - Filter and pagination options
+     * @returns List of validation suggestions
+     *
+     * @example
+     * ```ts
+     * // List all pending suggestions
+     * const pending = await client.validation.listSuggestions({ status: 'pending' });
+     *
+     * // List high-confidence typo suggestions
+     * const typos = await client.validation.listSuggestions({
+     *   issueType: 'typo',
+     *   minConfidence: 0.9
+     * });
+     * ```
+     */
+    listSuggestions(options?: ListValidationSuggestionsOptions): Promise<ApiResponse<ValidationSuggestion[]>>;
+    /**
+     * Get a single validation suggestion by ID.
+     *
+     * @param suggestionId - The suggestion UUID
+     * @returns The suggestion details
+     */
+    getSuggestion(suggestionId: string): Promise<ApiResponse<ValidationSuggestion>>;
+    /**
+     * Get all suggestions for a specific record.
+     *
+     * @param recordId - The record UUID
+     * @param status - Optional status filter
+     * @returns List of suggestions for the record
+     */
+    getRecordSuggestions(recordId: string, status?: ValidationSuggestionStatus): Promise<ApiResponse<ValidationSuggestion[]>>;
+    /**
+     * Accept a validation suggestion and apply the fix to the record.
+     *
+     * @param suggestionId - The suggestion UUID
+     * @returns Result with updated suggestion and record status
+     *
+     * @example
+     * ```ts
+     * const result = await client.validation.accept('suggestion-id');
+     * if (result.data.recordUpdated) {
+     *   console.log('Fix applied successfully');
+     * }
+     * ```
+     */
+    accept(suggestionId: string): Promise<ApiResponse<AcceptSuggestionResult>>;
+    /**
+     * Reject a validation suggestion.
+     *
+     * @param suggestionId - The suggestion UUID
+     * @returns The updated suggestion
+     */
+    reject(suggestionId: string): Promise<ApiResponse<ValidationSuggestion>>;
+    /**
+     * Bulk accept multiple suggestions.
+     *
+     * @param ids - Array of suggestion IDs to accept (max 100)
+     * @returns Result with count and any errors
+     *
+     * @example
+     * ```ts
+     * const result = await client.validation.bulkAccept(['id1', 'id2', 'id3']);
+     * console.log('Accepted:', result.data.count);
+     * ```
+     */
+    bulkAccept(ids: string[]): Promise<ApiResponse<BulkOperationResult>>;
+    /**
+     * Bulk reject multiple suggestions.
+     *
+     * @param ids - Array of suggestion IDs to reject (max 100)
+     * @returns Result with count and any errors
+     */
+    bulkReject(ids: string[]): Promise<ApiResponse<BulkOperationResult>>;
+    /**
+     * Get validation summary statistics.
+     *
+     * @param structureId - Optional structure ID to filter summary
+     * @returns Summary of suggestions by status and type
+     *
+     * @example
+     * ```ts
+     * const summary = await client.validation.getSummary();
+     * console.log('Pending:', summary.data.pending);
+     * console.log('By type:', summary.data.byIssueType);
+     * ```
+     */
+    getSummary(structureSlug?: string): Promise<ApiResponse<ValidationSummary>>;
+    /**
+     * Get the count of pending suggestions for a structure.
+     *
+     * @param structureSlug - The structure slug (recordSlug)
+     * @returns Object with pending count
+     */
+    getPendingCount(structureSlug: string): Promise<ApiResponse<{
+        structureSlug: string;
+        pendingCount: number;
+    }>>;
+}
+/**
+ * AllowedDomainsManager provides methods for managing allowed domains for compute function external calls.
+ * Access via `client.allowedDomains`.
+ *
+ * Usage:
+ * ```ts
+ * // List all allowed domains
+ * const domains = await client.allowedDomains.list();
+ *
+ * // Add a new domain
+ * const domain = await client.allowedDomains.add({ domain: 'api.example.com' });
+ *
+ * // Remove a domain
+ * await client.allowedDomains.remove('domain-id');
+ * ```
+ */
+export declare class AllowedDomainsManager {
+    private requestFn;
+    private workspaceId;
+    constructor(workspaceId: string, requestFn: <T>(method: Method, path: string, data?: any, queryParams?: Record<string, any>) => Promise<ApiResponse<T>>);
+    /**
+     * List all allowed domains in the workspace.
+     *
+     * @returns List of allowed domains with total count
+     *
+     * @example
+     * ```ts
+     * const result = await client.allowedDomains.list();
+     * console.log('Total domains:', result.meta.total);
+     * result.data.forEach(d => console.log(d.domain));
+     * ```
+     */
+    list(): Promise<ApiResponse<AllowedDomain[]>>;
+    /**
+     * Add a new allowed domain.
+     *
+     * @param options - The domain to add
+     * @returns The created allowed domain entry
+     *
+     * @example
+     * ```ts
+     * const result = await client.allowedDomains.add({ domain: 'api.stripe.com' });
+     * console.log('Added:', result.data.domain, result.data.id);
+     * ```
+     */
+    add(options: AddAllowedDomainOptions): Promise<ApiResponse<AllowedDomain>>;
+    /**
+     * Remove an allowed domain by ID.
+     *
+     * @param domainId - The ID of the domain to remove
+     *
+     * @example
+     * ```ts
+     * await client.allowedDomains.remove('domain-id-123');
+     * ```
+     */
+    remove(domainId: string): Promise<ApiResponse<void>>;
+}
+/**
+ * StructuresManager provides methods for managing data structures (schemas).
+ * Structures define the shape of records including properties, validation rules,
+ * and schema discovery modes.
+ * Access via `client.structures`.
+ *
+ * Usage:
+ * ```ts
+ * // List all structures
+ * const structures = await client.structures.list();
+ *
+ * // Create a new structure
+ * const structure = await client.structures.create({
+ *   name: 'Orders',
+ *   slug: 'orders',
+ *   properties: [
+ *     { name: 'title', type: 'string', required: true },
+ *     { name: 'amount', type: 'number', minimum: 0 }
+ *   ]
+ * });
+ *
+ * // Validate before creating
+ * const validation = await client.structures.validate({ slug: 'orders' });
+ * ```
+ */
+export declare class StructuresManager {
+    private requestFn;
+    private workspaceId;
+    constructor(workspaceId: string, requestFn: <T>(method: Method, path: string, data?: any, queryParams?: Record<string, any>) => Promise<ApiResponse<T>>);
+    /**
+     * List all structures in the workspace.
+     *
+     * @param options - Optional list parameters (pagination)
+     * @returns List of structures
+     *
+     * @example
+     * ```ts
+     * const structures = await client.structures.list();
+     * const page2 = await client.structures.list({ page: 2, limit: 10 });
+     * ```
+     */
+    list(options?: ListStructuresOptions): Promise<ApiResponse<Structure[]>>;
+    /**
+     * Get a structure by ID.
+     *
+     * @param structureId - The structure UUID
+     * @returns The structure details
+     *
+     * @example
+     * ```ts
+     * const structure = await client.structures.get('structure-uuid');
+     * console.log('Properties:', structure.data.properties.length);
+     * ```
+     */
+    get(structureId: string): Promise<ApiResponse<Structure>>;
+    /**
+     * Get a structure by its record slug.
+     *
+     * @param recordSlug - The structure's record slug (e.g., "orders")
+     * @returns The structure details
+     *
+     * @example
+     * ```ts
+     * const structure = await client.structures.getBySlug('orders');
+     * console.log('Structure name:', structure.data.name);
+     * ```
+     */
+    getBySlug(recordSlug: string): Promise<ApiResponse<Structure>>;
+    /**
+     * Create a new structure.
+     *
+     * @param input - The structure definition
+     * @returns The created structure
+     *
+     * @example
+     * ```ts
+     * const structure = await client.structures.create({
+     *   name: 'Orders',
+     *   slug: 'orders',
+     *   description: 'Customer orders',
+     *   properties: [
+     *     { name: 'title', type: 'string', required: true },
+     *     { name: 'amount', type: 'number', minimum: 0 },
+     *     { name: 'status', type: 'string', enum: ['pending', 'completed'] }
+     *   ],
+     *   enableVersioning: true,
+     *   schemaDiscoveryMode: 'strict'
+     * });
+     * ```
+     */
+    create(input: CreateStructureInput): Promise<ApiResponse<Structure>>;
+    /**
+     * Update an existing structure.
+     *
+     * @param structureId - The structure UUID
+     * @param input - The fields to update
+     * @returns The updated structure
+     *
+     * @example
+     * ```ts
+     * const updated = await client.structures.update('structure-uuid', {
+     *   name: 'Updated Orders',
+     *   properties: [
+     *     { name: 'title', type: 'string', required: true },
+     *     { name: 'amount', type: 'number', minimum: 0 },
+     *     { name: 'priority', type: 'number' }
+     *   ]
+     * });
+     * ```
+     */
+    update(structureId: string, input: UpdateStructureInput): Promise<ApiResponse<Structure>>;
+    /**
+     * Delete a structure.
+     *
+     * @param structureId - The structure UUID
+     *
+     * @example
+     * ```ts
+     * await client.structures.delete('structure-uuid');
+     * ```
+     */
+    delete(structureId: string): Promise<ApiResponse<void>>;
+    /**
+     * Validate a structure definition without creating it.
+     * Useful for checking slug uniqueness and property validity before creation.
+     *
+     * @param input - The structure definition to validate
+     * @returns Validation result
+     *
+     * @example
+     * ```ts
+     * const result = await client.structures.validate({
+     *   slug: 'orders',
+     *   properties: [{ name: 'title', type: 'string' }]
+     * });
+     * ```
+     */
+    validate(input: ValidateStructureInput): Promise<ApiResponse<any>>;
+}
+/**
+ * CollectionsManager provides methods for managing data collections (schemas).
+ * Collections define the shape of records including properties, validation rules,
+ * and schema discovery modes.
+ * Access via `client.collections`.
+ *
+ * Usage:
+ * ```ts
+ * // List all collections
+ * const collections = await client.collections.list();
+ *
+ * // Create a new collection
+ * const collection = await client.collections.create({
+ *   name: 'Orders',
+ *   recordSlug: 'orders',
+ *   properties: [
+ *     { name: 'title', type: 'string', required: true },
+ *     { name: 'amount', type: 'number', minimum: 0 }
+ *   ]
+ * });
+ *
+ * // Validate before creating
+ * const validation = await client.collections.validate({ recordSlug: 'orders' });
+ * ```
+ */
+export declare class CollectionsManager {
+    private requestFn;
+    private workspaceId;
+    constructor(workspaceId: string, requestFn: <T>(method: Method, path: string, data?: any, queryParams?: Record<string, any>) => Promise<ApiResponse<T>>);
+    /**
+     * List all collections in the workspace.
+     *
+     * @param options - Optional list parameters (pagination)
+     * @returns List of collections
+     *
+     * @example
+     * ```ts
+     * const collections = await client.collections.list();
+     * const page2 = await client.collections.list({ page: 2, limit: 10 });
+     * ```
+     */
+    list(options?: ListCollectionsOptions): Promise<ApiResponse<Structure[]>>;
+    /**
+     * Get a collection by ID.
+     *
+     * @param collectionId - The collection UUID
+     * @returns The collection details
+     *
+     * @example
+     * ```ts
+     * const collection = await client.collections.get('collection-uuid');
+     * console.log('Properties:', collection.data.properties.length);
+     * ```
+     */
+    get(collectionId: string): Promise<ApiResponse<Structure>>;
+    /**
+     * Get a collection by its record slug.
+     *
+     * @param recordSlug - The collection's record slug (e.g., "orders")
+     * @returns The collection details
+     *
+     * @example
+     * ```ts
+     * const collection = await client.collections.getBySlug('orders');
+     * console.log('Collection name:', collection.data.name);
+     * ```
+     */
+    getBySlug(recordSlug: string): Promise<ApiResponse<Structure>>;
+    /**
+     * Create a new collection.
+     *
+     * @param input - The collection definition
+     * @returns The created collection
+     *
+     * @example
+     * ```ts
+     * const collection = await client.collections.create({
+     *   name: 'Orders',
+     *   recordSlug: 'orders',
+     *   description: 'Customer orders',
+     *   properties: [
+     *     { name: 'title', type: 'string', required: true },
+     *     { name: 'amount', type: 'number', minimum: 0 },
+     *     { name: 'status', type: 'string', enum: ['pending', 'completed'] }
+     *   ],
+     *   enableVersioning: true,
+     *   schemaDiscoveryMode: 'strict'
+     * });
+     * ```
+     */
+    create(input: CreateStructureInput): Promise<ApiResponse<Structure>>;
+    /**
+     * Update an existing collection.
+     *
+     * @param collectionId - The collection UUID
+     * @param input - The fields to update
+     * @returns The updated collection
+     *
+     * @example
+     * ```ts
+     * const updated = await client.collections.update('collection-uuid', {
+     *   name: 'Updated Orders',
+     *   properties: [
+     *     { name: 'title', type: 'string', required: true },
+     *     { name: 'amount', type: 'number', minimum: 0 },
+     *     { name: 'priority', type: 'number' }
+     *   ]
+     * });
+     * ```
+     */
+    update(collectionId: string, input: UpdateStructureInput): Promise<ApiResponse<Structure>>;
+    /**
+     * Delete a collection.
+     *
+     * @param collectionId - The collection UUID
+     *
+     * @example
+     * ```ts
+     * await client.collections.delete('collection-uuid');
+     * ```
+     */
+    delete(collectionId: string): Promise<ApiResponse<void>>;
+    /**
+     * Validate a collection definition without creating it.
+     * Useful for checking slug uniqueness and property validity before creation.
+     *
+     * @param input - The collection definition to validate
+     * @returns Validation result
+     *
+     * @example
+     * ```ts
+     * const result = await client.collections.validate({
+     *   slug: 'orders',
+     *   properties: [{ name: 'title', type: 'string' }]
+     * });
+     * ```
+     */
+    validate(input: ValidateStructureInput): Promise<ApiResponse<any>>;
+}
+/**
+ * ComputeFunctionsManager provides methods for managing compute functions.
+ * Compute functions are JavaScript code blocks that can be executed on triggers,
+ * schedules, or on-demand.
+ * Access via `client.functions`.
+ *
+ * Usage:
+ * ```ts
+ * // List all compute functions
+ * const fns = await client.functions.list();
+ *
+ * // Create a new function
+ * const fn = await client.functions.create({
+ *   name: 'Process Order',
+ *   code: 'async function run() { return { processed: true }; }'
+ * });
+ *
+ * // Test execute code without saving
+ * const result = await client.functions.testExecute({
+ *   code: 'async function run() { return executionParams; }',
+ *   params: { orderId: '123' }
+ * });
+ * ```
+ */
+export declare class ComputeFunctionsManager {
+    private requestFn;
+    private workspaceId;
+    constructor(workspaceId: string, requestFn: <T>(method: Method, path: string, data?: any, queryParams?: Record<string, any>) => Promise<ApiResponse<T>>);
+    /**
+     * List all compute functions in the workspace.
+     *
+     * @param options - Optional list parameters (pagination, search)
+     * @returns List of compute functions
+     *
+     * @example
+     * ```ts
+     * const fns = await client.functions.list();
+     * const searched = await client.functions.list({ search: 'order', limit: 10 });
+     * ```
+     */
+    list(options?: ListComputeFunctionsOptions): Promise<ApiResponse<ComputeFunction[]>>;
+    /**
+     * Get a compute function by ID.
+     *
+     * @param functionId - The compute function UUID
+     * @returns The compute function details
+     *
+     * @example
+     * ```ts
+     * const fn = await client.functions.get('function-uuid');
+     * console.log('Function name:', fn.data.name);
+     * ```
+     */
+    get(functionId: string): Promise<ApiResponse<ComputeFunction>>;
+    /**
+     * Create a new compute function.
+     *
+     * @param input - The function definition
+     * @returns The created compute function
+     *
+     * @example
+     * ```ts
+     * const fn = await client.functions.create({
+     *   name: 'Process Order',
+     *   code: 'async function run() { return { processed: true }; }',
+     *   description: 'Processes incoming orders',
+     *   timeoutMs: 60000
+     * });
+     * ```
+     */
+    create(input: CreateComputeFunctionInput): Promise<ApiResponse<ComputeFunction>>;
+    /**
+     * Update an existing compute function.
+     *
+     * @param functionId - The compute function UUID
+     * @param input - The fields to update
+     * @returns The updated compute function
+     *
+     * @example
+     * ```ts
+     * const updated = await client.functions.update('function-uuid', {
+     *   code: 'async function run() { return { v2: true }; }',
+     *   timeoutMs: 120000
+     * });
+     * ```
+     */
+    update(functionId: string, input: UpdateComputeFunctionInput): Promise<ApiResponse<ComputeFunction>>;
+    /**
+     * Delete a compute function.
+     *
+     * @param functionId - The compute function UUID
+     *
+     * @example
+     * ```ts
+     * await client.functions.delete('function-uuid');
+     * ```
+     */
+    delete(functionId: string): Promise<ApiResponse<void>>;
+    /**
+     * Test execute code without saving it as a function.
+     * Useful for validating function code before creating/updating.
+     *
+     * @param input - The code to test and optional input data
+     * @returns Test execution result including output, duration, and logs
+     *
+     * @example
+     * ```ts
+     * const result = await client.functions.testExecute({
+     *   code: 'async function run() { return { sum: executionParams.a + executionParams.b }; }',
+     *   params: { a: 1, b: 2 }
+     * });
+     * console.log('Output:', result.data.output); // { sum: 3 }
+     * console.log('Duration:', result.data.duration_ms, 'ms');
+     * ```
+     */
+    testExecute(input: TestComputeFunctionInput): Promise<ApiResponse<TestComputeFunctionResult>>;
+}
+/**
+ * Manager for querying function execution runs.
+ *
+ * Provides read access to function run history — useful for checking
+ * whether jobs completed, inspecting outputs, and monitoring trigger activity.
+ *
+ * Access via `client.runs`.
+ */
+export declare class FunctionRunsManager {
+    private requestFn;
+    private workspaceId;
+    constructor(workspaceId: string, requestFn: <T>(method: Method, path: string, data?: any, queryParams?: Record<string, any>) => Promise<ApiResponse<T>>);
+    /**
+     * Get a function run by ID.
+     *
+     * @param runId - The function run UUID
+     * @returns The function run details
+     *
+     * @example
+     * ```ts
+     * const run = await client.runs.get('run-uuid');
+     * console.log('Status:', run.data.status);
+     * console.log('Duration:', run.data.endedAt ? Date.parse(run.data.endedAt) - Date.parse(run.data.startedAt) : 'still running');
+     * ```
+     */
+    get(runId: string): Promise<ApiResponse<FunctionRun>>;
+    /**
+     * List runs for a specific trigger.
+     *
+     * @param triggerId - The trigger UUID
+     * @param options - Optional pagination and status filter
+     * @returns Paginated list of function runs
+     *
+     * @example
+     * ```ts
+     * // List recent runs for a trigger
+     * const runs = await client.runs.listByTrigger('trigger-uuid');
+     *
+     * // Filter to only failed runs
+     * const failed = await client.runs.listByTrigger('trigger-uuid', {
+     *   status: 'failure'
+     * });
+     * ```
+     */
+    listByTrigger(triggerId: string, options?: ListFunctionRunsOptions): Promise<ApiResponse<PaginatedResponse<FunctionRun>>>;
+    /**
+     * List runs for a specific compute function.
+     *
+     * @param functionId - The compute function UUID
+     * @param options - Optional pagination and status filter
+     * @returns Paginated list of function runs
+     *
+     * @example
+     * ```ts
+     * // List recent runs for a function
+     * const runs = await client.runs.listByFunction('function-uuid');
+     *
+     * // Only completed runs, page 2
+     * const completed = await client.runs.listByFunction('function-uuid', {
+     *   status: 'completed',
+     *   page: 2
+     * });
+     * ```
+     */
+    listByFunction(functionId: string, options?: ListFunctionRunsOptions): Promise<ApiResponse<PaginatedResponse<FunctionRun>>>;
+    /**
+     * Get the status of a compute job by job ID.
+     *
+     * This is the primary way to poll for the result of an async trigger
+     * invocation. The job ID is returned by `client.triggers.invoke()`.
+     *
+     * @param jobId - The job ID returned by invoke
+     * @returns Job status including returnValue (on success) or failedReason (on failure)
+     *
+     * @example
+     * ```ts
+     * // Invoke a trigger and poll for the result
+     * const { data: jobId } = await client.triggers.invoke('trigger-uuid');
+     *
+     * // Poll until complete
+     * let job;
+     * do {
+     *   await new Promise(r => setTimeout(r, 1000));
+     *   job = await client.runs.getJobStatus(jobId);
+     * } while (job.data.status === 'queued' || job.data.status === 'running');
+     *
+     * if (job.data.status === 'completed') {
+     *   console.log('Result:', job.data.returnValue);
+     * } else {
+     *   console.error('Failed:', job.data.failedReason);
+     * }
+     * ```
+     */
+    getJobStatus(jobId: string): Promise<ApiResponse<ComputeJobStatusResponse>>;
+}
+/**
+ * WebhookSubscriptionsManager provides methods for managing outbound webhook
+ * subscriptions and inspecting delivery history. Access via
+ * `centrali.webhookSubscriptions`.
+ *
+ * Subscriptions listen for record events (`record_created`, `record_updated`,
+ * `record_deleted`, `records_bulk_created`) and POST a signed JSON payload to
+ * your URL. Payloads are signed with HMAC-SHA256 using the subscription's
+ * `whsec_` secret and delivered in the `X-Signature` header.
+ *
+ * Usage:
+ * ```ts
+ * // Create a subscription
+ * const sub = await centrali.webhookSubscriptions.create({
+ *   name: 'Orders webhook',
+ *   url: 'https://my-app.example.com/webhooks/centrali',
+ *   events: [RecordEvents.CREATED, RecordEvents.UPDATED],
+ *   recordSlugs: ['orders'],
+ * });
+ * // The signing secret is returned on create — copy it now, it's not shown again.
+ * // `secret` is typed `string | undefined` (reads omit it), so assert here.
+ * console.log('Signing secret:', sub.data.secret!);
+ *
+ * // Rotate the secret (immediate cutover)
+ * const rotated = await centrali.webhookSubscriptions.rotateSecret(sub.data.id);
+ *
+ * // Inspect delivery history
+ * const deliveries = await centrali.webhookSubscriptions.deliveries.list(sub.data.id);
+ *
+ * // Replay a delivery
+ * await centrali.webhookSubscriptions.deliveries.retry(deliveryId);
+ * ```
+ */
+export declare class WebhookSubscriptionsManager {
+    private requestFn;
+    private workspaceId;
+    /**
+     * Delivery history and replay controls. Deliveries are per-subscription for
+     * list/get, but retry/cancel are workspace-scoped — the backend routes
+     * those under `/webhook-subscriptions/deliveries/{id}/retry|cancel`, so the
+     * subscription ID is not needed to replay or cancel.
+     */
+    readonly deliveries: {
+        /**
+         * List deliveries for a subscription. Rows omit `requestPayload` and
+         * `responseBody` — use `deliveries.get()` to fetch the full record.
+         * `result.data` is the array of trimmed rows; `result.meta` carries
+         * the pagination counters (`total`, `limit`, `offset`).
+         */
+        list: (subscriptionId: string, options?: ListWebhookDeliveriesOptions) => Promise<ApiResponse<WebhookDeliverySummary[]> & {
+            meta?: WebhookDeliveriesListMeta;
+        }>;
+        /** Get a single delivery including the full payload and response body. */
+        get: (subscriptionId: string, deliveryId: string) => Promise<ApiResponse<WebhookDelivery>>;
+        /**
+         * Replay a previously recorded delivery. Queues a new delivery row
+         * pointing at `replayedFrom` the original. Returns the new delivery ID.
+         */
+        retry: (deliveryId: string) => Promise<ApiResponse<WebhookReplayResponse>>;
+        /**
+         * Cancel a delivery that is currently in `retrying` status. Flips the
+         * row to `failed` with `lastError = 'Cancelled by user'`.
+         */
+        cancel: (deliveryId: string) => Promise<ApiResponse<WebhookCancelResponse>>;
+    };
+    constructor(workspaceId: string, requestFn: <T>(method: Method, path: string, data?: any, queryParams?: Record<string, any>) => Promise<ApiResponse<T>>);
+    /**
+     * List all webhook subscriptions in the workspace.
+     *
+     * @example
+     * ```ts
+     * const subs = await centrali.webhookSubscriptions.list();
+     * for (const sub of subs.data) console.log(sub.name, sub.url);
+     * ```
+     */
+    list(): Promise<ApiResponse<WebhookSubscription[]>>;
+    /**
+     * Get a webhook subscription by ID.
+     * @param subscriptionId - The subscription UUID
+     */
+    get(subscriptionId: string): Promise<ApiResponse<WebhookSubscription>>;
+    /**
+     * Create a webhook subscription. The response `secret` field is only
+     * populated on this call (and on `rotateSecret`) — copy it immediately;
+     * subsequent `get`/`list` responses do not return the secret.
+     *
+     * @example
+     * ```ts
+     * const sub = await centrali.webhookSubscriptions.create({
+     *   name: 'Order notifications',
+     *   url: 'https://api.example.com/hooks/centrali',
+     *   events: [RecordEvents.CREATED, RecordEvents.UPDATED],
+     *   recordSlugs: ['orders'],
+     * });
+     * const signingSecret = sub.data.secret; // copy once — not returned on reads
+     * ```
+     */
+    create(input: CreateWebhookSubscriptionInput): Promise<ApiResponse<WebhookSubscription>>;
+    /**
+     * Update fields on a webhook subscription. The signing secret is managed
+     * by the server — use `rotateSecret()` to regenerate it.
+     */
+    update(subscriptionId: string, patch: UpdateWebhookSubscriptionInput): Promise<ApiResponse<WebhookSubscription>>;
+    /** Delete a webhook subscription. Existing delivery history is retained. */
+    delete(subscriptionId: string): Promise<ApiResponse<void>>;
+    /**
+     * Rotate the signing secret. Immediate cutover — the previous secret stops
+     * signing on the next dispatch. The response includes the new secret;
+     * capture it before closing the response.
+     */
+    rotateSecret(subscriptionId: string): Promise<ApiResponse<WebhookSubscription>>;
+}
+/**
+ * Main Centrali SDK client.
+ */
+export declare class CentraliSDK {
+    private axios;
+    private token;
+    private options;
+    private _realtime;
+    private _triggers;
+    private _smartQueries;
+    private _anomalyInsights;
+    private _validation;
+    private _orchestrations;
+    private _allowedDomains;
+    private _structures;
+    private _collections;
+    private _functions;
+    private _runs;
+    private _webhookSubscriptions;
+    private isRefreshingToken;
+    private tokenRefreshPromise;
+    constructor(options: CentraliSDKOptions);
+    /**
+     * Realtime namespace for subscribing to SSE events.
+     *
+     * Usage:
+     * ```ts
+     * const sub = client.realtime.subscribe({
+     *   structures: ['order'],
+     *   events: ['record_created', 'record_updated'],
+     *   onEvent: (event) => console.log(event),
+     * });
+     * // Later: sub.unsubscribe();
+     * ```
+     *
+     * IMPORTANT: Initial Sync Pattern
+     * Realtime delivers only new events after connection. For dashboards and lists:
+     * 1. Fetch current records first
+     * 2. Subscribe to realtime
+     * 3. Apply diffs while UI shows the snapshot
+     */
+    get realtime(): RealtimeManager;
+    /**
+     * Get the current token, or fetch one using client credentials if available.
+     * This ensures realtime subscriptions work without needing a prior HTTP request.
+     */
+    private getTokenOrFetch;
+    /**
+     * Triggers namespace for invoking and managing function triggers.
+     *
+     * Usage:
+     * ```ts
+     * // Invoke an on-demand trigger
+     * const job = await client.triggers.invoke('trigger-id');
+     *
+     * // Invoke with custom payload
+     * const job = await client.triggers.invoke('trigger-id', {
+     *   payload: { orderId: '12345' }
+     * });
+     *
+     * // Get trigger details
+     * const trigger = await client.triggers.get('trigger-id');
+     *
+     * // List all triggers
+     * const triggers = await client.triggers.list();
+     * ```
+     */
+    get triggers(): TriggersManager;
+    /**
+     * Smart Queries namespace for listing and executing smart queries.
+     *
+     * Usage:
+     * ```ts
+     * // List all smart queries in workspace
+     * const allQueries = await client.smartQueries.listAll();
+     *
+     * // List smart queries for a structure
+     * const queries = await client.smartQueries.list('employee');
+     *
+     * // Get a smart query by name
+     * const query = await client.smartQueries.getByName('employee', 'Active Employees');
+     *
+     * // Execute a smart query
+     * const results = await client.smartQueries.execute('employee', query.data.id);
+     * console.log('Found:', results.data.length, 'records');
+     * ```
+     */
+    get smartQueries(): SmartQueriesManager;
+    /**
+     * Anomaly Insights namespace for querying and managing AI-generated insights.
+     *
+     * Usage:
+     * ```ts
+     * // List all active critical insights
+     * const insights = await client.anomalyInsights.list({
+     *   status: 'active',
+     *   severity: 'critical'
+     * });
+     *
+     * // Get insights for a specific structure
+     * const orderInsights = await client.anomalyInsights.listByStructure('orders');
+     *
+     * // Get insight summary
+     * const summary = await client.anomalyInsights.getSummary();
+     * console.log('Critical:', summary.data.bySeverity.critical);
+     *
+     * // Acknowledge an insight
+     * await client.anomalyInsights.acknowledge('insight-id');
+     *
+     * // Dismiss an insight
+     * await client.anomalyInsights.dismiss('insight-id');
+     * ```
+     */
+    get anomalyInsights(): AnomalyInsightsManager;
+    /**
+     * Validation namespace for AI-powered data quality validation.
+     *
+     * Features:
+     * - Trigger batch validation scans on structures
+     * - List and manage validation suggestions (typos, format issues, duplicates)
+     * - Accept or reject suggestions to fix data
+     *
+     * Usage:
+     * ```ts
+     * // Trigger a batch scan
+     * const batch = await client.validation.triggerScan('orders');
+     *
+     * // Wait for completion
+     * const result = await client.validation.waitForScan(batch.data.batchId);
+     *
+     * // List pending suggestions
+     * const suggestions = await client.validation.listSuggestions({ status: 'pending' });
+     *
+     * // Accept a suggestion (applies the fix)
+     * await client.validation.accept('suggestion-id');
+     * ```
+     */
+    get validation(): ValidationManager;
+    /**
+     * Orchestrations namespace for managing multi-step workflows.
+     *
+     * Orchestrations chain compute functions together with conditional logic,
+     * delays, and decision branches to automate complex business processes.
+     *
+     * Usage:
+     * ```ts
+     * // List all orchestrations
+     * const orchestrations = await client.orchestrations.list();
+     *
+     * // Trigger an on-demand orchestration
+     * const run = await client.orchestrations.trigger('orch-id', {
+     *   input: { orderId: '12345' }
+     * });
+     *
+     * // Get run status
+     * const runStatus = await client.orchestrations.getRun('orch-id', run.data.id);
+     *
+     * // Create a new orchestration
+     * const orch = await client.orchestrations.create({
+     *   slug: 'order-processing',
+     *   name: 'Order Processing',
+     *   trigger: { type: 'on-demand' },
+     *   steps: [
+     *     { id: 'validate', type: 'compute', functionId: 'func_validate', onSuccess: { nextStepId: 'process' } },
+     *     { id: 'process', type: 'compute', functionId: 'func_process' }
+     *   ]
+     * });
+     * ```
+     */
+    get orchestrations(): OrchestrationsManager;
+    /**
+     * Allowed Domains namespace for managing compute function external call domains.
+     *
+     * Usage:
+     * ```ts
+     * // List all allowed domains
+     * const domains = await client.allowedDomains.list();
+     *
+     * // Add a new domain
+     * const domain = await client.allowedDomains.add({ domain: 'api.stripe.com' });
+     *
+     * // Remove a domain
+     * await client.allowedDomains.remove('domain-id');
+     * ```
+     */
+    get allowedDomains(): AllowedDomainsManager;
+    /**
+     * Structures namespace for managing data structures (schemas).
+     * Provides CRUD operations and validation for structure definitions.
+     *
+     * Usage:
+     * ```ts
+     * // List all structures
+     * const structures = await client.structures.list();
+     *
+     * // Create a structure
+     * const structure = await client.structures.create({
+     *   name: 'Orders',
+     *   slug: 'orders',
+     *   properties: [{ name: 'title', type: 'string', required: true }]
+     * });
+     *
+     * // Validate before creating
+     * const result = await client.structures.validate({ slug: 'orders' });
+     * ```
+     */
+    get structures(): StructuresManager;
+    /**
+     * Collections namespace for managing data collections (schemas).
+     * Provides CRUD operations and validation for collection definitions.
+     * This is the preferred API — use `client.collections` instead of `client.structures`.
+     *
+     * Usage:
+     * ```ts
+     * // List all collections
+     * const collections = await client.collections.list();
+     *
+     * // Create a collection
+     * const collection = await client.collections.create({
+     *   name: 'Orders',
+     *   slug: 'orders',
+     *   properties: [{ name: 'title', type: 'string', required: true }]
+     * });
+     *
+     * // Validate before creating
+     * const result = await client.collections.validate({ slug: 'orders' });
+     * ```
+     */
+    get collections(): CollectionsManager;
+    /**
+     * Functions namespace for managing compute functions.
+     * Provides CRUD operations and test execution for compute function code.
+     *
+     * Usage:
+     * ```ts
+     * // List all functions
+     * const fns = await client.functions.list();
+     *
+     * // Create a function
+     * const fn = await client.functions.create({
+     *   name: 'Process Order',
+     *   code: 'async function run() { return { ok: true }; }'
+     * });
+     *
+     * // Test execute without saving
+     * const result = await client.functions.testExecute({
+     *   code: 'async function run() { return executionParams; }',
+     *   params: { test: true }
+     * });
+     * ```
+     */
+    get functions(): ComputeFunctionsManager;
+    /**
+     * Runs namespace for querying execution history.
+     *
+     * Usage:
+     * ```ts
+     * // Get a specific run
+     * const run = await client.runs.get('run-id');
+     *
+     * // List runs for a trigger
+     * const runs = await client.runs.listByTrigger('trigger-id');
+     *
+     * // List failed runs for a compute definition
+     * const failed = await client.runs.listByFunction('fn-id', {
+     *   status: 'failure'
+     * });
+     * ```
+     */
+    get runs(): FunctionRunsManager;
+    /**
+     * Webhook subscriptions namespace for outbound webhooks — create, update,
+     * rotate signing secrets, inspect delivery history, and replay/cancel
+     * individual deliveries.
+     *
+     * Usage:
+     * ```ts
+     * // Create a subscription (capture secret immediately — not returned on reads)
+     * const sub = await centrali.webhookSubscriptions.create({
+     *   name: 'Order notifications',
+     *   url: 'https://api.example.com/hooks/centrali',
+     *   events: [RecordEvents.CREATED, RecordEvents.UPDATED],
+     *   recordSlugs: ['orders'],
+     * });
+     *
+     * // Rotate the signing secret (immediate cutover)
+     * const rotated = await centrali.webhookSubscriptions.rotateSecret(sub.data.id);
+     *
+     * // Inspect deliveries
+     * const deliveries = await centrali.webhookSubscriptions.deliveries.list(sub.data.id, {
+     *   status: 'failed'
+     * });
+     *
+     * // Replay a failed delivery
+     * await centrali.webhookSubscriptions.deliveries.retry(deliveries.data[0].id);
+     * ```
+     */
+    get webhookSubscriptions(): WebhookSubscriptionsManager;
+    /**
+     * Manually set or update the bearer token for subsequent requests.
+     */
+    setToken(token: string): void;
+    /**
+     * Fetch Service Account token using Client Credentials flow.
+     */
+    fetchServiceAccountToken(): Promise<string>;
+    /**
+     * Perform an HTTP request.
+     */
+    private request;
+    /** Create a new record in a given recordSlug. */
+    createRecord<T = any>(recordSlug: string, record: Record<string, any>, options?: RecordTtlOptions): Promise<ApiResponse<T>>;
+    /** Get the token used for authentication. */
+    getToken(): string | null;
+    /**
+     * Retrieve a record by ID.
+     *
+     * @param recordSlug - The structure's record slug
+     * @param id - The record ID
+     * @param options - Optional parameters including expand for reference fields
+     *
+     * @example
+     * // Basic fetch
+     * const order = await centrali.getRecord('Order', 'order-123');
+     *
+     * // With expanded references
+     * const order = await centrali.getRecord('Order', 'order-123', {
+     *   expand: 'customer,items'
+     * });
+     * // Access expanded data: order.data.data._expanded.customer
+     */
+    getRecord<T = any>(recordSlug: string, id: string, options?: GetRecordOptions): Promise<ApiResponse<T>>;
+    /**
+     * Query records with filters, pagination, sorting, and reference expansion.
+     *
+     * IMPORTANT: Filters are passed at the TOP LEVEL, not nested under 'filter'.
+     * Use 'data.' prefix for custom fields and bracket notation for operators.
+     *
+     * @param recordSlug - The structure's record slug
+     * @param queryParams - Query parameters (filters at top level, plus sort, pagination, expand)
+     *
+     * @example
+     * // Simple equality filter
+     * const activeProducts = await centrali.queryRecords('Product', {
+     *   'data.status': 'active',
+     *   sort: '-createdAt',
+     *   page: 1,
+     *   pageSize: 10
+     * });
+     *
+     * // Filter with operators (bracket notation)
+     * const products = await centrali.queryRecords('Product', {
+     *   'data.inStock': true,
+     *   'data.price[lte]': 100,
+     *   sort: '-createdAt',
+     *   pageSize: 10
+     * });
+     *
+     * // Multiple values with 'in' operator (comma-separated string)
+     * const orders = await centrali.queryRecords('Order', {
+     *   'data.status[in]': 'pending,processing',
+     *   expand: 'customer,items'
+     * });
+     * // Access expanded data: orders.data[0].data._expanded.customer
+     *
+     * // Range filters
+     * const customers = await centrali.queryRecords('Customer', {
+     *   'data.age[gte]': 18,
+     *   'data.age[lte]': 65,
+     *   'data.verified': true
+     * });
+     *
+     * // Filter with 'ne' (not equal)
+     * const availableItems = await centrali.queryRecords('Product', {
+     *   'data.status[ne]': 'discontinued',
+     *   pageSize: 100
+     * });
+     */
+    queryRecords<T = any>(recordSlug: string, queryParams?: QueryRecordOptions): Promise<ApiResponse<T>>;
+    /** Get records by Ids. */
+    getRecordsByIds<T = any>(recordSlug: string, ids: string[]): Promise<ApiResponse<T[]>>;
+    /** Update an existing record by ID. */
+    updateRecord<T = any>(recordSlug: string, id: string, updates: Record<string, any>, options?: RecordTtlOptions): Promise<ApiResponse<T>>;
+    /**
+     * Upsert a record: find by match fields, update if exists, create if not.
+     * Uses advisory locking for atomicity — safe for concurrent calls.
+     *
+     * @param recordSlug - The structure's record slug
+     * @param options - { match: key-value pairs to find existing record, data: full record data }
+     * @returns Response where result.data is the record and result.operation indicates create/update
+     *
+     * @example
+     * const result = await client.upsertRecord('HourlyRollup', {
+     *   match: { metricKey: 'pageviews', bucketHour: '2025-01-01T10:00' },
+     *   data: { metricKey: 'pageviews', bucketHour: '2025-01-01T10:00', count: 42 },
+     * });
+     * // result.data → the record
+     * // result.operation → 'created' or 'updated'
+     */
+    upsertRecord<T = any>(recordSlug: string, options: {
+        match: Record<string, any>;
+        data: Record<string, any>;
+    }): Promise<ApiResponse<T> & {
+        operation: 'created' | 'updated';
+    }>;
+    /** Delete a record by ID (soft delete by default, can be restored). */
+    deleteRecord(recordSlug: string, id: string, options?: DeleteRecordOptions): Promise<ApiResponse<null>>;
+    /** Restore a soft-deleted record by ID. */
+    restoreRecord(recordSlug: string, id: string): Promise<ApiResponse<null>>;
+    /**
+     * Reveal plaintext values of secret fields for a record.
+     * Requires secrets:reveal permission.
+     *
+     * @param recordSlug - The structure's record slug
+     * @param id - The record ID
+     * @param fields - Optional array of specific secret field names to reveal
+     * @returns Object with field names as keys and plaintext secret values
+     *
+     * @example
+     * ```ts
+     * // Reveal all secrets
+     * const result = await client.revealSecrets('users', 'record-123');
+     * console.log(result.data.revealed.apiKey); // "sk_live_..."
+     *
+     * // Reveal specific fields
+     * const result = await client.revealSecrets('users', 'record-123', ['apiKey']);
+     * ```
+     */
+    revealSecrets(recordSlug: string, id: string, fields?: string[]): Promise<ApiResponse<{
+        revealed: Record<string, any>;
+    }>>;
+    /**
+     * Compare a candidate value against a secret field without revealing the stored secret.
+     * Requires secrets:compare permission.
+     *
+     * @param recordSlug - The structure's record slug
+     * @param id - The record ID
+     * @param field - The secret field name to compare against
+     * @param value - The candidate value to compare
+     * @returns Boolean indicating if the values match
+     *
+     * @example
+     * ```ts
+     * const result = await client.compareSecret('users', 'record-123', 'apiKey', 'sk_live_test');
+     * if (result.data.matches) {
+     *   console.log('API key is valid');
+     * }
+     * ```
+     */
+    compareSecret(recordSlug: string, id: string, field: string, value: string): Promise<ApiResponse<{
+        matches: boolean;
+    }>>;
+    /**
+     * Upload a file to the storage service.
+     *
+     * @param file - The file to upload
+     * @param location - Target folder path (e.g., '/root/shared/images'). Defaults to '/root/shared' if not specified.
+     *                   /root/shared always exists. For custom subfolders, create them first with createFolder().
+     * @param isPublic - If true, the file will be publicly accessible without authentication. Defaults to false.
+     * @returns The file URL or render ID
+     *
+     * @example
+     * ```ts
+     * // Upload to default location (/root/shared)
+     * const result = await client.uploadFile(file);
+     *
+     * // Upload to specific folder
+     * const result = await client.uploadFile(file, '/root/shared/images');
+     *
+     * // Upload as public file
+     * const result = await client.uploadFile(file, '/root/shared/public', true);
+     * ```
+     */
+    uploadFile(file: File, location?: string, isPublic?: boolean): Promise<ApiResponse<string>>;
+    /**
+     * Create a folder in the storage service.
+     * Use this to create subfolders under /root/shared (which always exists).
+     *
+     * @param name - The folder name (e.g., 'logos', 'avatars')
+     * @param location - Parent folder path (e.g., '/root/shared'). Defaults to '/root/shared'.
+     * @returns The created folder object
+     *
+     * @example
+     * ```ts
+     * // Create a folder under /root/shared
+     * const folder = await client.createFolder('logos', '/root/shared');
+     * // Result: folder at /root/shared/logos
+     *
+     * // Then upload to it
+     * const { data: renderId } = await client.uploadFile(file, '/root/shared/logos', true);
+     * ```
+     */
+    createFolder(name: string, location?: string): Promise<ApiResponse<any>>;
+    /**
+     * List folders in the workspace, optionally filtered by parent location.
+     *
+     * @param location - Parent folder path to list contents of (e.g., '/root/shared'). If omitted, lists top-level folders.
+     * @returns Array of folder objects
+     *
+     * @example
+     * ```ts
+     * // List all folders under /root/shared
+     * const folders = await client.listFolders('/root/shared');
+     *
+     * // Check if a folder exists before uploading
+     * const folders = await client.listFolders('/root/shared');
+     * const hasLogos = folders.data.some(f => f.name === 'logos');
+     * if (!hasLogos) {
+     *     await client.createFolder('logos', '/root/shared');
+     * }
+     * ```
+     */
+    listFolders(location?: string): Promise<ApiResponse<any[]>>;
+    /**
+     * Get a specific folder by ID.
+     *
+     * @param folderId - The folder ID (UUID)
+     * @returns The folder object
+     */
+    getFolder(folderId: string): Promise<ApiResponse<any>>;
+    /**
+     * List sub-folders within a specific folder.
+     *
+     * @param folderId - The parent folder ID (UUID)
+     * @returns Array of sub-folder objects
+     */
+    listSubFolders(folderId: string): Promise<ApiResponse<any[]>>;
+    /**
+     * Delete a folder by ID. System folders (/root, /root/shared, /root/users) cannot be deleted.
+     *
+     * @param folderId - The folder ID (UUID) to delete
+     */
+    deleteFolder(folderId: string): Promise<ApiResponse<void>>;
+    /**
+     * Get the render URL for a file. Use this URL to display files inline (e.g., images in img tags).
+     * Supports optional image transformation parameters.
+     *
+     * @param renderId - The render ID returned from uploadFile()
+     * @param options - Optional image transformation parameters
+     * @returns The full render URL
+     *
+     * @example
+     * ```ts
+     * // Basic render URL
+     * const url = client.getFileRenderUrl('abc123');
+     * // => "https://api.centrali.io/storage/ws/my-workspace/api/v1/render/abc123"
+     *
+     * // With image transformations
+     * const thumbUrl = client.getFileRenderUrl('abc123', { width: 200 });
+     * const compressedUrl = client.getFileRenderUrl('abc123', { width: 800, quality: 60, format: 'webp' });
+     * ```
+     */
+    getFileRenderUrl(renderId: string, options?: {
+        width?: number;
+        height?: number;
+        quality?: number;
+        format?: 'jpeg' | 'png' | 'webp';
+    }): string;
+    /**
+     * Get the download URL for a file. Use this URL to download files as attachments.
+     *
+     * @param renderId - The render ID returned from uploadFile()
+     * @returns The full download URL
+     *
+     * @example
+     * ```ts
+     * const downloadUrl = client.getFileDownloadUrl('abc123');
+     * // => "https://api.centrali.io/storage/ws/my-workspace/api/v1/download/abc123"
+     * ```
+     */
+    getFileDownloadUrl(renderId: string): string;
+    /**
+     * Search records across the workspace using full-text search.
+     *
+     * @param query - The search query string
+     * @param options - Optional search parameters
+     * @returns Search results with hits and metadata
+     *
+     * @example
+     * ```ts
+     * // Basic search
+     * const results = await client.search('customer email');
+     * console.log('Found:', results.data.totalHits, 'results');
+     * results.data.hits.forEach(hit => console.log(hit.id, hit.structureSlug));
+     *
+     * // Search with structure filter
+     * const userResults = await client.search('john', { structures: 'users' });
+     *
+     * // Search multiple structures with limit
+     * const results = await client.search('active', {
+     *   structures: ['users', 'orders'],
+     *   limit: 50
+     * });
+     * ```
+     */
+    search(query: string, options?: SearchOptions): Promise<ApiResponse<SearchResponse>>;
+    /**
+     * Check if an action is authorized for an external token.
+     *
+     * Use this method when you want to authorize access using tokens from your
+     * own identity provider (Clerk, Auth0, Okta, etc.) instead of Centrali's
+     * built-in authentication.
+     *
+     * **Use Cases:**
+     * 1. **AuthZ-as-a-Service**: Define custom resources (orders, invoices) in Centrali
+     *    and use it purely for authorization decisions.
+     * 2. **External IdP for Centrali resources**: Access Centrali data (records, files)
+     *    using your corporate IdP tokens.
+     *
+     * **Prerequisites:**
+     * - Configure an External Auth Provider in Centrali Console (Settings → External Auth)
+     * - Define claim mappings to extract attributes from your JWT
+     * - Create policies that reference the extracted attributes (prefixed with `ext_`)
+     *
+     * @example
+     * // Simple authorization check
+     * const result = await client.checkAuthorization({
+     *   token: clerkJWT,
+     *   resource: 'orders',
+     *   action: 'read'
+     * });
+     *
+     * if (result.data.allowed) {
+     *   // Proceed with the action
+     * }
+     *
+     * @example
+     * // Authorization with context for policy evaluation
+     * const result = await client.checkAuthorization({
+     *   token: clerkJWT,
+     *   resource: 'orders',
+     *   action: 'approve',
+     *   context: {
+     *     orderId: 'order-123',
+     *     orderAmount: 50000,
+     *     department: 'sales'
+     *   }
+     * });
+     *
+     * // Policy can check: ext_role == 'manager' AND request_metadata.orderAmount > 10000
+     *
+     * @param options - Authorization check options
+     * @returns Promise resolving to the authorization result
+     */
+    checkAuthorization(options: CheckAuthorizationOptions): Promise<ApiResponse<AuthorizationResult>>;
+}
+export {};
+/**
+ * Usage Example:
+ *
+ * ```ts
+ * import { CentraliSDK, CentraliSDKOptions } from 'centrali-sdk';
+ *
+ * const options: CentraliSDKOptions = {
+ *   baseUrl: 'https://centrali.io',
+ *   workspaceId: 'my-workspace',
+ *   clientId: process.env.CLIENT_ID,
+ *   clientSecret: process.env.CLIENT_SECRET,
+ * };
+ * const client = new CentraliSDK(options);
+ *
+ * // Automatic client credentials flow on first request
+ * const record = await client.createRecord('Customer', { email: 'jane@example.com' });
+ *
+ * // Or set a user token:
+ * client.setToken('<JWT_TOKEN>');
+ * await client.queryRecords('Product', { pageSize: 10 });
+ *
+ * // Subscribe to realtime events (Initial Sync Pattern):
+ * // 1. First fetch initial data (filters at TOP LEVEL, not nested)
+ * const orders = await client.queryRecords('Order', { 'data.status': 'pending' });
+ * setOrders(orders.data);
+ *
+ * // 2. Then subscribe to realtime updates
+ * const subscription = client.realtime.subscribe({
+ *   structures: ['Order'],
+ *   events: ['record_created', 'record_updated', 'record_deleted'],
+ *   onEvent: (event) => {
+ *     // 3. Apply updates to UI
+ *     console.log('Event:', event.event, event.recordSlug, event.recordId);
+ *   },
+ *   onError: (error) => console.error('Realtime error:', error),
+ *   onConnected: () => console.log('Connected'),
+ *   onDisconnected: (reason) => console.log('Disconnected:', reason),
+ * });
+ *
+ * // Cleanup when done
+ * subscription.unsubscribe();
+ *
+ * // Invoke an on-demand trigger:
+ * const job = await client.triggers.invoke('trigger-id');
+ * console.log('Job queued:', job.data);
+ *
+ * // Invoke trigger with custom payload:
+ * const job2 = await client.triggers.invoke('trigger-id', {
+ *   payload: { orderId: '12345', action: 'process' }
+ * });
+ *
+ * // Get trigger details:
+ * const trigger = await client.triggers.get('trigger-id');
+ * console.log('Trigger:', trigger.data.name, trigger.data.executionType);
+ *
+ * // List all triggers:
+ * const triggers = await client.triggers.list();
+ * triggers.data.forEach(t => console.log(t.name));
+ *
+ * // ---- Smart Queries ----
+ *
+ * // List all smart queries in the workspace:
+ * const allQueries = await client.smartQueries.listAll();
+ *
+ * // List smart queries for a specific structure:
+ * const employeeQueries = await client.smartQueries.list('employee');
+ * employeeQueries.data.forEach(q => console.log(q.name));
+ *
+ * // Get a smart query by name:
+ * const activeQuery = await client.smartQueries.getByName('employee', 'Active Employees');
+ * console.log('Query ID:', activeQuery.data.id);
+ *
+ * // Execute a smart query:
+ * const results = await client.smartQueries.execute('employee', activeQuery.data.id);
+ * console.log('Found:', results.data.length, 'employees');
+ *
+ * // ---- Search ----
+ *
+ * // Basic full-text search:
+ * const searchResults = await client.search('customer email');
+ * console.log('Found:', searchResults.data.totalHits, 'results');
+ * searchResults.data.hits.forEach(hit => console.log(hit.id, hit.structureSlug));
+ *
+ * // Search with structure filter:
+ * const userResults = await client.search('john', { structures: 'users' });
+ *
+ * // Search multiple structures with limit:
+ * const multiResults = await client.search('active', {
+ *   structures: ['users', 'orders'],
+ *   limit: 50
+ * });
+ *
+ * // ---- Authorization (BYOT - Bring Your Own Token) ----
+ *
+ * // Simple authorization check with external IdP token:
+ * const authResult = await client.checkAuthorization({
+ *   token: clerkJWT, // Token from Clerk, Auth0, Okta, etc.
+ *   resource: 'orders',
+ *   action: 'read'
+ * });
+ *
+ * if (authResult.data.allowed) {
+ *   console.log('Access granted');
+ * } else {
+ *   console.log('Access denied:', authResult.data.message);
+ * }
+ *
+ * // Authorization with context for policy evaluation:
+ * const approveResult = await client.checkAuthorization({
+ *   token: clerkJWT,
+ *   resource: 'orders',
+ *   action: 'approve',
+ *   context: {
+ *     orderId: 'order-123',
+ *     orderAmount: 50000,
+ *     department: 'sales'
+ *   }
+ * });
+ * // Policy can reference: ext_role, ext_department (from JWT claims)
+ * // and request_metadata.orderId, request_metadata.orderAmount (from context)
+ *```
+ */