@stacksjs/ts-cloud 0.7.55 → 0.7.57

package/dist/alerts/alerts.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/alerts/delivery.d.ts

@@ -0,0 +1,45 @@
+import type { Alert, NotificationChannel, NotificationDelivery, NotificationRoute } from './model';
+import { AlertStore } from './store';
+export type NotificationFetch = (input: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+    signal?: AbortSignal;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+}>;
+export type NotificationEmail = (input: {
+    to: string | string[];
+    from?: string;
+    subject: string;
+    text: string;
+}) => Promise<unknown>;
+export declare function isQuietHours(route: NotificationRoute, at: Date): boolean;
+export declare class NotificationRouter {
+    private readonly store;
+    private readonly options;
+    private readonly fetchImpl;
+    constructor(store: AlertStore, options?: {
+        fetchImpl?: NotificationFetch;
+        emailImpl?: NotificationEmail;
+        now?: () => Date;
+    });
+    private now;
+    preview(organizationId: string, alert: Alert, eventType: string): Array<{
+        route: NotificationRoute;
+        channels: NotificationChannel[];
+        quiet: boolean;
+    }>;
+    enqueue(organizationId: string, alert: Alert, eventType: 'firing' | 'resolved' | 'reminder' | 'escalation'): NotificationDelivery[];
+    enqueueRemindersAndEscalations(organizationId: string, alerts: Alert[]): NotificationDelivery[];
+    private send;
+    deliver(id: string): Promise<NotificationDelivery>;
+    deliverAll(deliveries: NotificationDelivery[]): Promise<NotificationDelivery[]>;
+    retryDue(): Promise<NotificationDelivery[]>;
+    testChannel(id: string): Promise<{
+        ok: boolean;
+        status?: number;
+        error?: string;
+    }>;
+}

package/dist/alerts/evaluator.d.ts

@@ -0,0 +1,12 @@
+import type { Alert, AlertRule, AlertSample } from './model';
+import { AlertStore } from './store';
+export interface AlertEvaluation {
+    alert?: Alert;
+    transition: 'ignored' | 'pending' | 'firing' | 'updated' | 'resolved' | 'silenced';
+    notify: boolean;
+}
+export declare class AlertEvaluator {
+    private readonly store;
+    constructor(store: AlertStore);
+    evaluate(rule: AlertRule, sample: AlertSample): AlertEvaluation;
+}

package/dist/alerts/health.d.ts

@@ -0,0 +1,34 @@
+import type { AlertEvaluation } from './evaluator';
+import type { HealthCheck, HealthResult } from './model';
+import { AlertStore } from './store';
+type FetchLike = (input: string, init: {
+    method: string;
+    headers?: Record<string, string>;
+    signal: AbortSignal;
+    redirect: 'manual';
+}) => Promise<Response>;
+type CommandLike = (command: string[], timeoutMs: number) => Promise<{
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+export declare class HealthCheckRunner {
+    private readonly store;
+    private readonly options;
+    constructor(store: AlertStore, options?: {
+        fetchImpl?: FetchLike;
+        commandImpl?: CommandLike;
+        lookupImpl?: (hostname: string) => Promise<unknown>;
+        now?: () => Date;
+        agent?: string;
+        region?: string;
+    });
+    private now;
+    probe(check: HealthCheck): Promise<Omit<HealthResult, 'id'>>;
+    run(check: HealthCheck): Promise<HealthResult>;
+    runAndEvaluate(check: HealthCheck): Promise<{
+        result: HealthResult;
+        evaluations: AlertEvaluation[];
+    }>;
+}
+export {};

package/dist/alerts/index.d.ts

@@ -0,0 +1,6 @@
+export * from './model';
+export * from './store';
+export * from './evaluator';
+export * from './delivery';
+export * from './health';
+export * from './telemetry';

package/dist/alerts/model.d.ts

@@ -0,0 +1,170 @@
+import type { JsonValue } from '../control-plane';
+export type HealthCheckKind = 'http' | 'tcp' | 'command';
+export type HealthStatus = 'healthy' | 'unhealthy' | 'no_data';
+export type AlertState = 'pending' | 'firing' | 'resolved' | 'silenced';
+export type AlertSeverity = 'info' | 'warning' | 'critical';
+export type NotificationChannelKind = 'slack' | 'discord' | 'teams' | 'telegram' | 'email' | 'webhook';
+export interface HealthCheck {
+    id: string;
+    projectId: string;
+    environmentId?: string;
+    resourceId?: string;
+    name: string;
+    kind: HealthCheckKind;
+    target: string;
+    config: {
+        method?: string;
+        path?: string;
+        port?: number;
+        command?: string[];
+        expectedStatuses?: number[];
+        expectedBody?: string;
+        headers?: Record<string, string>;
+    };
+    intervalSeconds: number;
+    timeoutSeconds: number;
+    failureThreshold: number;
+    recoveryThreshold: number;
+    regions: string[];
+    enabled: boolean;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface HealthResult {
+    id: string;
+    checkId: string;
+    status: HealthStatus;
+    agent: string;
+    region?: string;
+    statusCode?: number;
+    message?: string;
+    timings: {
+        dnsMs?: number;
+        connectMs?: number;
+        tlsMs?: number;
+        ttfbMs?: number;
+        totalMs?: number;
+    };
+    checkedAt: string;
+}
+export interface AlertRule {
+    id: string;
+    projectId: string;
+    environmentId?: string;
+    resourceId?: string;
+    healthCheckId?: string;
+    name: string;
+    signal: string;
+    operator: 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'unhealthy';
+    threshold?: number;
+    recoveryThreshold?: number;
+    windowMs: number;
+    consecutive: number;
+    recoveryConsecutive: number;
+    noDataPolicy: 'ignore' | 'pending' | 'firing';
+    severity: AlertSeverity;
+    groupBy: string[];
+    labels: Record<string, JsonValue>;
+    enabled: boolean;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Alert {
+    id: string;
+    ruleId: string;
+    projectId: string;
+    environmentId?: string;
+    resourceId?: string;
+    dedupKey: string;
+    groupKey: string;
+    state: AlertState;
+    severity: AlertSeverity;
+    title: string;
+    evidence: Record<string, JsonValue>;
+    failureCount: number;
+    recoveryCount: number;
+    occurrenceCount: number;
+    ownerActorId?: string;
+    acknowledgedByActorId?: string;
+    acknowledgedAt?: string;
+    firstSeenAt: string;
+    lastSeenAt: string;
+    firingAt?: string;
+    resolvedAt?: string;
+    silencedUntil?: string;
+    updatedAt: string;
+}
+export interface AlertSample {
+    status?: HealthStatus;
+    value?: number;
+    timestamp: string;
+    group?: Record<string, string>;
+    evidence?: Record<string, unknown>;
+}
+export interface NotificationChannel {
+    id: string;
+    organizationId: string;
+    name: string;
+    kind: NotificationChannelKind;
+    config: Record<string, JsonValue>;
+    credentialFingerprint?: string;
+    hasCredential: boolean;
+    status: 'active' | 'paused' | 'failing' | 'disabled';
+    version: number;
+    lastTestedAt?: string;
+    lastError?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface NotificationRoute {
+    id: string;
+    organizationId: string;
+    name: string;
+    priority: number;
+    matcher: {
+        projectIds?: string[];
+        environmentIds?: string[];
+        resourceIds?: string[];
+        severities?: AlertSeverity[];
+        eventTypes?: string[];
+    };
+    channelIds: string[];
+    quietHours?: {
+        timezone: string;
+        start: string;
+        end: string;
+        weekdays?: number[];
+    };
+    groupWaitSeconds: number;
+    reminderSeconds?: number;
+    escalation: Array<{
+        afterSeconds: number;
+        channelIds: string[];
+    }>;
+    template?: string;
+    rateLimitPerMinute: number;
+    enabled: boolean;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface NotificationDelivery {
+    id: string;
+    alertId?: string;
+    channelId: string;
+    routeId?: string;
+    eventType: string;
+    idempotencyKey: string;
+    state: 'pending' | 'delivered' | 'retrying' | 'failed' | 'dead';
+    attempt: number;
+    maxAttempts: number;
+    nextAttemptAt?: string;
+    responseStatus?: number;
+    error?: string;
+    payload: Record<string, JsonValue>;
+    createdAt: string;
+    updatedAt: string;
+    deliveredAt?: string;
+}

package/dist/alerts/store.d.ts

@@ -0,0 +1,90 @@
+import type { ControlPlaneStore, JsonValue } from '../control-plane';
+import type { Alert, AlertRule, HealthCheck, HealthResult, NotificationChannel, NotificationDelivery, NotificationRoute } from './model';
+export declare class AlertStore {
+    readonly controlPlane: ControlPlaneStore;
+    private readonly options;
+    private readonly key;
+    constructor(controlPlane: ControlPlaneStore, options: {
+        now?: () => Date;
+        encryptionKey: string;
+    });
+    now(): string;
+    private encrypt;
+    private decrypt;
+    createHealthCheck(input: Omit<HealthCheck, 'id' | 'version' | 'createdAt' | 'updatedAt'>): HealthCheck;
+    getHealthCheck(id: string): HealthCheck | undefined;
+    listHealthChecks(projectId: string, environmentId?: string): HealthCheck[];
+    setHealthCheckEnabled(id: string, enabled: boolean): HealthCheck;
+    appendHealthResult(input: Omit<HealthResult, 'id'>): HealthResult;
+    listHealthResults(checkId: string, limit?: number): HealthResult[];
+    createRule(input: Omit<AlertRule, 'id' | 'version' | 'createdAt' | 'updatedAt'>): AlertRule;
+    getRule(id: string): AlertRule | undefined;
+    listRules(projectId: string, environmentId?: string): AlertRule[];
+    setRuleEnabled(id: string, enabled: boolean): AlertRule;
+    getAlertByDedup(dedupKey: string): Alert | undefined;
+    getAlert(id: string): Alert | undefined;
+    listAlerts(projectId: string, input?: {
+        environmentId?: string;
+        states?: string[];
+        limit?: number;
+    }): Alert[];
+    saveAlert(value: Alert, eventType: string, actorId?: string): Alert;
+    acknowledge(id: string, actorId: string): Alert;
+    assign(id: string, ownerActorId: string | undefined, actorId?: string): Alert;
+    silenceAlert(id: string, until: string, actorId?: string): Alert;
+    createSilence(input: {
+        projectId: string;
+        environmentId?: string;
+        resourceId?: string;
+        matcher?: Record<string, unknown>;
+        reason: string;
+        startsAt: string;
+        endsAt: string;
+        timezone: string;
+        actorId?: string;
+    }): string;
+    isSilenced(rule: AlertRule, group: Record<string, string>, at: string): boolean;
+    createChannel(input: {
+        organizationId: string;
+        name: string;
+        kind: NotificationChannel['kind'];
+        config?: Record<string, unknown>;
+        credential?: string;
+        actorId?: string;
+    }): NotificationChannel;
+    getChannel(id: string): NotificationChannel | undefined;
+    channelCredential(id: string): string | undefined;
+    listChannels(organizationId: string): NotificationChannel[];
+    rotateChannel(id: string, credential: string): NotificationChannel;
+    setChannelStatus(id: string, status: NotificationChannel['status'], error?: string): NotificationChannel;
+    markChannelTest(id: string, ok: boolean, error?: string): NotificationChannel;
+    createRoute(input: Omit<NotificationRoute, 'id' | 'version' | 'createdAt' | 'updatedAt'>): NotificationRoute;
+    getRoute(id: string): NotificationRoute | undefined;
+    listRoutes(organizationId: string): NotificationRoute[];
+    countRouteDeliveries(routeId: string, since: string): number;
+    setRouteEnabled(id: string, enabled: boolean): NotificationRoute;
+    createDelivery(input: {
+        alertId?: string;
+        channelId: string;
+        routeId?: string;
+        eventType: string;
+        idempotencyKey: string;
+        payload: Record<string, JsonValue>;
+        maxAttempts?: number;
+        nextAttemptAt?: string;
+    }): NotificationDelivery;
+    getDelivery(id: string): NotificationDelivery | undefined;
+    listDeliveries(input?: {
+        alertId?: string;
+        states?: string[];
+        limit?: number;
+    }): NotificationDelivery[];
+    updateDelivery(id: string, input: {
+        state: NotificationDelivery['state'];
+        attempt: number;
+        nextAttemptAt?: string;
+        responseStatus?: number;
+        error?: string;
+        deliveredAt?: string;
+    }): NotificationDelivery;
+}

package/dist/alerts/telemetry.d.ts

@@ -0,0 +1,3 @@
+import type { AlertEvaluation } from './evaluator';
+import { AlertStore } from './store';
+export declare function evaluateTelemetryAlertRules(store: AlertStore, projectId: string, environmentId?: string, now?: Date): AlertEvaluation[];

package/dist/api/client.d.ts

@@ -0,0 +1,197 @@
+import type { ComposeApplicationRecord, ComposeParseResult, ComposeServiceState, ComposeTemplate } from '../compose';
+import type { ApplicationArtifactRecord, ApplicationDraftRecord, RegistryConnection } from '../onboarding';
+import type { CreatePreviewDefinitionInput, PreviewDefinition, PreviewInstance } from '../preview';
+import type { QueueConcurrencyLimits } from '../queue';
+import type { ReleaseArtifact, ReleaseDeployableKind, ReleaseRecord, ReleaseStrategy, ReleaseStrategyCapability, ReleaseTransition } from '../release';
+import type { ApiApplicationCreateRequest, ApiApplicationCreateResponse, ApiApplicationDetectionRequest, ApiApplicationDetectionResponse, ApiApplicationDraftCreateRequest, ApiApplicationDraftUpdateRequest, ApiApplicationPlanRequest, ApiApplicationPlanResponse, ApiDeploymentRequest, ApiOperationLogsResponse, ApiOperationResponse, ApiPage, ApiQueueOperation, ApiQueueSettingsResponse, ApiRegistryConnectionCreateRequest, ApiRegistryConnectionUpdateRequest } from './types';
+export interface TsCloudClientOptions {
+    baseUrl: string;
+    token: string;
+    fetch?: typeof globalThis.fetch;
+}
+export declare class TsCloudApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly requestId?: string | undefined;
+    constructor(status: number, code: string, message: string, requestId?: string | undefined);
+}
+export declare class TsCloudClient {
+    private readonly options;
+    private readonly baseUrl;
+    private readonly fetchFn;
+    constructor(options: TsCloudClientOptions);
+    private request;
+    listProjects(options?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<ApiPage<Record<string, unknown>>>;
+    listEnvironments(projectId: string, options?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<ApiPage<Record<string, unknown>>>;
+    listServices(projectId: string, environmentId?: string): Promise<ApiPage<Record<string, unknown>>>;
+    listOperations(projectId?: string): Promise<ApiPage<Record<string, unknown>>>;
+    listComposeTemplates(): Promise<ApiPage<ComposeTemplate>>;
+    listComposeApplications(projectId: string, environmentId?: string): Promise<ApiPage<ComposeApplicationRecord & {
+        services: ComposeServiceState[];
+    }>>;
+    previewCompose(input: {
+        source: string;
+        name: string;
+        slug?: string;
+        projectId: string;
+        environmentId: string;
+    }): Promise<{
+        result: ComposeParseResult;
+        requestId: string;
+    }>;
+    createComposeApplication(input: {
+        source?: string;
+        templateId?: string;
+        templateVersion?: string;
+        inputs?: Record<string, string>;
+        name: string;
+        slug?: string;
+        projectId: string;
+        environmentId: string;
+    }): Promise<{
+        application: ComposeApplicationRecord;
+        diagnostics: ComposeParseResult['diagnostics'];
+        requestId: string;
+    }>;
+    composeServices(applicationId: string): Promise<{
+        application: ComposeApplicationRecord;
+        services: ComposeServiceState[];
+        requestId: string;
+    }>;
+    composeAction(applicationId: string, action: 'deploy' | 'redeploy' | 'start' | 'stop' | 'scale' | 'delete', input?: {
+        service?: string;
+        replicas?: number;
+        removeVolumes?: boolean;
+        confirm?: string;
+    }): Promise<ApiOperationResponse>;
+    releaseCapabilities(kind: ReleaseDeployableKind, input?: {
+        health?: boolean;
+        replicas?: number;
+    }): Promise<{
+        capabilities: ReleaseStrategyCapability[];
+        requestId: string;
+    }>;
+    listReleases(projectId: string, input?: {
+        environmentId?: string;
+        resourceId?: string;
+    }): Promise<ApiPage<ReleaseRecord & {
+        artifact: ReleaseArtifact;
+        transitions: ReleaseTransition[];
+    }>>;
+    createReleaseArtifact(input: {
+        digest: string;
+        kind: ReleaseDeployableKind;
+        uri: string;
+        size: number;
+        mediaType?: string;
+        provenance?: unknown;
+        attestation?: unknown;
+    }): Promise<{
+        artifact: ReleaseArtifact;
+        requestId: string;
+    }>;
+    createRelease(input: {
+        projectId: string;
+        environmentId: string;
+        resourceId: string;
+        artifactId: string;
+        kind: ReleaseDeployableKind;
+        sourceSha?: string;
+        config?: unknown;
+        manifest?: unknown;
+        strategy: ReleaseStrategy;
+        healthGate?: unknown;
+        approvalRequired?: boolean;
+    }): Promise<{
+        release: ReleaseRecord;
+        requestId: string;
+    }>;
+    releaseAction(releaseId: string, action: 'promote' | 'approve' | 'activate' | 'rollback' | 'health' | 'pin', input?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createDeployment(input: ApiDeploymentRequest, idempotencyKey: string): Promise<ApiOperationResponse>;
+    detectApplication(input: ApiApplicationDetectionRequest): Promise<ApiApplicationDetectionResponse>;
+    planApplication(input: ApiApplicationPlanRequest): Promise<ApiApplicationPlanResponse>;
+    listApplicationDrafts(projectId: string): Promise<ApiPage<ApplicationDraftRecord>>;
+    createApplicationDraft(input: ApiApplicationDraftCreateRequest): Promise<{
+        draft: ApplicationDraftRecord;
+        requestId: string;
+    }>;
+    updateApplicationDraft(input: ApiApplicationDraftUpdateRequest): Promise<{
+        draft: ApplicationDraftRecord;
+        requestId: string;
+    }>;
+    createApplication(input: ApiApplicationCreateRequest, idempotencyKey: string): Promise<ApiApplicationCreateResponse>;
+    uploadApplicationArtifact(projectId: string, filename: string, body: Blob | ArrayBuffer): Promise<{
+        artifact: ApplicationArtifactRecord;
+        requestId: string;
+    }>;
+    listRegistryConnections(): Promise<ApiPage<RegistryConnection>>;
+    createRegistryConnection(input: ApiRegistryConnectionCreateRequest): Promise<{
+        registry: RegistryConnection;
+        requestId: string;
+    }>;
+    updateRegistryConnection(input: ApiRegistryConnectionUpdateRequest): Promise<{
+        registry: RegistryConnection;
+        requestId: string;
+    }>;
+    disconnectRegistryConnection(id: string): Promise<{
+        registry: RegistryConnection;
+        requestId: string;
+    }>;
+    listQueue(input?: {
+        projectId?: string;
+        state?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<ApiPage<ApiQueueOperation>>;
+    operationLogs(operationId: string, input?: {
+        after?: number;
+        limit?: number;
+    }): Promise<ApiOperationLogsResponse>;
+    streamOperationLogs(operationId: string, after?: number): Promise<Response>;
+    cancelOperation(operationId: string): Promise<{
+        operation: ApiOperationResponse['operation'];
+        requestId: string;
+    }>;
+    retryOperation(operationId: string, errorClass: string, delayMs?: number): Promise<{
+        operation: ApiOperationResponse['operation'];
+        requestId: string;
+    }>;
+    queueSettings(): Promise<ApiQueueSettingsResponse>;
+    updateQueueSettings(concurrency: Partial<QueueConcurrencyLimits>): Promise<ApiQueueSettingsResponse>;
+    listPreviews(projectId?: string): Promise<ApiPage<PreviewInstance>>;
+    listPreviewDefinitions(projectId: string): Promise<ApiPage<PreviewDefinition>>;
+    createPreviewDefinition(input: CreatePreviewDefinitionInput): Promise<{
+        definition: PreviewDefinition;
+        requestId: string;
+    }>;
+    createPreview(input: {
+        definitionId: string;
+        repository?: string;
+        branch: string;
+        pullRequestNumber?: number;
+        fork?: boolean;
+        commitSha: string;
+    }): Promise<{
+        preview: PreviewInstance;
+        operation: ApiOperationResponse['operation'];
+        requestId: string;
+    }>;
+    destroyPreview(previewId: string, confirm: string): Promise<{
+        operation: ApiOperationResponse['operation'];
+        requestId: string;
+    }>;
+    extendPreview(previewId: string, hours: number): Promise<{
+        preview: PreviewInstance;
+        requestId: string;
+    }>;
+    rebuildPreview(previewId: string): Promise<{
+        operation: ApiOperationResponse['operation'];
+        requestId: string;
+    }>;
+}

package/dist/api/handler.d.ts

@@ -0,0 +1,18 @@
+import type { AutomationIdentityStore } from '../automation';
+import type { ControlPlaneStore } from '../control-plane';
+import type { ApplicationArtifactStore, ApplicationDraftStore, RegistryConnectionStore } from '../onboarding';
+import type { SourceConnectionStore } from '../source';
+interface ApiV1HandlerOptions {
+    controlPlane: ControlPlaneStore;
+    identities: AutomationIdentityStore;
+    sources?: SourceConnectionStore;
+    applications?: {
+        drafts: ApplicationDraftStore;
+        artifacts?: ApplicationArtifactStore;
+        registries: RegistryConnectionStore;
+    };
+    now?: () => Date;
+    rateLimit?: number;
+}
+export declare function createApiV1Handler(options: ApiV1HandlerOptions): (request: Request, networkHint?: string) => Promise<Response | undefined>;
+export {};

package/dist/api/handler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/index.d.ts

@@ -0,0 +1,6 @@
+export { TsCloudApiError, TsCloudClient } from './client';
+export type { TsCloudClientOptions } from './client';
+export { createApiV1Handler } from './handler';
+export { API_VERSION, openApiDocument } from './openapi';
+export { ApiServiceError, AutomationApiService, requestHash } from './service';
+export * from './types';

package/dist/api/openapi.d.ts

@@ -0,0 +1,2 @@
+export declare const API_VERSION = "1.6.0";
+export declare function openApiDocument(): Record<string, unknown>;

package/dist/api/service.d.ts

@@ -0,0 +1,28 @@
+import type { ApiTokenPrincipal, AutomationIdentityStore } from '../automation';
+import type { AuthorizationCapability, AuthorizationScope, AuthorizationTarget, ControlPlaneOperation, ControlPlaneStore } from '../control-plane';
+import type { ApiDeploymentRequest } from './types';
+export declare class ApiServiceError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, status: number, details?: Record<string, unknown> | undefined);
+}
+export declare function requestHash(method: string, pathname: string, body: unknown): string;
+export declare class AutomationApiService {
+    private readonly controlPlane;
+    private readonly identities;
+    private readonly queue;
+    constructor(controlPlane: ControlPlaneStore, identities: AutomationIdentityStore);
+    target(principal: ApiTokenPrincipal, requested: AuthorizationScope): AuthorizationTarget;
+    authorize(principal: ApiTokenPrincipal, capability: AuthorizationCapability, requested: AuthorizationScope): AuthorizationTarget;
+    listProjects(principal: ApiTokenPrincipal): Array<Record<string, unknown>>;
+    listEnvironments(principal: ApiTokenPrincipal, projectId: string): Array<Record<string, unknown>>;
+    listServices(principal: ApiTokenPrincipal, projectId: string, environmentId?: string): Array<Record<string, unknown>>;
+    listOperations(principal: ApiTokenPrincipal, projectId?: string): Array<Record<string, unknown>>;
+    listEvents(principal: ApiTokenPrincipal, projectId?: string, afterSequence?: number): Array<Record<string, unknown>>;
+    createDeployment(principal: ApiTokenPrincipal, input: ApiDeploymentRequest, idempotencyKey: string): {
+        operation: Record<string, unknown>;
+        replay: boolean;
+    };
+    operation(operation: ControlPlaneOperation): Record<string, unknown>;
+}