import type { LTApiResult } from '../types/sdk';
import type { StreamMessageStatus } from '../services/controlplane/types';
/**
 * List all registered application namespaces.
 *
 * @returns `{ status: 200, data: { apps } }` array of known app identifiers
 */
export declare function listApps(): Promise<LTApiResult>;
/**
 * Query active worker profiles for an application.
 *
 * Sends a roll-call request to the mesh and collects responses from
 * all running workers within the optional delay window.
 *
 * @param input.appId — application namespace to query (defaults to 'durable')
 * @param input.delay — milliseconds to wait for worker responses before returning
 * @returns `{ status: 200, data: { profiles } }` array of worker profile objects
 */
export declare function rollCall(input: {
    appId?: string;
    delay?: number;
}): Promise<LTApiResult>;
/**
 * Apply a throttle rate to workflow execution.
 *
 * Sets the throttle value for a specific topic or workflow within an app
 * namespace. Also publishes a synthetic `mesh.throttle` event so the
 * dashboard event stream reflects the change.
 *
 * @param input.appId — application namespace (defaults to 'durable')
 * @param input.throttle — throttle value to apply (required, must be a number)
 * @param input.topic — optional topic to scope the throttle to
 * @param input.guid — optional workflow GUID to scope the throttle to
 * @returns `{ status: 200, data: { success } }` boolean indicating the throttle was applied
 */
export declare function applyThrottle(input: {
    appId?: string;
    throttle: number;
    topic?: string;
    guid?: string;
    scope?: 'engines' | 'workers' | 'all';
}): Promise<LTApiResult>;
/**
 * Retrieve stream statistics for an application.
 *
 * Returns throughput and backlog metrics for Redis streams backing the
 * given app namespace over the specified time window.
 *
 * @param input.app_id — application namespace (defaults to 'durable')
 * @param input.duration — time window for stats aggregation, e.g. '1h', '30m' (defaults to '1h')
 * @param input.stream — optional specific stream name to filter results
 * @returns `{ status: 200, data: { ... } }` stream statistics object
 */
export declare function getStreamStats(input: {
    app_id?: string;
    duration?: string;
    stream?: string;
}): Promise<LTApiResult>;
/**
 * Subscribe to mesh events for an application.
 *
 * Establishes a subscription to the event stream of the given app
 * namespace so that mesh events are captured and forwarded.
 *
 * @param input.appId — application namespace to subscribe to (defaults to 'durable')
 * @returns `{ status: 200, data: { subscribed, appId } }` confirmation with the subscribed app ID
 */
export declare function subscribeMesh(input: {
    appId?: string;
}): Promise<LTApiResult>;
/**
 * Browse stream messages across engine and worker streams.
 *
 * Returns paginated, filterable, sortable results from the Postgres
 * engine_streams and worker_streams tables. Messages are schema-isolated
 * by namespace.
 *
 * @param input.namespace — Postgres schema (required, e.g. "durable")
 * @param input.limit — page size (1–100, default 25)
 * @param input.offset — pagination offset (default 0)
 * @param input.sort_by — sort column: created_at, stream_name, priority, id
 * @param input.order — sort direction: asc | desc (default desc)
 * @param input.source — filter by source: engine | worker (default all)
 * @param input.status — filter by status: pending | claimed | processed | dead_lettered
 * @param input.stream_name — partial match on stream name (ILIKE)
 * @param input.msg_type — filter by message type (worker streams only)
 */
export declare function listStreamMessages(input: {
    namespace: string;
    source: string;
    limit?: number;
    offset?: number;
    sort_by?: string;
    order?: 'asc' | 'desc';
    status?: StreamMessageStatus | null;
    stream_name?: string | null;
    msg_type?: string | null;
    topic?: string | null;
    workflow_name?: string | null;
    jid?: string | null;
    aid?: string | null;
}): Promise<LTApiResult>;
