@cadenza.io/service 2.18.2 → 2.19.0

package/dist/Cadenza-DCMs7q97.d.ts

@@ -0,0 +1,1666 @@
+import { Task, ThrottleTagGetter, Schema, GraphContext, AnyObject, InquiryOptions, TaskResult, GraphRoutine, SchemaDefinition, Actor, SignalBroker, InquiryBroker, GraphRunner, GraphRegistry, CadenzaMode, EmitOptions, Intent, RuntimeValidationPolicy, RuntimeValidationScope, TaskOptions, ActorSpec, ActorFactoryOptions, ActorDefinition, TaskFunction, DebounceOptions, DebounceTask, EphemeralTaskOptions, EphemeralTask } from '@cadenza.io/core';
+
+/**
+ * Represents a task that delegates execution of a routine to a remote system or service.
+ * The `DeputyTask` serves as a proxy to perform and track the progress of a remote workflow.
+ * It extends the `Task` class with additional delegation capabilities.
+ *
+ * Emits various meta-signals for monitoring delegation progress and resolution.
+ */
+declare class DeputyTask extends Task {
+    readonly isDeputy: boolean;
+    protected readonly remoteRoutineName: string;
+    protected serviceName: string | undefined;
+    registeredDeputyMap: boolean;
+    /**
+     * Constructs a new instance of the class with the specified parameters.
+     *
+     * @param {string} name - The name of the task.
+     * @param {string} remoteRoutineName - The name of the remote routine to delegate tasks to.
+     * @param {string | undefined} [serviceName=undefined] - The name of the service associated with the task.
+     * @param {string} [description=""] - A brief description of the task.
+     * @param {number} [concurrency=0] - The concurrency level of the task.
+     * @param {number} [timeout=0] - The timeout duration for the task.
+     * @param {boolean} [register=true] - Whether the task should be registered in the system.
+     * @param {boolean} [isUnique=false] - Whether the task is unique.
+     * @param {boolean} [isMeta=false] - Whether the task is a meta task.
+     * @param {boolean} [isSubMeta=false] - Whether the task is a sub-meta task.
+     * @param {boolean} [isHidden=false] - Whether the task is hidden from the system.
+     * @param {ThrottleTagGetter | undefined} [getTagCallback=undefined] - A callback function to retrieve throttle tags.
+     * @param {SchemaDefinition | undefined} [inputSchema=undefined] - The input schema definition for the task.
+     * @param {boolean} [validateInputContext=false] - Whether to validate the input context against the input schema.
+     * @param {SchemaDefinition | undefined} [outputSchema=undefined] - The output schema definition for the task.
+     * @param {boolean} [validateOutputContext=false] - Whether to validate the output context against the output schema.
+     * @param {number} [retryCount=0] - The number of retries allowed for task execution.
+     * @param {number} [retryDelay=0] - The initial delay between retries in milliseconds.
+     * @param {number} [retryDelayMax=0] - The maximum retry delay in milliseconds.
+     * @param {number} [retryDelayFactor=1] - The factor by which to increase the retry delay for subsequent retries.
+     * @return {void} This constructor does not return a value.
+     */
+    constructor(name: string, remoteRoutineName: string, serviceName?: string | undefined, description?: string, concurrency?: number, timeout?: number, register?: boolean, isUnique?: boolean, isMeta?: boolean, isSubMeta?: boolean, isHidden?: boolean, getTagCallback?: ThrottleTagGetter | undefined, inputSchema?: Schema | undefined, validateInputContext?: boolean, outputSchema?: Schema | undefined, validateOutputContext?: boolean, retryCount?: number, retryDelay?: number, retryDelayMax?: number, retryDelayFactor?: number);
+    /**
+     * Executes the specified task function within the provided execution context.
+     *
+     * @param {GraphContext} context - The execution context containing methods and metadata for task execution.
+     * @param {function(string, AnyObject): void} emit - A function for emitting signals with associated data during execution.
+     * @param inquire
+     * @param {function(number): void} progressCallback - A callback function to report progress updates during task processing.
+     * @param {{ nodeId: string, routineExecId: string }} nodeData - Object containing identifiers for the node and routine execution.
+     * @return {TaskResult} Returns the result of the task function execution.
+     */
+    execute(context: GraphContext, emit: (signal: string, ctx: AnyObject) => void, inquire: (inquiry: string, context: AnyObject, options: InquiryOptions) => Promise<AnyObject>, progressCallback: (progress: number) => void, nodeData: {
+        nodeId: string;
+        routineExecId: string;
+    }): TaskResult;
+}
+
+type DbOperationType$1 = "query" | "insert" | "update" | "delete";
+type QueryMode = "rows" | "count" | "exists" | "one" | "aggregate";
+type AggregateFunction = "count" | "sum" | "avg" | "min" | "max";
+interface AggregateDefinition {
+    fn: AggregateFunction;
+    field?: string;
+    as?: string;
+    distinct?: boolean;
+}
+type SortDirection = "asc" | "desc";
+interface JoinDefinition {
+    on: string;
+    fields: string[];
+    returnAs?: "array" | "object";
+    filter?: AnyObject;
+    alias?: string;
+    joins?: Record<string, JoinDefinition>;
+}
+type SubOperationType = "insert" | "query";
+interface SubOperation {
+    subOperation: SubOperationType;
+    table: string;
+    data?: AnyObject | AnyObject[];
+    filter?: AnyObject;
+    fields?: string[];
+    return?: string;
+}
+interface OnConflictAction {
+    do: "nothing" | "update";
+    set?: Record<string, any>;
+    where?: string;
+}
+type OpEffect = "increment" | "decrement" | "set";
+type ValueOrSubOp = any | SubOperation | OpEffect;
+type ValueOrList = any | any[];
+interface DbOperationPayload {
+    data?: Record<string, ValueOrSubOp> | Record<string, ValueOrSubOp>[];
+    filter?: Record<string, ValueOrList>;
+    fields?: string[];
+    joins?: Record<string, JoinDefinition>;
+    queryMode?: QueryMode;
+    aggregates?: AggregateDefinition[];
+    groupBy?: string[];
+    sort?: Record<string, SortDirection>;
+    limit?: number;
+    offset?: number;
+    transaction?: boolean;
+    batch?: boolean;
+    onConflict?: {
+        target: string[];
+        action: OnConflictAction;
+    };
+}
+
+/**
+ * Represents a specialized task for delegating database operations. Extends `DeputyTask`.
+ * This class is designed to abstract database operation requests, delegating execution to a meta-layer system.
+ */
+declare class DatabaseTask extends DeputyTask {
+    private readonly queryData;
+    /**
+     * Constructs an instance of the class with the provided parameters, defining
+     * various configuration options and behaviors for the task.
+     *
+     * @param {string} name - The unique name of the task.
+     * @param {string} taskName - The specific name of the task.
+     * @param {string | undefined} serviceName - The associated service name. Defaults to undefined.
+     * @param {string} description - A brief description of the task. Defaults to an empty string.
+     * @param {DbOperationPayload} queryData - The data payload for database operations.
+     * @param {number} concurrency - The level of concurrency allowed. Defaults to 0.
+     * @param {number} timeout - The timeout duration in milliseconds. Defaults to 0.
+     * @param {boolean} register - A flag indicating whether to register the task. Defaults to true.
+     * @param {boolean} isUnique - Indicates if the task instance is unique. Defaults to false.
+     * @param {boolean} isMeta - Indicates if the task is meta. Defaults to false.
+     * @param {boolean} isSubMeta - Indicates if the task is a sub-meta task. Defaults to false.
+     * @param {boolean} isHidden - Indicates if the task is hidden. Defaults to false.
+     * @param {ThrottleTagGetter | undefined} getTagCallback - A callback used for throttling. Defaults to undefined.
+     * @param {SchemaDefinition | undefined} inputSchema - The schema definition for input validation. Defaults to undefined.
+     * @param {boolean} validateInputContext - Whether to validate the input context. Defaults to false.
+     * @param {SchemaDefinition | undefined} outputSchema - The schema definition for output validation. Defaults to undefined.
+     * @param {boolean} validateOutputContext - Whether to validate the output context. Defaults to false.
+     * @param {number} retryCount - The maximum number of retry attempts. Defaults to 0.
+     * @param {number} retryDelay - The delay between retries in milliseconds. Defaults to 0.
+     * @param {number} retryDelayMax - The maximum delay between retries in milliseconds. Defaults to 0.
+     * @param {number} retryDelayFactor - The factor for exponential backoff. Defaults to 1.
+     * @return {void}
+     */
+    constructor(name: string, taskName: string, serviceName: string | undefined, description: string | undefined, queryData: DbOperationPayload, concurrency?: number, timeout?: number, register?: boolean, isUnique?: boolean, isMeta?: boolean, isSubMeta?: boolean, isHidden?: boolean, getTagCallback?: ThrottleTagGetter | undefined, inputSchema?: Schema | undefined, validateInputContext?: boolean, outputSchema?: Schema | undefined, validateOutputContext?: boolean, retryCount?: number, retryDelay?: number, retryDelayMax?: number, retryDelayFactor?: number);
+    /**
+     * Executes the specified task within the given context.
+     *
+     * @param {GraphContext} context - The execution context for the current task, which includes data and metadata required for processing.
+     * @param {(signal: string, ctx: AnyObject) => void} emit - A function used to send signals or events during task execution.
+     * @param inquire
+     * @param {(progress: number) => void} progressCallback - A function to report execution progress as a percentage (0-100).
+     * @param {{ nodeId: string; routineExecId: string }} nodeData - An object containing identifiers for the current node and routine execution.
+     * @return {TaskResult} The result of the task execution.
+     */
+    execute(context: GraphContext, emit: (signal: string, ctx: AnyObject) => void, inquire: (inquiry: string, context: AnyObject, options: InquiryOptions) => Promise<AnyObject>, progressCallback: (progress: number) => void, nodeData: {
+        nodeId: string;
+        routineExecId: string;
+    }): TaskResult;
+}
+
+interface InquiryResponderDescriptor {
+    isRemote: boolean;
+    serviceName: string;
+    taskName: string;
+    taskVersion: number;
+    localTaskName: string;
+}
+interface InquiryResponderStatus extends InquiryResponderDescriptor {
+    status: "fulfilled" | "failed" | "timed_out";
+    durationMs: number;
+    error?: string;
+}
+interface DistributedInquiryMeta {
+    inquiry: string;
+    isMetaInquiry: boolean;
+    totalResponders: number;
+    eligibleResponders: number;
+    filteredOutResponders: number;
+    responded: number;
+    failed: number;
+    timedOut: number;
+    pending: number;
+    durationMs: number;
+    responders: InquiryResponderStatus[];
+}
+type DistributedInquiryOptions = Partial<InquiryOptions> & {
+    /**
+     * Total timeout budget for the whole inquiry fan-out.
+     * Falls back to InquiryOptions.timeout when not set.
+     */
+    overallTimeoutMs?: number;
+    /**
+     * If true, reject on timeout / partial completion.
+     * If false (default), resolve with partial result and metadata.
+     */
+    requireComplete?: boolean;
+    /**
+     * Timeout propagated to responder execution context (__timeout).
+     * Mainly used by distributed deputy responders.
+     */
+    perResponderTimeoutMs?: number;
+    /**
+     * Optional hydration cache key used to consume one SSR-provided inquiry result
+     * before the live frontend runtime performs normal distributed routing.
+     */
+    hydrationKey?: string;
+};
+
+type RuntimeStatusState = "healthy" | "degraded" | "overloaded" | "unavailable";
+
+type ServiceTransportRole = "internal" | "public";
+type ServiceTransportProtocol = "rest" | "socket";
+type ServiceTransportSecurityProfile = "low" | "medium" | "high";
+interface ServiceTransportConfig {
+    role: ServiceTransportRole;
+    origin: string;
+    protocols?: ServiceTransportProtocol[];
+    securityProfile?: ServiceTransportSecurityProfile | null;
+    authStrategy?: string | null;
+}
+interface ServiceTransportDescriptor {
+    uuid: string;
+    serviceInstanceId: string;
+    role: ServiceTransportRole;
+    origin: string;
+    protocols: ServiceTransportProtocol[];
+    securityProfile: ServiceTransportSecurityProfile | null;
+    authStrategy: string | null;
+    deleted?: boolean;
+    clientCreated?: boolean;
+}
+
+interface ServiceInstanceDescriptor {
+    uuid: string;
+    serviceName: string;
+    numberOfRunningGraphs?: number;
+    isPrimary: boolean;
+    isActive: boolean;
+    isNonResponsive: boolean;
+    isBlocked: boolean;
+    runtimeState?: RuntimeStatusState;
+    acceptingWork?: boolean;
+    reportedAt?: string;
+    health: AnyObject;
+    isFrontend: boolean;
+    isDatabase?: boolean;
+    isBootstrapPlaceholder?: boolean;
+    transports: ServiceTransportDescriptor[];
+    clientCreatedTransportIds?: string[];
+    clientPendingTransportIds?: string[];
+    clientReadyTransportIds?: string[];
+}
+
+declare const AUTHORITY_RUNTIME_STATUS_REPORT_INTENT = "meta-service-registry-authority-runtime-status-report";
+declare const RUNTIME_STATUS_AUTHORITY_SYNC_REQUESTED_SIGNAL = "meta.service_registry.runtime_status_authority_sync_requested";
+interface RuntimeMetricsHealthDetail {
+    sampledAt?: string;
+    cpuUsage?: number | null;
+    memoryUsage?: number | null;
+    eventLoopLag?: number | null;
+    rssBytes?: number | null;
+    heapUsedBytes?: number | null;
+    heapTotalBytes?: number | null;
+    memoryLimitBytes?: number | null;
+}
+interface AuthorityRuntimeStatusReport {
+    serviceName: string;
+    serviceInstanceId: string;
+    transportId?: string;
+    transportRole?: ServiceTransportRole;
+    transportOrigin?: string;
+    transportProtocols?: ServiceTransportProtocol[];
+    isFrontend?: boolean;
+    reportedAt: string;
+    state: RuntimeStatusState;
+    acceptingWork: boolean;
+    numberOfRunningGraphs: number;
+    cpuUsage?: number | null;
+    memoryUsage?: number | null;
+    eventLoopLag?: number | null;
+    isActive: boolean;
+    isNonResponsive: boolean;
+    isBlocked: boolean;
+    health?: AnyObject;
+}
+declare function normalizeAuthorityRuntimeStatusReport(input: Record<string, any> | null | undefined): AuthorityRuntimeStatusReport | null;
+declare function buildAuthorityRuntimeStatusSignature(report: AuthorityRuntimeStatusReport): string;
+
+interface DeputyDescriptor {
+    serviceName: string;
+    remoteRoutineName?: string;
+    signalName?: string;
+    localTaskName: string;
+    communicationType: string;
+}
+/**
+ * The ServiceRegistry class is a singleton that manages the registration and lifecycle of
+ * service instances, deputies, and remote signals in a distributed service architecture.
+ * It handles various tasks such as instance updates, remote signal registration,
+ * service status synchronization, and error/event broadcasting.
+ */
+declare class ServiceRegistry {
+    private static _instance;
+    static get instance(): ServiceRegistry;
+    private instances;
+    private remoteRoutesByKey;
+    private localInstanceSeed;
+    private deputies;
+    private remoteSignals;
+    private remoteIntents;
+    private gatheredSyncTransmissionServices;
+    private remoteIntentDeputiesByKey;
+    private remoteIntentDeputiesByTask;
+    private dependeesByService;
+    private dependeeByInstance;
+    private readinessDependeesByService;
+    private readinessDependeeByInstance;
+    private lastHeartbeatAtByInstance;
+    private missedHeartbeatsByInstance;
+    private runtimeStatusFallbackInFlightByInstance;
+    private runtimeStatusRestRefreshInFlightByInstance;
+    private routingCooldownsByKey;
+    private transportFailuresByKey;
+    private activeRoutineExecutionIds;
+    private runtimeStatusHeartbeatStarted;
+    private runtimeMetricsSamplingStarted;
+    private lastRuntimeStatusSnapshot;
+    private lastPeerRuntimeStatusSnapshot;
+    private latestRuntimeMetricsSnapshot;
+    private readonly runtimeMetricsSampler;
+    private readonly runtimeStatusHeartbeatIntervalMs;
+    private readonly runtimeMetricsSampleIntervalMs;
+    private readonly runtimeStatusRestRefreshIntervalMs;
+    private readonly runtimeStatusMissThreshold;
+    private readonly runtimeStatusFallbackTimeoutMs;
+    private readonly runtimeStatusAuthorityReportTimeoutMs;
+    private readonly runtimeStatusInactiveMissThreshold;
+    private readonly noRouteCooldownFailureThreshold;
+    private readonly noRouteCooldownWindowMs;
+    private readonly noRouteCooldownMs;
+    private readonly transportFailureThreshold;
+    private readonly transportFailureWindowMs;
+    private readonly routeFailurePenaltyMs;
+    private readonly degradedGraphThreshold;
+    private readonly overloadedGraphThreshold;
+    serviceName: string | null;
+    serviceInstanceId: string | null;
+    numberOfRunningGraphs: number;
+    useSocket: boolean;
+    retryCount: number;
+    isFrontend: boolean;
+    connectsToCadenzaDB: boolean;
+    private bootstrapFullSyncRetryTimer;
+    private bootstrapFullSyncRetryIndex;
+    private bootstrapFullSyncRetryGeneration;
+    private bootstrapFullSyncSatisfied;
+    private bootstrapFullSyncRetryReason;
+    private knownGlobalSignalMaps;
+    private authorityBootstrapRoute;
+    private authorityBootstrapHandshakeInFlight;
+    handleInstanceUpdateTask: Task;
+    handleTransportUpdateTask: Task;
+    handleGlobalSignalRegistrationTask: Task;
+    handleGlobalIntentRegistrationTask: Task;
+    reconcileGatheredSyncTransmissionsTask: Task;
+    handleSocketStatusUpdateTask: Task;
+    fullSyncTask: GraphRoutine | Task;
+    getAllInstances: Task;
+    doForEachInstance: Task;
+    deleteInstance: Task;
+    getBalancedInstance: Task;
+    getInstanceById: Task;
+    getInstancesByServiceName: Task;
+    handleDeputyRegistrationTask: Task;
+    getStatusTask: Task;
+    insertServiceTask: Task;
+    insertServiceInstanceTask: Task;
+    insertServiceTransportTask: Task;
+    handleServiceNotRespondingTask: Task;
+    handleServiceHandshakeTask: Task;
+    collectTransportDiagnosticsTask: Task;
+    collectReadinessTask: Task;
+    private authorityFullSyncResponderTask;
+    private authorityServiceCommunicationPersistenceTask;
+    private readonly localLifecycleFlushActor;
+    private collectBootstrapFullSyncPayload;
+    private buildRemoteIntentDeputyKey;
+    private readArrayPayload;
+    private normalizeSignalMaps;
+    private rememberKnownGlobalSignalMaps;
+    private applyGlobalSignalRegistrations;
+    reconcileKnownGlobalSignalRegistrations(): boolean;
+    private normalizeIntentMaps;
+    private normalizeServiceInstancesFromSync;
+    private shouldReconcileGatheredSyncTransmissions;
+    private collectGatheredSyncTransmissionRecipients;
+    private reconcileGatheredSyncTransmissions;
+    seedAuthorityBootstrapRoute(origin: string, role?: ServiceTransportRole): void;
+    private noteAuthorityBootstrapHandshake;
+    private getAuthorityBootstrapRestTarget;
+    hasAuthorityBootstrapHandshakeEstablished(): boolean;
+    private invalidateAuthorityBootstrapHandshake;
+    private requestAuthorityBootstrapHandshake;
+    private invokeAuthorityBootstrapRoutine;
+    private registerRemoteIntentDeputy;
+    private unregisterRemoteIntentDeputy;
+    ensureAuthorityFullSyncResponderTask(): Task | null;
+    ensureAuthorityServiceCommunicationPersistenceTask(): Task | null;
+    private registerBootstrapFullSyncDeputies;
+    ensureBootstrapAuthorityControlPlaneForInquiry(intentName: string, ctx?: AnyObject): boolean;
+    private ensureBootstrapAuthorityControlPlane;
+    private hasBootstrapFullSyncDeputies;
+    private ensureAuthorityBootstrapSignalTransmissions;
+    private clearBootstrapFullSyncRetryTimer;
+    private invalidateBootstrapFullSyncRetryState;
+    private markBootstrapFullSyncSatisfied;
+    private hasHealthyBootstrapFullSyncResult;
+    private scheduleNextBootstrapFullSyncRetry;
+    private restartBootstrapFullSyncRetryChain;
+    bootstrapFullSync(emit: (signal: string, ctx: AnyObject) => void, ctx?: AnyObject, reason?: string): boolean;
+    getInquiryResponderDescriptor(task: Task): InquiryResponderDescriptor;
+    private getInstance;
+    private getLocalInstance;
+    hasLocalInstanceRegistered(): boolean;
+    seedLocalInstance(value: unknown, options?: {
+        markTransportsReady?: boolean;
+    }): ServiceInstanceDescriptor | null;
+    private summarizeTransportForDebug;
+    private summarizeInstanceForRuntimeStatusFallback;
+    private summarizeRuntimeStatusInquiryReports;
+    private createRuntimeStatusFallbackError;
+    resolveLocalStatusCheck(ctx?: AnyObject): {
+        __status: string;
+        __error: string;
+        errored: boolean;
+    } | {
+        __status: string;
+        __serviceName: string;
+        __serviceInstanceId: string;
+        __numberOfRunningGraphs: number;
+        __health: AnyObject;
+        __active: boolean;
+        cpuUsage: number | null;
+        memoryUsage: number | null;
+        eventLoopLag: number | null;
+        reportedAt: string;
+        serviceName: string;
+        serviceInstanceId: string;
+        numberOfRunningGraphs: number;
+        health: AnyObject;
+        isActive: boolean;
+        isNonResponsive: boolean;
+        isBlocked: boolean;
+        state: RuntimeStatusState;
+        acceptingWork: boolean;
+        __error?: undefined;
+        errored?: undefined;
+    };
+    private resolveTransportProtocolOrder;
+    private selectTransportForInstance;
+    private selectReadyTransportForInstance;
+    private getRoutingTransportRole;
+    private getPreferredRoutingProtocol;
+    private buildRoutingCooldownKey;
+    private getActiveRoutingCooldown;
+    private recordRoutingFailure;
+    private clearRoutingCooldown;
+    private hasRouteableInstanceForRouting;
+    private refreshRoutingCooldownsForService;
+    private buildTransportFailureKey;
+    private clearTransportFailureState;
+    private classifyTransportFailureKind;
+    private getTransportFailureThreshold;
+    private recordTransportFailure;
+    private findInstanceByTransportId;
+    private resolveRouteRecordFromContext;
+    private isCurrentRouteContext;
+    private maybeDemoteFailedTransport;
+    private getTransportById;
+    private getRouteableTransport;
+    private getTransportClientKey;
+    private resolveCommunicationTypesForService;
+    private ensureDependeeClientForInstance;
+    private ensureDependeeClientsForService;
+    private scheduleDependeeClientRecovery;
+    private shouldEagerlyEstablishRemoteClients;
+    private shouldDemandEstablishRemoteClients;
+    private buildTransportRouteKey;
+    private buildTransportProtocolHandleKey;
+    private resolveProtocolFromContext;
+    private ensureRouteProtocolState;
+    private cloneRouteBalancingState;
+    private resolveRouteDispatchToken;
+    private getNumericHealthMetric;
+    private compareOptionalBalancingMetric;
+    private buildRouteBalancingSnapshot;
+    private compareRouteBalancingSnapshots;
+    private markRouteDispatchSelected;
+    private markRouteDispatchCompleted;
+    recordBalancedRouteSelection(routeKey: string, ctx: AnyObject): void;
+    recordBalancedRouteOutcome(ctx: AnyObject, outcome: "success" | "failure" | "neutral"): void;
+    private matchesSignalBroadcastFilter;
+    private routeHasProtocolState;
+    private syncInstanceClientRouteState;
+    private findRemoteRouteRecordByTransportId;
+    private upsertRemoteRouteRecord;
+    private clearRemoteRouteRecordIfCurrent;
+    private emitTransportHandleShutdowns;
+    private resolveTransportRouteKey;
+    private hasTransportClientCreated;
+    private markTransportClientPending;
+    private hasTransportClientReady;
+    private hasReadyClientTransportForProtocol;
+    private hasAnyReadyClientProtocolForTransport;
+    private markTransportClientReady;
+    private clearTransportClientState;
+    shouldProcessRemoteRouteEvent(ctx: AnyObject): boolean;
+    private resolveRequiredReadinessFromCommunicationTypes;
+    private markTransportReadyFromContext;
+    private clearTransportReadyFromContext;
+    private registerDependee;
+    private unregisterDependee;
+    private getInstanceRouteRole;
+    private findSupersededInstancesForTransport;
+    private compareInstancesForRoutePrecedence;
+    private hasReadyTransportForRoute;
+    private retireSupersededInstancesForTransport;
+    private shouldRetireSupersededInstancesForTransport;
+    private hydrateAuthorityInstanceForTransport;
+    private reconcileBootstrapPlaceholderInstance;
+    private adoptBootstrapPlaceholderInstanceId;
+    private getHeartbeatMisses;
+    private getRuntimeStatusInactiveThreshold;
+    private buildGracefulShutdownTransportDeactivationContext;
+    private applyInstanceLifecycleState;
+    private emitInstanceLifecyclePersistence;
+    private deactivateInstanceTransports;
+    private emitTransportDeletionPersistence;
+    private markInstanceInactive;
+    private handleLocalInboundActivity;
+    private handleRemoteActivityObserved;
+    private resolveRouteFreshnessTimestamp;
+    private collapseInstancesByRouteOrigin;
+    private shouldRequireReadinessFromCommunicationTypes;
+    private resolveRuntimeStatusSnapshot;
+    private captureRuntimeMetricsSample;
+    private getLatestRuntimeMetricsSnapshot;
+    private buildRuntimeMetricsHealthPayload;
+    private stripRuntimeStatusReportForPeer;
+    private buildPeerRuntimeStatusSnapshot;
+    private hasSignificantPeerRuntimeStatusChange;
+    private readRuntimeStatusMetric;
+    private normalizeRuntimeStatusReport;
+    private applyRuntimeStatusReport;
+    private retireLocalRemoteInstance;
+    private applyRuntimeStatusIdentityReplacement;
+    applyAuthorityRuntimeStatusReport(report: AuthorityRuntimeStatusReport): boolean;
+    private buildLocalRuntimeStatusReport;
+    private selectRuntimeStatusReportForTarget;
+    private resolveRuntimeStatusFallbackInquiry;
+    private requestRuntimeStatusViaRest;
+    private shouldRefreshRuntimeStatusViaRest;
+    private getAuthorityRestTransport;
+    private delegateAuthorityLifecycleUpdate;
+    reportLocalShutdownToAuthority(reason: string, timeoutMs: number): Promise<boolean>;
+    private evaluateDependencyReadinessDetail;
+    private buildLocalReadinessReport;
+    /**
+     * Initializes a private constructor for managing service instances, remote signals,
+     * service health, and handling updates or synchronization tasks. The constructor
+     * creates a variety of meta tasks that process different lifecycle events and
+     * service-related updates in a distributed service registry model.
+     *
+     * @return {Object} An instance of the constructed class with initialized tasks
+     *                  and state management necessary to process service-related events.
+     */
+    private constructor();
+    reset(): void;
+}
+
+/**
+ * Represents a task responsible for transmitting signals to a remote service
+ * through the meta-layer for operations delegation.
+ *
+ * @class
+ * @extends Task
+ */
+declare class SignalTransmissionTask extends Task {
+    readonly isDeputy: boolean;
+    protected readonly signalName: string;
+    protected readonly serviceName: string;
+    /**
+     * Constructs a new instance of the class and initializes it with the provided parameters.
+     *
+     * @param {string} name - The name of the task being created.
+     * @param {string} signalName - The name of the signal associated with this task.
+     * @param {string} serviceName - The name of the service associated with this task.
+     * @param {string} [description=""] - An optional description of the task.
+     * @param {number} [concurrency=0] - The maximum allowed concurrency for this task.
+     * @param {number} [timeout=0] - The maximum execution time for this task, in milliseconds.
+     * @param {boolean} [register=true] - Whether the task should be registered upon creation.
+     * @param {boolean} [isUnique=false] - Indicates if the task should enforce uniqueness.
+     * @param {boolean} [isMeta=false] - Specifies if the task is a meta-task.
+     * @param {boolean} [isSubMeta=false] - Specifies if the task is a sub-meta-task.
+     * @param {boolean} [isHidden=false] - Indicates if the task is hidden from visibility.
+     * @param {ThrottleTagGetter|undefined} [getTagCallback=undefined] - A callback for tag throttling logic.
+     * @param {SchemaDefinition|undefined} [inputSchema=undefined] - An optional schema for validating input data.
+     * @param {boolean} [validateInputContext=false] - Whether to validate the input context against the input schema.
+     * @param {SchemaDefinition|undefined} [outputSchema=undefined] - An optional schema for validating output data.
+     * @param {boolean} [validateOutputContext=false] - Whether to validate the output context against the output schema.
+     * @param {number} [retryCount=0] - The number of retry attempts allowed in case of task failure.
+     * @param {number} [retryDelay=0] - The initial delay before retrying a failed task, in milliseconds.
+     * @param {number} [retryDelayMax=0] - The maximum delay between retry attempts, in milliseconds.
+     * @param {number} [retryDelayFactor=1] - A multiplier applied to retry delay for exponential backoff.
+     * @return {void} Does not return a value.
+     */
+    constructor(name: string, signalName: string, serviceName: string, description?: string, concurrency?: number, timeout?: number, register?: boolean, isUnique?: boolean, isMeta?: boolean, isSubMeta?: boolean, isHidden?: boolean, getTagCallback?: ThrottleTagGetter | undefined, inputSchema?: Schema | undefined, validateInputContext?: boolean, outputSchema?: Schema | undefined, validateOutputContext?: boolean, retryCount?: number, retryDelay?: number, retryDelayMax?: number, retryDelayFactor?: number);
+    /**
+     * Executes the given task function within the provided execution context.
+     *
+     * @param {GraphContext} context - The context object providing the graph execution environment and metadata.
+     * @param {Function} emit - A function to emit signals with the provided name and context.
+     * @param inquire
+     * @param {Function} progressCallback - A callback function to report the progress of the task execution as a number between 0 and 1.
+     * @return {TaskResult} The result of the executed task function.
+     */
+    execute(context: GraphContext, emit: (signal: string, ctx: AnyObject) => void, inquire: (inquiry: string, context: AnyObject, options: InquiryOptions) => Promise<AnyObject>, progressCallback: (progress: number) => void): TaskResult;
+}
+
+type SchemaType = "varchar" | "text" | "int" | "bigint" | "decimal" | "boolean" | "array" | "object" | "jsonb" | "uuid" | "timestamp" | "date" | "geo_point" | "bytea" | "any";
+type SchemaConstraints = {
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    enum?: any[];
+    multipleOf?: number;
+    format?: "email" | "url" | "date-time" | "uuid" | "custom";
+    oneOf?: any[];
+    appendOnly?: boolean;
+    check?: string;
+    precision?: number;
+    scale?: number;
+};
+interface FieldDefinition {
+    type: SchemaType;
+    primary?: boolean;
+    index?: boolean;
+    unique?: boolean;
+    default?: any;
+    required?: boolean;
+    nullable?: boolean;
+    encrypted?: boolean;
+    constraints?: SchemaConstraints;
+    references?: string;
+    items?: FieldDefinition;
+    description?: string;
+    generated?: "uuid" | "timestamp" | "now" | "autoIncrement";
+    onDelete?: "cascade" | "set null" | "no action" | "set default" | "restrict";
+    onUpdate?: "cascade" | "set null" | "no action" | "set default";
+}
+type DbOperationType = "query" | "insert" | "update" | "delete";
+interface TableDefinition {
+    fields: Record<string, FieldDefinition>;
+    meta?: {
+        description?: string;
+        tags?: string[];
+        shardKey?: string;
+        partitionHint?: string;
+        appendOnly?: boolean;
+        encryptedFields?: string[];
+    };
+    indexes?: string[][];
+    uniqueConstraints?: string[][];
+    primaryKey?: string[];
+    fullTextIndexes?: string[][];
+    foreignKeys?: {
+        tableName: string;
+        fields: string[];
+        referenceFields: string[];
+        onDelete?: "cascade" | "set null" | "no action";
+    }[];
+    triggers?: Record<string, {
+        when: "before" | "after";
+        event: "insert" | "update" | "delete";
+        function: string;
+    }>;
+    customSignals?: {
+        triggers?: {
+            [key in DbOperationType]?: (string | {
+                signal: string;
+                condition?: (ctx: AnyObject) => boolean;
+                queryData?: DbOperationPayload;
+            })[];
+        };
+        emissions?: {
+            [key in DbOperationType]?: (string | {
+                signal: string;
+                condition?: (ctx: AnyObject) => boolean;
+            })[];
+        };
+    };
+    customIntents?: {
+        query?: (string | {
+            intent: string;
+            description?: string;
+            input?: SchemaDefinition;
+        })[];
+        insert?: (string | {
+            intent: string;
+            description?: string;
+            input?: SchemaDefinition;
+        })[];
+        update?: (string | {
+            intent: string;
+            description?: string;
+            input?: SchemaDefinition;
+        })[];
+        delete?: (string | {
+            intent: string;
+            description?: string;
+            input?: SchemaDefinition;
+        })[];
+    };
+    initialData?: {
+        fields: string[];
+        data: any[][];
+    };
+}
+interface DatabaseMigrationPolicy {
+    baselineOnEmpty?: boolean;
+    adoptExistingVersion?: number | null;
+    allowDestructive?: boolean;
+    transactionalMode?: "per_migration" | "none";
+}
+type DatabaseMigrationConstraintDefinition = {
+    kind: "primaryKey";
+    fields: string[];
+} | {
+    kind: "unique";
+    fields: string[];
+} | {
+    kind: "foreignKey";
+    fields: string[];
+    referenceTable: string;
+    referenceFields: string[];
+    onDelete?: "cascade" | "set null" | "no action";
+} | {
+    kind: "check";
+    expression: string;
+} | {
+    kind: "sql";
+    sql: string;
+};
+type DatabaseMigrationStep = {
+    kind: "createTable";
+    table: string;
+    definition: TableDefinition;
+} | {
+    kind: "dropTable";
+    table: string;
+    ifExists?: boolean;
+    cascade?: boolean;
+} | {
+    kind: "addColumn";
+    table: string;
+    column: string;
+    definition: FieldDefinition;
+    ifNotExists?: boolean;
+} | {
+    kind: "dropColumn";
+    table: string;
+    column: string;
+    ifExists?: boolean;
+    cascade?: boolean;
+} | {
+    kind: "alterColumn";
+    table: string;
+    column: string;
+    setType?: SchemaType;
+    using?: string;
+    setDefault?: any;
+    dropDefault?: boolean;
+    setNotNull?: boolean;
+    dropNotNull?: boolean;
+} | {
+    kind: "renameColumn";
+    table: string;
+    from: string;
+    to: string;
+} | {
+    kind: "renameTable";
+    from: string;
+    to: string;
+} | {
+    kind: "addIndex";
+    table: string;
+    fields: string[];
+    name?: string;
+    unique?: boolean;
+} | {
+    kind: "dropIndex";
+    table?: string;
+    fields?: string[];
+    name?: string;
+    ifExists?: boolean;
+} | {
+    kind: "addConstraint";
+    table: string;
+    name: string;
+    definition: DatabaseMigrationConstraintDefinition;
+} | {
+    kind: "dropConstraint";
+    table: string;
+    name: string;
+    ifExists?: boolean;
+} | {
+    kind: "sql";
+    sql: string | string[];
+};
+interface DatabaseMigrationDefinition {
+    version: number;
+    name: string;
+    description?: string;
+    steps: DatabaseMigrationStep[];
+    transaction?: "inherit" | "required" | "none";
+}
+interface DatabaseSchemaDefinition {
+    version?: number;
+    tables: Record<string, TableDefinition>;
+    migrations?: DatabaseMigrationDefinition[];
+    migrationPolicy?: DatabaseMigrationPolicy;
+    relations?: Record<string, {
+        on: string;
+        type?: "one-to-one" | "one-to-many" | "many-to-one" | "many-to-many";
+    }>;
+    meta?: {
+        defaultEncoding?: "utf8" | "base64";
+        autoIndex?: boolean;
+        relationsVersion?: number;
+        dropExisting?: boolean;
+    };
+}
+
+interface BootstrapOptions {
+    url?: string;
+    injectedGlobalKey?: string;
+}
+interface HydrationOptions {
+    initialInquiryResults?: Record<string, unknown>;
+}
+interface ResolvedBootstrapEndpoint {
+    url: string;
+    protocol: "http" | "https";
+    address: string;
+    port: number;
+    exposed: boolean;
+    injectedGlobalKey: string;
+}
+
+interface BrowserRuntimeActorRuntimeState<TProjectionState extends Record<string, any> = Record<string, any>> {
+    ready: boolean;
+    projectionState: TProjectionState;
+    lastReadyAt: string | null;
+    lastSyncRequestedAt: string | null;
+}
+interface BrowserRuntimeProjectionBinding<TProjectionState extends Record<string, any> = Record<string, any>> {
+    signal: string;
+    taskName?: string;
+    description?: string;
+    reduce: (current: TProjectionState, payload: Record<string, any>) => TProjectionState;
+}
+interface BrowserRuntimeServiceOptions extends Omit<ServerOptions, "isFrontend" | "bootstrap" | "hydration"> {
+    name: string;
+    description?: string;
+    bootstrap: BootstrapOptions;
+    hydration?: HydrationOptions;
+}
+interface BrowserRuntimeActorOptions<TProjectionState extends Record<string, any> = Record<string, any>> {
+    actorName: string;
+    actorDescription?: string;
+    actorKey?: string;
+    service: BrowserRuntimeServiceOptions;
+    initialProjectionState: TProjectionState | (() => TProjectionState);
+    signalBindings?: Array<BrowserRuntimeProjectionBinding<TProjectionState>>;
+    readySignal?: string;
+    syncSignals?: string[];
+}
+interface BrowserRuntimeActorHandle<TProjectionState extends Record<string, any> = Record<string, any>> {
+    actor: Actor<Record<string, never>, BrowserRuntimeActorRuntimeState<TProjectionState>>;
+    actorKey: string;
+    waitUntilReady: () => Promise<void>;
+    inquire: (inquiry: string, context?: Record<string, any>, options?: DistributedInquiryOptions) => Promise<AnyObject>;
+    getRuntimeState: () => BrowserRuntimeActorRuntimeState<TProjectionState>;
+    subscribe: (listener: (state: BrowserRuntimeActorRuntimeState<TProjectionState>) => void) => () => void;
+}
+
+type SecurityProfile = "low" | "medium" | "high";
+type NetworkMode = "internal" | "exposed" | "exposed-high-sec" | "auto" | "dev";
+type ServerOptions = {
+    customServiceId?: string;
+    loadBalance?: boolean;
+    useSocket?: boolean;
+    log?: boolean;
+    displayName?: string;
+    isMeta?: boolean;
+    port?: number;
+    securityProfile?: SecurityProfile;
+    networkMode?: NetworkMode;
+    retryCount?: number;
+    cadenzaDB?: {
+        connect?: boolean;
+        address?: string;
+        port?: number;
+    };
+    bootstrap?: BootstrapOptions;
+    hydration?: HydrationOptions;
+    transports?: ServiceTransportConfig[];
+    relatedServices?: string[][];
+    isDatabase?: boolean;
+    isFrontend?: boolean;
+};
+interface DatabaseOptions {
+    databaseType?: "postgres";
+    databaseName?: string;
+    poolSize?: number;
+    ownerServiceName?: string | null;
+}
+/**
+ * The CadenzaService class serves as a central service layer providing various utility methods for managing tasks, signals, logging, and service interactions.
+ * This class handles the initialization (`bootstrap`) and validation of services, as well as the creation of tasks associated with services and signals.
+ */
+declare class CadenzaService {
+    static signalBroker: SignalBroker;
+    static inquiryBroker: InquiryBroker;
+    static runner: GraphRunner;
+    static metaRunner: GraphRunner;
+    static registry: GraphRegistry;
+    static serviceRegistry: ServiceRegistry;
+    protected static isBootstrapped: boolean;
+    protected static serviceCreated: boolean;
+    protected static bootstrapSyncCompleted: boolean;
+    protected static bootstrapSignalRegistrationsCompleted: boolean;
+    protected static bootstrapIntentRegistrationsCompleted: boolean;
+    protected static defaultDatabaseServiceName: string | null;
+    protected static warnedInvalidMetaIntentResponderKeys: Set<string>;
+    protected static hydratedInquiryResults: Map<string, AnyObject>;
+    protected static frontendSyncScheduled: boolean;
+    protected static serviceManifestRevision: number;
+    protected static lastPublishedServiceManifestHash: string | null;
+    protected static serviceManifestPublicationInFlight: boolean;
+    protected static serviceManifestPublicationPendingReason: string | null;
+    private static shutdownHandlersRegistered;
+    private static shutdownInFlight;
+    private static shutdownHandlerCleanup;
+    private static unregisterGracefulShutdownHandlers;
+    private static registerGracefulShutdownHandlers;
+    private static replayRegisteredTaskIntentAssociations;
+    private static replayRegisteredTaskSignalObservations;
+    private static replayRegisteredTaskGraphMetadata;
+    private static requestServiceManifestPublication;
+    private static scheduleServiceManifestPublicationRetry;
+    private static publishServiceManifestIfNeeded;
+    private static ensureServiceManifestPublicationTasks;
+    private static buildLegacyLocalCadenzaDBTaskName;
+    private static buildGeneratedLocalCadenzaDBTaskName;
+    /**
+     * Initializes the application by setting up necessary components and configurations.
+     * This method ensures the initialization process is only executed once throughout the application lifecycle.
+     *
+     * @return {void} This method does not return any value.
+     */
+    static bootstrap(): void;
+    private static ensureTransportControllers;
+    private static setHydrationResults;
+    private static consumeHydratedInquiryResult;
+    private static ensureFrontendSyncLoop;
+    private static normalizeDeclaredTransports;
+    private static createBootstrapTransport;
+    /**
+     * Validates the provided service name based on specific rules.
+     *
+     * @param {string} serviceName - The service name to validate. Must be less than 100 characters,
+     *                                must not contain spaces, dots, or backslashes, and must start with a capital letter.
+     * @return {void} Throws an error if the service name does not meet the validation criteria.
+     * @throws {Error} If the service name exceeds 100 characters.
+     * @throws {Error} If the service name contains spaces.
+     * @throws {Error} If the service name contains dots.
+     * @throws {Error} If the service name contains backslashes.
+     * @throws {Error} If the service name does not start with a capital letter.
+     */
+    protected static validateServiceName(serviceName: string): void;
+    /**
+     * Validates the provided name to ensure it meets the required criteria.
+     *
+     * @param {string} name - The name to be validated.
+     * @return {void} Does not return any value.
+     */
+    protected static validateName(name: string): void;
+    /**
+     * Gets the current run strategy from the Cadenza configuration.
+     *
+     * @return {Function} The run strategy function defined in the Cadenza configuration.
+     */
+    static get runStrategy(): {
+        PARALLEL: unknown;
+        SEQUENTIAL: unknown;
+    };
+    /**
+     * Sets the mode for the Cadenza application.
+     *
+     * @param {CadenzaMode} mode - The mode to be set for the application.
+     * @return {void} This method does not return a value.
+     */
+    static setMode(mode: CadenzaMode): void;
+    static hasCompletedBootstrapSync(): boolean;
+    static isServiceReady(): boolean;
+    static getServiceReadySignalName(serviceName?: string): string;
+    private static getServiceReadyHandoffSignalName;
+    static markBootstrapSyncCompleted(): void;
+    /**
+     * Emits a signal with the specified data using the associated broker.
+     *
+     * @param {string} signal - The name of the event or signal to emit.
+     * @param {AnyObject} [data={}] - The data to be emitted along with the signal.
+     * @param options
+     * @return {void} No return value.
+     *
+     * @example
+     * This is meant to be used as a global event emitter.
+     * If you want to emit an event from within a task, you can use the `emit` method provided to the task function. See {@link TaskFunction}.
+     * ```ts
+     * Cadenza.emit('main.my_event', { foo: 'bar' });
+     * ```
+     */
+    static emit(signal: string, data?: AnyObject, options?: EmitOptions): void;
+    static debounce(signal: string, context?: any, delayMs?: number): void;
+    static schedule(signal: string, context: AnyObject, timeoutMs: number, exactDateTime?: Date): void;
+    static interval(signal: string, context: AnyObject, intervalMs: number, leading?: boolean, startDateTime?: Date): void;
+    static defineIntent(intent: Intent): Intent;
+    static getRuntimeValidationPolicy(): RuntimeValidationPolicy;
+    static setRuntimeValidationPolicy(policy?: RuntimeValidationPolicy): RuntimeValidationPolicy;
+    static replaceRuntimeValidationPolicy(policy?: RuntimeValidationPolicy): RuntimeValidationPolicy;
+    static clearRuntimeValidationPolicy(): void;
+    static getRuntimeValidationScopes(): RuntimeValidationScope[];
+    static upsertRuntimeValidationScope(scope: RuntimeValidationScope): RuntimeValidationScope;
+    static removeRuntimeValidationScope(id: string): void;
+    static clearRuntimeValidationScopes(): void;
+    private static getInquiryResponderDescriptor;
+    private static compareInquiryResponders;
+    private static buildInquirySummary;
+    private static shouldPersistInquiry;
+    private static splitInquiryPersistenceContext;
+    private static buildInquiryPersistenceStartData;
+    static inquire(inquiry: string, context: AnyObject, options?: DistributedInquiryOptions): Promise<AnyObject>;
+    /**
+     * Executes the given task or graph routine within the provided context using the configured runner.
+     *
+     * @param {Task | GraphRoutine} task - The task or graph routine to be executed.
+     * @param {AnyObject} context - The context within which the task will be executed.
+     * @return {void}
+     *
+     * @example
+     * ```ts
+     * const task = Cadenza.createTask('My task', (ctx) => {
+     *   console.log('My task executed with context:', ctx);
+     * });
+     *
+     * Cadenza.run(task, { foo: 'bar' });
+     *
+     * const routine = Cadenza.createRoutine('My routine', [task], 'My routine description');
+     *
+     * Cadenza.run(routine, { foo: 'bar' });
+     * ```
+     */
+    static run(task: Task | GraphRoutine, context: AnyObject): void;
+    /**
+     * Logs a message with a specified log level and additional contextual data.
+     * Records in the CadenzaDB when available.
+     *
+     * @param {string} message - The main message to be logged.
+     * @param {any} [data={}] - Additional data or metadata to include with the log.
+     * @param {"info"|"warning"|"error"|"critical"} [level="info"] - The severity level of the log message.
+     * @param {string|null} [subjectServiceName=null] - The name of the subject service related to the log.
+     * @param {string|null} [subjectServiceInstanceId=null] - The instance ID of the subject service related to the log.
+     * @return {void} No return value.
+     */
+    static log(message: string, data?: any, level?: "info" | "warning" | "error" | "critical", subjectServiceName?: string | null, subjectServiceInstanceId?: string | null): void;
+    static get(taskName: string): Task | undefined;
+    static getLocalCadenzaDBTask(tableName: string, operation: DbOperationType$1): Task | undefined;
+    static getLocalCadenzaDBInsertTask(tableName: string): Task | undefined;
+    static getLocalCadenzaDBQueryTask(tableName: string): Task | undefined;
+    static getActor<D extends Record<string, any> = AnyObject, R = AnyObject>(actorName: string): Actor<D, R> | undefined;
+    static getAllActors<D extends Record<string, any> = AnyObject, R = AnyObject>(): Actor<D, R>[];
+    static getRoutine(routineName: string): GraphRoutine | undefined;
+    /**
+     * Creates a new DeputyTask instance based on the provided routine name, service name, and options.
+     * This method ensures proper task initialization, including setting a unique name,
+     * validation of the routine name, and applying default option values.
+     *
+     * @param {string} routineName - The name of the routine the task references. This is mandatory and should be a valid string.
+     * @param {string|undefined} [serviceName] - The name of the service that the routine belongs to. This is optional and defaults to undefined.
+     * @param {TaskOptions} [options={}] - A configuration object for the task, allowing various properties such as concurrency, timeout, and retry settings to be customized.
+     * @return {DeputyTask} - A new DeputyTask instance initialized with the specified parameters.
+     *
+     * @example
+     * Let's say we are writing the code for a Service called "Service1".
+     * We also have an additional service called "Service2" with a routine called "My Routine".
+     * A flow on Service1 depends on the result of "My Routine" on Service2.
+     * We can create a deputy task for the routine using the following code:
+     * ```ts
+     * Cadenza.createDeputyTask("My Routine", "Service2").then(
+     *   Cadenza.createTask("Handle result", (ctx) => {
+     *     console.log("'Handle result' executed with context:", ctx);
+     *   }),
+     * );
+     * ```
+     * Internally, this will send a request to an available "Service2" instance to execute the "My Routine" routine.
+     * The deputy task will wait for the response and then execute the next task(s) in the chain.
+     *
+     * You can visualize the execution of the deputy task as follows:
+     * ```
+     * Service1 flow = [Deputy tasks for "My Routine"] -> ["Handle result"]
+     *                       ||       A
+     *                       V       ||
+     * Service2 flow =    [[My Routine]]
+     * ```
+     *
+     * Deputy tasks are useful for delegating flows to other services, allowing for parallel execution and load balancing.
+     * But it creates tight coupling between the services, which may not be desirable in some cases.
+     * In cases where an event on one service should simply trigger a flow on another service, without the need for a result,
+     * it is recommended to use signals instead. Like this:
+     *
+     * Service1
+     * ```ts
+     * Cadenza.createTask("Generate event", (ctx, emit) => {
+     *   // Do something
+     *   emit("some.event");
+     * });
+     * ```
+     *
+     * Service2
+     * ```ts
+     * Cadenza.createTask("Handle event", (ctx) => {
+     *   console.log("Handle event executed with context:", ctx);
+     * }).doOn("Service1.some.event");
+     * ```
+     *
+     * Every time the "Generate event" task is executed, it will emit a signal "Service1.some.event" to one Service2 instance and trigger the "Handle event" task.
+     */
+    static createDeputyTask(routineName: string, serviceName?: string | undefined, options?: TaskOptions): DeputyTask;
+    /**
+     * Creates a meta deputy task by setting the `isMeta` property in the options to true,
+     * and delegating task creation to the `createDeputyTask` method.
+     * See {@link createDeputyTask} and {@link createMetaTask} for more information.
+     *
+     * @param {string} routineName - The name of the routine associated with the task.
+     * @param {string | undefined} [serviceName] - The optional name of the service associated with the task.
+     * @param {TaskOptions} [options={}] - Additional options for the task. Defaults to an empty object if not provided.
+     * @return {DeputyTask} - The created meta deputy task.
+     */
+    static createMetaDeputyTask(routineName: string, serviceName?: string | undefined, options?: TaskOptions): DeputyTask;
+    /**
+     * Creates a throttled deputy task with the specified parameters.
+     * See {@link createThrottledTask} and {@link createDeputyTask} for more information.
+     *
+     * @param {string} routineName - The name of the routine to be executed.
+     * @param {string | undefined} [serviceName=undefined] - The name of the service, if applicable.
+     * @param {ThrottleTagGetter} [throttledIdGetter=() => "default"] - A function to get the throttled tag for the task.
+     * @param {TaskOptions} [options={}] - The options for task configuration, including concurrency and callbacks.
+     * @return {DeputyTask} The created throttled deputy task.
+     */
+    static createThrottledDeputyTask(routineName: string, serviceName?: string | undefined, throttledIdGetter?: ThrottleTagGetter, options?: TaskOptions): DeputyTask;
+    /**
+     * Creates a throttled deputy task with meta-task settings enabled.
+     * See {@link createThrottledTask},{@link createDeputyTask} and {@link createMetaTask} for more information.
+     *
+     * @param {string} routineName - The name of the routine for which the task is being created.
+     * @param {string|undefined} [serviceName=undefined] - The name of the service associated with the task, or undefined if not applicable.
+     * @param {ThrottleTagGetter} [throttledIdGetter=() => "default"] - A function to compute or return the throttling identifier.
+     * @param {TaskOptions} [options={}] - Additional options for the task configuration.
+     * @return {any} Returns the created throttled deputy task instance.
+     */
+    static createMetaThrottledDeputyTask(routineName: string, serviceName?: string | undefined, throttledIdGetter?: ThrottleTagGetter, options?: TaskOptions): DeputyTask;
+    /**
+     * Creates and configures a signal transmission task that handles the transmission
+     * of a specified signal to a target service with a set of customizable options.
+     * This is only used for internal purposes and is not exposed to the business logic layer.
+     *
+     * @param {string} signalName - The name of the signal to be transmitted.
+     * @param {string} serviceName - The name of the target service to transmit the signal to.
+     * @param {TaskOptions} [options={}] - A set of optional parameters to further configure the task.
+     * @return {SignalTransmissionTask} A new instance of SignalTransmissionTask configured with the given parameters.
+     */
+    static createSignalTransmissionTask(signalName: string, serviceName: string, options?: TaskOptions): SignalTransmissionTask | undefined;
+    /**
+     * Creates and configures a database task that performs an operation on a specified table.
+     *
+     * @param {string} tableName - The name of the database table on which the operation will be performed.
+     * @param {DbOperationType} operation - The type of database operation to execute (e.g., insert, update, delete).
+     * @param {string|undefined} [databaseServiceName=undefined] - The name of the database service; defaults to "default database service" if not provided.
+     * @param {DbOperationPayload} queryData - The data payload required for executing the specified database operation.
+     * @param {TaskOptions} [options={}] - Optional configuration for the task, including concurrency, timeout, and retry policies.
+     * @return {DatabaseTask} A configured database task instance ready for execution.
+     */
+    static createDatabaseTask(tableName: string, operation: DbOperationType$1, databaseServiceName: string | undefined, queryData: DbOperationPayload, options?: TaskOptions): DatabaseTask;
+    /**
+     * Creates a task for performing a database insert operation.
+     *
+     * @param {string} tableName - The name of the table where the insert operation will be performed.
+     * @param {string | undefined} [databaseServiceName=undefined] - The name of the database service to use. Optional parameter, defaults to undefined.
+     * @param {DbOperationPayload} [queryData={}] - The data payload for the insert operation. Defaults to an empty object.
+     * @param {TaskOptions} [options={}] - Additional task options to configure the insert operation. Defaults to an empty object.
+     * @return {object} A task configuration object for the database insert operation.
+     */
+    static createDatabaseInsertTask(tableName: string, databaseServiceName?: string | undefined, queryData?: DbOperationPayload, options?: TaskOptions): DatabaseTask;
+    /**
+     * Creates a database query task for the specified table and configuration.
+     *
+     * @param {string} tableName - The name of the database table to execute the query on.
+     * @param {string | undefined} [databaseServiceName=undefined] - The name of the database service to use. If undefined, the default service will be used.
+     * @param {DbOperationPayload} queryData - The payload containing the query data to be executed.
+     * @param {TaskOptions} [options={}] - Optional parameters to configure the task execution.
+     * @return {Task} The created database query task.
+     */
+    static createDatabaseQueryTask(tableName: string, databaseServiceName: string | undefined, queryData: DbOperationPayload, options?: TaskOptions): DatabaseTask;
+    /**
+     * Creates a database task for the CadenzaDB with the specified parameters.
+     *
+     * @param {string} tableName - The name of the database table on which the operation will be performed.
+     * @param {DbOperationType} operation - The type of database operation to execute (e.g., INSERT, UPDATE, DELETE).
+     * @param {DbOperationPayload} queryData - The payload or data required to perform the database operation.
+     * @param {TaskOptions} [options={}] - Additional options for the task, such as configuration settings.
+     * @return {any} The result of creating the database task.
+     */
+    static createCadenzaDBTask(tableName: string, operation: DbOperationType$1, queryData: DbOperationPayload, options?: TaskOptions): DatabaseTask;
+    /**
+     * Creates a database insert task specifically for the CadenzaDB database.
+     *
+     * @param {string} tableName - The name of the table into which the data will be inserted.
+     * @param {DbOperationPayload} [queryData={}] - An object representing the data to be inserted.
+     * @param {TaskOptions} [options={}] - Additional options to customize the task. The `isMeta` property is set to true by default.
+     * @return {Task} A task object configured to perform an insert operation in the CadenzaDB database.
+     */
+    static createCadenzaDBInsertTask(tableName: string, queryData?: DbOperationPayload, options?: TaskOptions): DatabaseTask;
+    /**
+     * Creates a database query task specifically for the CadenzaDB.
+     *
+     * @param {string} tableName - The name of the database table to execute the query on.
+     * @param {DbOperationPayload} queryData - The payload containing data and parameters for the database operation.
+     * @param {TaskOptions} [options={}] - Additional options for the task configuration.
+     * @return {any} The created task for executing a database query.
+     */
+    static createCadenzaDBQueryTask(tableName: string, queryData: DbOperationPayload, options?: TaskOptions): DatabaseTask;
+    /**
+     * Creates a new Cadenza service with the specified configuration.
+     *
+     * @param {string} serviceName - The unique name of the service to create.
+     * @param {string} [description] - An optional description of the service.
+     * @param {ServerOptions} [options] - An optional object containing configuration options for the service.
+     * @return {boolean} Returns true when the service is successfully created.
+     */
+    static createCadenzaService(serviceName: string, description?: string, options?: ServerOptions): void;
+    /**
+     * Creates a Cadenza metadata service with the specified name, description, and options.
+     *
+     * @param {string} serviceName - The name of the metadata service to be created.
+     * @param {string} description - A brief description of the metadata service.
+     * @param {ServerOptions} [options={}] - Optional configuration for the metadata service. Defaults to an empty object.
+     * @return {void} Does not return a value.
+     */
+    static createCadenzaMetaService(serviceName: string, description: string, options?: ServerOptions): void;
+    /**
+     * Creates a framework-agnostic browser runtime actor on top of frontend mode.
+     * The actor owns readiness and projected browser runtime state while the caller
+     * remains free to adapt that state into any frontend framework.
+     */
+    static createBrowserRuntimeActor<TProjectionState extends Record<string, any>>(options: BrowserRuntimeActorOptions<TProjectionState>): BrowserRuntimeActorHandle<TProjectionState>;
+    /**
+     * Creates and initializes a specialized PostgresActor.
+     * This is actor-only and does not create or register a network service.
+     *
+     * @param {string} name - Logical PostgresActor name.
+     * @param {DatabaseSchemaDefinition} schema - Database schema definition.
+     * @param {string} [description=""] - Optional human-readable actor description.
+     * @param {ServerOptions & DatabaseOptions} [options={}] - Actor/database runtime options.
+     * @return {void}
+     */
+    static createPostgresActor(name: string, schema: DatabaseSchemaDefinition, description?: string, options?: ServerOptions & DatabaseOptions): void;
+    /**
+     * Creates a meta PostgresActor.
+     *
+     * @param {string} name - Logical PostgresActor name.
+     * @param {DatabaseSchemaDefinition} schema - Database schema definition.
+     * @param {string} [description=""] - Optional description.
+     * @param {ServerOptions & DatabaseOptions} [options={}] - Optional actor/database options.
+     * @return {void}
+     */
+    static createMetaPostgresActor(name: string, schema: DatabaseSchemaDefinition, description?: string, options?: ServerOptions & DatabaseOptions): void;
+    /**
+     * Creates a dedicated database service by composing a PostgresActor and a Cadenza service.
+     */
+    static createDatabaseService(name: string, schema: DatabaseSchemaDefinition, description?: string, options?: ServerOptions & DatabaseOptions): void;
+    /**
+     * Creates a meta database service with the specified configuration.
+     *
+     * @param {string} name - The name of the database service to be created.
+     * @param {DatabaseSchemaDefinition} schema - The schema definition for the database.
+     * @param {string} [description=""] - An optional description of the database service.
+     * @param {ServerOptions & DatabaseOptions} [options={}] - Optional server and database configuration options. The `isMeta` flag will be automatically set to true.
+     * @return {void} - This method does not return a value.
+     */
+    static createMetaDatabaseService(name: string, schema: DatabaseSchemaDefinition, description?: string, options?: ServerOptions & DatabaseOptions): void;
+    private static normalizePostgresActorOptions;
+    private static normalizeDatabaseServiceOptions;
+    private static registerDatabaseServiceBridgeTask;
+    static createActor<D extends Record<string, any> = AnyObject, R = AnyObject>(spec: ActorSpec<D, R>, options?: ActorFactoryOptions): Actor<D, R>;
+    static createActorFromDefinition<D extends Record<string, any> = AnyObject, R = AnyObject>(definition: ActorDefinition<D, R>, options?: ActorFactoryOptions<D, R>): Actor<D, R>;
+    /**
+     * Creates and registers a new task with the provided name, function, and optional details.
+     *
+     * @param {string} name - The name of the task to be created.
+     * @param {TaskFunction} func - The function that contains the task execution logic.
+     * @param {string} [description] - An optional description of what the task does.
+     * @param {TaskOptions} [options={}] - An optional configuration object specifying additional task options.
+     * @return {Task} - The created task instance.
+     *
+     * @example
+     * You can use arrow functions to create tasks.
+     * ```ts
+     * const task = Cadenza.createTask('My task', (ctx) => {
+     *   console.log('My task executed with context:', ctx);
+     * }, 'My task description');
+     * ```
+     *
+     * You can also use named functions to create tasks.
+     * This is the preferred way to create tasks since it allows for code inspection in the CadenzaUI.
+     * ```ts
+     * function myTask(ctx) {
+     *   console.log('My task executed with context:', ctx);
+     * }
+     *
+     * const task = Cadenza.createTask('My task', myTask);
+     * ```
+     *
+     * ** Use the TaskOptions object to configure the task. **
+     *
+     * With concurrency limit, timeout limit and retry settings.
+     * ```ts
+     * Cadenza.createTask('My task', (ctx) => {
+     *   console.log('My task executed with context:', ctx);
+     * }, 'My task description', {
+     *   concurrency: 10,
+     *   timeout: 10000,
+     *   retryCount: 3,
+     *   retryDelay: 1000,
+     *   retryDelayFactor: 1.5,
+     * });
+     * ```
+     *
+     * You can specify the input and output context schemas for the task.
+     * ```ts
+     * Cadenza.createTask('My task', (ctx) => {
+     *   return { bar: 'foo' + ctx.foo };
+     * }, 'My task description', {
+     *   inputContextSchema: {
+     *     type: 'object',
+     *     properties: {
+     *       foo: {
+     *         type: 'string',
+     *       },
+     *     },
+     *   required: ['foo'],
+     *   },
+     *   validateInputContext: true, // default is false
+     *   outputContextSchema: {
+     *     type: 'object',
+     *     properties: {
+     *       bar: {
+     *         type: 'string',
+     *       },
+     *     },
+     *     required: ['bar'],
+     *   },
+     *   validateOutputContext: true, // default is false
+     * });
+     * ```
+     */
+    static createTask(name: string, func: TaskFunction, description?: string, options?: TaskOptions): Task;
+    /**
+     * Creates a meta task with the specified name, functionality, description, and options.
+     * This is used for creating tasks that lives on the meta layer.
+     * The meta layer is a special layer that is executed separately from the business logic layer and is used for extending Cadenzas core functionality.
+     * See {@link Task} or {@link createTask} for more information.
+     *
+     * @param {string} name - The name of the meta task.
+     * @param {TaskFunction} func - The function to be executed by the meta task.
+     * @param {string} [description] - An optional description of the meta task.
+     * @param {TaskOptions} [options={}] - Additional optional task configuration. Automatically sets `isMeta` to true.
+     * @return {Task} A task instance configured as a meta task.
+     */
+    static createMetaTask(name: string, func: TaskFunction, description?: string, options?: TaskOptions): Task;
+    /**
+     * Creates a unique task by wrapping the provided task function with a uniqueness constraint.
+     * Unique tasks are designed to execute once per execution ID, merging parents. This is useful for
+     * tasks that require fan-in/joins after parallel branches.
+     * See {@link Task} for more information.
+     * @param {string} name Unique identifier.
+     * @param {TaskFunction} func Function receiving joinedContexts as a list (context.joinedContexts).
+     * @param {string} [description] Optional description.
+     * @param {TaskOptions} [options={}] Optional task options.
+     * @returns {Task} The created UniqueTask.
+     *
+     * @example
+     * ```ts
+     * const splitTask = Cadenza.createTask('Split foos', function* (ctx) {
+     *   for (const foo of ctx.foos) {
+     *     yield { foo };
+     *   }
+     * }, 'Splits a list of foos into multiple sub-branches');
+     *
+     * const processTask = Cadenza.createTask('Process foo', (ctx) => {
+     *  return { bar: 'foo' + ctx.foo };
+     * }, 'Process a foo');
+     *
+     * const uniqueTask = Cadenza.createUniqueTask('Gather processed foos', (ctx) => {
+     *   // A unique task will always be provided with a list of contexts (ctx.joinedContexts) from its predecessors.
+     *   const processedFoos = ctx.joinedContexts.map((c) => c.bar);
+     *   return { foos: processedFoos };
+     * }, 'Gathers together the processed foos.');
+     *
+     * splitTask.then(
+     *   processTask.then(
+     *     uniqueTask,
+     *   ),
+     * );
+     *
+     * // Give the flow a name using a routine
+     * Cadenza.createRoutine(
+     *   'Process foos',
+     *   [splitTask],
+     *   'Processes a list of foos'
+     * ).doOn('main.received_foos'); // Subscribe to a signal
+     *
+     * // Trigger the flow from anywhere
+     * Cadenza.emit('main.received_foos', { foos: ['foo1', 'foo2', 'foo3'] });
+     * ```
+     */
+    static createUniqueTask(name: string, func: TaskFunction, description?: string, options?: TaskOptions): Task;
+    /**
+     * Creates a unique meta task with the specified name, function, description, and options.
+     * See {@link createUniqueTask} and {@link createMetaTask} for more information.
+     *
+     * @param {string} name - The name of the task to create.
+     * @param {TaskFunction} func - The function to execute when the task is run.
+     * @param {string} [description] - An optional description of the task.
+     * @param {TaskOptions} [options={}] - Optional settings for the task. Defaults to an empty object. Automatically sets `isMeta` and `isUnique` to true.
+     * @return {Task} The created unique meta task.
+     */
+    static createUniqueMetaTask(name: string, func: TaskFunction, description?: string, options?: TaskOptions): Task;
+    /**
+     * Creates a throttled task with a concurrency limit of 1, ensuring that only one instance of the task can run at a time for a specific throttle tag.
+     * This is useful for ensuring execution order and preventing race conditions.
+     * See {@link Task} for more information.
+     *
+     * @param {string} name - The name of the task.
+     * @param {TaskFunction} func - The function to be executed when the task runs.
+     * @param {ThrottleTagGetter} [throttledIdGetter=() => "default"] - A function that generates a throttle tag identifier to group tasks for throttling.
+     * @param {string} [description] - An optional description of the task.
+     * @param {TaskOptions} [options={}] - Additional options to customize the task behavior.
+     * @return {Task} The created throttled task.
+     *
+     * @example
+     * ```ts
+     * const task = Cadenza.createThrottledTask(
+     *   'My task',
+     *   async (ctx) => {
+     *      await new Promise((resolve) => setTimeout(resolve, 1000));
+     *      console.log('My task executed with context:', ctx);
+     *   },
+     *   // Will throttle by the value of ctx.foo to make sure tasks with the same value are executed sequentially
+     *   (ctx) => ctx.foo,
+     * );
+     *
+     * Cadenza.run(task, { foo: 'bar' }); // (First execution)
+     * Cadenza.run(task, { foo: 'bar' }); // This will be executed after the first execution is finished
+     * Cadenza.run(task, { foo: 'baz' }); // This will be executed in parallel with the first execution
+     * ```
+     */
+    static createThrottledTask(name: string, func: TaskFunction, throttledIdGetter?: ThrottleTagGetter, description?: string, options?: TaskOptions): Task;
+    /**
+     * Creates a throttled meta task with the specified configuration.
+     * See {@link createThrottledTask} and {@link createMetaTask} for more information.
+     *
+     * @param {string} name - The name of the throttled meta task.
+     * @param {TaskFunction} func - The task function to be executed.
+     * @param {ThrottleTagGetter} throttledIdGetter - A function to retrieve the throttling identifier.
+     * @param {string} [description] - An optional description of the task.
+     * @param {TaskOptions} [options={}] - Additional options for configuring the task.
+     * @return {Task} The created throttled meta task.
+     */
+    static createThrottledMetaTask(name: string, func: TaskFunction, throttledIdGetter?: ThrottleTagGetter, description?: string, options?: TaskOptions): Task;
+    /**
+     * Creates and returns a new debounced task with the specified parameters.
+     * This is useful to prevent rapid execution of tasks that may be triggered by multiple events within a certain time frame.
+     * See {@link DebounceTask} for more information.
+     *
+     * @param {string} name - The unique name of the task to be created.
+     * @param {TaskFunction} func - The function to be executed by the task.
+     * @param {string} [description] - An optional description of the task.
+     * @param {number} [debounceTime=1000] - The debounce time in milliseconds to delay the execution of the task.
+     * @param {TaskOptions & DebounceOptions} [options={}] - Additional configuration options for the task, including debounce behavior and other task properties.
+     * @return {DebounceTask} A new instance of the DebounceTask with the specified configuration.
+     *
+     * @example
+     * ```ts
+     * const task = Cadenza.createDebounceTask(
+     *   'My debounced task',
+     *   (ctx) => {
+     *      console.log('My task executed with context:', ctx);
+     *   },
+     *   'My debounced task description',
+     *   100, // Debounce time in milliseconds. Default is 1000
+     *   {
+     *     leading: false, // Should the first execution of a burst be executed immediately? Default is false
+     *     trailing: true, // Should the last execution of a burst be executed? Default is true
+     *     maxWait: 1000, // Maximum time in milliseconds to wait for the next execution. Default is 0
+     *   },
+     * );
+     *
+     * Cadenza.run(task, { foo: 'bar' }); // This will not be executed
+     * Cadenza.run(task, { foo: 'bar' }); // This will not be executed
+     * Cadenza.run(task, { foo: 'baz' }); // This execution will be delayed by 100ms
+     * ```
+     */
+    static createDebounceTask(name: string, func: TaskFunction, description?: string, debounceTime?: number, options?: TaskOptions & DebounceOptions): DebounceTask;
+    /**
+     * Creates a debounced meta task with the specified parameters.
+     * See {@link createDebounceTask} and {@link createMetaTask} for more information.
+     *
+     * @param {string} name - The name of the task.
+     * @param {TaskFunction} func - The function to be executed by the task.
+     * @param {string} [description] - Optional description of the task.
+     * @param {number} [debounceTime=1000] - The debounce delay in milliseconds.
+     * @param {TaskOptions & DebounceOptions} [options={}] - Additional configuration options for the task.
+     * @return {DebounceTask} Returns an instance of the debounced meta task.
+     */
+    static createDebounceMetaTask(name: string, func: TaskFunction, description?: string, debounceTime?: number, options?: TaskOptions & DebounceOptions): DebounceTask;
+    /**
+     * Creates an ephemeral task with the specified configuration.
+     * Ephemeral tasks are designed to self-destruct after execution or a certain condition is met.
+     * This is useful for transient tasks such as resolving promises or performing cleanup operations.
+     * They are not registered by default.
+     * See {@link EphemeralTask} for more information.
+     *
+     * @param {string} name - The name of the task to be created.
+     * @param {TaskFunction} func - The function that defines the logic of the task.
+     * @param {string} [description] - An optional description of the task.
+     * @param {TaskOptions & EphemeralTaskOptions} [options={}] - The configuration options for the task, including concurrency, timeouts, and retry policies.
+     * @return {EphemeralTask} The created ephemeral task instance.
+     *
+     * @example
+     * By default, ephemeral tasks are executed once and destroyed after execution.
+     * ```ts
+     * const task = Cadenza.createEphemeralTask('My ephemeral task', (ctx) => {
+     *   console.log('My task executed with context:', ctx);
+     * });
+     *
+     * Cadenza.run(task); // Executes the task once and destroys it after execution
+     * Cadenza.run(task); // Does nothing, since the task is destroyed
+     * ```
+     *
+     * Use destroy condition to conditionally destroy the task
+     * ```ts
+     * const task = Cadenza.createEphemeralTask(
+     *   'My ephemeral task',
+     *   (ctx) => {
+     *      console.log('My task executed with context:', ctx);
+     *   },
+     *   'My ephemeral task description',
+     *   {
+     *     once: false, // Should the task be executed only once? Default is true
+     *     destroyCondition: (ctx) => ctx.foo > 10, // Should the task be destroyed after execution? Default is undefined
+     *   },
+     * );
+     *
+     * Cadenza.run(task, { foo: 5 }); // The task will not be destroyed and can still be executed
+     * Cadenza.run(task, { foo: 10 }); // The task will not be destroyed and can still be executed
+     * Cadenza.run(task, { foo: 20 }); // The task will be destroyed after execution and cannot be executed anymore
+     * Cadenza.run(task, { foo: 30 }); // This will not be executed
+     * ```
+     *
+     * A practical use case for ephemeral tasks is to resolve a promise upon some external event.
+     * ```ts
+     * const task = Cadenza.createTask('Confirm something', (ctx, emit) => {
+     *   return new Promise((resolve) => {
+     *     ctx.foo = uuid();
+     *
+     *     Cadenza.createEphemeralTask(`Resolve promise of ${ctx.foo}`, (c) => {
+     *       console.log('My task executed with context:', ctx);
+     *       resolve(c);
+     *     }).doOn(`socket.confirmation_received:${ctx.foo}`);
+     *
+     *     emit('this_domain.confirmation_requested', ctx);
+     *   });
+     * });
+     * ```
+     */
+    static createEphemeralTask(name: string, func: TaskFunction, description?: string, options?: TaskOptions & EphemeralTaskOptions): EphemeralTask;
+    /**
+     * Creates an ephemeral meta-task with the specified name, function, description, and options.
+     * See {@link createEphemeralTask} and {@link createMetaTask} for more details.
+     *
+     * @param {string} name - The name of the task to be created.
+     * @param {TaskFunction} func - The function to be executed as part of the task.
+     * @param {string} [description] - An optional description of the task.
+     * @param {TaskOptions & EphemeralTaskOptions} [options={}] - Additional options for configuring the task.
+     * @return {EphemeralTask} The created ephemeral meta-task.
+     */
+    static createEphemeralMetaTask(name: string, func: TaskFunction, description?: string, options?: TaskOptions & EphemeralTaskOptions): EphemeralTask;
+    /**
+     * Creates a new routine with the specified name, tasks, and an optional description.
+     * Routines are named entry points to starting tasks and are registered in the GraphRegistry.
+     * They are used to group tasks together and provide a high-level structure for organizing and managing the execution of a set of tasks.
+     * See {@link GraphRoutine} for more information.
+     *
+     * @param {string} name - The name of the routine to create.
+     * @param {Task[]} tasks - A list of tasks to include in the routine.
+     * @param {string} [description=""] - An optional description for the routine.
+     * @return {GraphRoutine} A new instance of the GraphRoutine containing the specified tasks and description.
+     *
+     * @example
+     * ```ts
+     * const task1 = Cadenza.createTask("Task 1", () => {});
+     * const task2 = Cadenza.createTask("Task 2", () => {});
+     *
+     * task1.then(task2);
+     *
+     * const routine = Cadenza.createRoutine("Some routine", [task1]);
+     *
+     * Cadenza.run(routine);
+     *
+     * // Or, routines can be triggered by signals
+     * routine.doOn("some.signal");
+     *
+     * Cadenza.emit("some.signal", {});
+     * ```
+     */
+    static createRoutine(name: string, tasks: Task[], description?: string): GraphRoutine;
+    /**
+     * Creates a meta routine with a given name, tasks, and optional description.
+     * Routines are named entry points to starting tasks and are registered in the GraphRegistry.
+     * They are used to group tasks together and provide a high-level structure for organizing and managing the execution of a set of tasks.
+     * See {@link GraphRoutine} and {@link createRoutine} for more information.
+     *
+     * @param {string} name - The name of the routine to be created.
+     * @param {Task[]} tasks - An array of tasks that the routine will consist of.
+     * @param {string} [description=""] - An optional description for the routine.
+     * @return {GraphRoutine} A new instance of the `GraphRoutine` representing the created routine.
+     */
+    static createMetaRoutine(name: string, tasks: Task[], description?: string): GraphRoutine;
+    static reset(): void;
+}
+
+export { AUTHORITY_RUNTIME_STATUS_REPORT_INTENT as A, type BootstrapOptions as B, CadenzaService as C, type DatabaseSchemaDefinition as D, type ServiceInstanceDescriptor as E, type FieldDefinition as F, type ServiceTransportConfig as G, type HydrationOptions as H, type InquiryResponderDescriptor as I, type JoinDefinition as J, type ServiceTransportDescriptor as K, type ServiceTransportProtocol as L, type ServiceTransportRole as M, type NetworkMode as N, type OpEffect as O, type ServiceTransportSecurityProfile as P, type QueryMode as Q, RUNTIME_STATUS_AUTHORITY_SYNC_REQUESTED_SIGNAL as R, type ServerOptions as S, SignalTransmissionTask as T, type SortDirection as U, type SubOperationType as V, type TableDefinition as W, type ValueOrSubOp as X, buildAuthorityRuntimeStatusSignature as Y, normalizeAuthorityRuntimeStatusReport as Z, type DatabaseOptions as a, type DbOperationPayload as b, type SubOperation as c, type DistributedInquiryOptions as d, ServiceRegistry as e, type AggregateDefinition as f, type AggregateFunction as g, type AuthorityRuntimeStatusReport as h, type BrowserRuntimeActorHandle as i, type BrowserRuntimeActorOptions as j, type BrowserRuntimeActorRuntimeState as k, type BrowserRuntimeProjectionBinding as l, type BrowserRuntimeServiceOptions as m, type DatabaseMigrationConstraintDefinition as n, type DatabaseMigrationDefinition as o, type DatabaseMigrationPolicy as p, type DatabaseMigrationStep as q, DatabaseTask as r, type DbOperationType$1 as s, type DeputyDescriptor as t, DeputyTask as u, type DistributedInquiryMeta as v, type InquiryResponderStatus as w, type ResolvedBootstrapEndpoint as x, type RuntimeMetricsHealthDetail as y, type SecurityProfile as z };