import 'reflect-metadata';
import { type DynamicModule, type FactoryProvider, type ModuleMetadata, type OnApplicationBootstrap, type OnModuleDestroy } from '@nestjs/common';
import { DiscoveryService, MetadataScanner } from '@nestjs/core';
import { type XemaResolvedCapabilityInvocation } from './capability-invocation';
import { RouteClassification } from './route-classification';
import type { XemaRequiredResourceRoleBinding, XemaWireRequiredResourceRoleBinding } from './capability-required-binding';
import type { XemaCapabilityAuthorityEffect, XemaCapabilityHumanBaseline, XemaCapabilityMetadata, XemaCapabilityOutputClassification, XemaCapabilityBaselineOrgRole, XemaCapabilityReach } from './capability.decorator';
import type { SpaceFromSpec } from './space-from';
export declare enum ServiceKind {
    PlatformService = "platform-service",
    BiomeApi = "biome-api",
    Cli = "cli"
}
export declare enum DiscoveryMode {
    Decorators = "decorators",
    Manual = "manual"
}
export declare enum PolicyMode {
    FailClosed = "fail-closed",
    FailOpen = "fail-open"
}
export interface XemaRuntimeServiceOptions {
    serviceName: string;
    serviceKind: ServiceKind;
    discovery?: DiscoveryMode;
    policy?: PolicyMode;
    manifestOutputDir?: string;
    registerCapabilities?: boolean;
    capabilityRegistryClient?: XemaCapabilityRegistryClient;
}
export interface XemaCapabilityRegistryClient {
    post(path: string, body: unknown): Promise<unknown>;
}
export interface GeneratedRouteEntry {
    controller: string;
    methodName: string;
    classification: RouteClassification;
    resource?: string;
    action?: string;
    operationId?: string;
    spaceFrom?: SpaceFromSpec;
    extras?: Record<string, unknown>;
}
export interface GeneratedCapabilityEntry {
    providerClass: string;
    methodName: string;
    ref: string;
    resource: string;
    action: string;
    version: string;
    spaceFrom?: SpaceFromSpec;
    title?: string;
    summary?: string;
    sideEffects?: string;
    inputSchema?: Record<string, unknown>;
    outputSchema?: Record<string, unknown>;
    riskTier?: 'low' | 'medium' | 'high' | 'critical';
    authorityEffect?: XemaCapabilityAuthorityEffect;
    outputClassification?: XemaCapabilityOutputClassification;
    reach?: XemaCapabilityReach;
    requiresApproval?: boolean;
    safeForAgents?: boolean;
    defaultBaselineOrgRole?: XemaCapabilityBaselineOrgRole;
    humanBaseline?: XemaCapabilityHumanBaseline;
    examples?: readonly Record<string, unknown>[];
    requiredBindings?: readonly XemaRequiredResourceRoleBinding[];
    invocation?: XemaResolvedCapabilityInvocation;
}
export interface CapabilitySyncPayload {
    ref: string;
    version: string;
    title: string;
    summary: string;
    sideEffects: string;
    riskTier: 'low' | 'medium' | 'high' | 'critical';
    authorityEffect?: XemaCapabilityAuthorityEffect;
    outputClassification?: XemaCapabilityOutputClassification;
    reach?: XemaCapabilityReach;
    requiresApproval: boolean;
    safeForAgents?: boolean;
    defaultBaselineOrgRole?: XemaCapabilityBaselineOrgRole;
    humanBaseline?: XemaCapabilityHumanBaseline;
    inputSchema: Record<string, unknown>;
    outputSchema: Record<string, unknown>;
    examples: readonly Record<string, unknown>[];
    requiredBindings?: readonly XemaWireRequiredResourceRoleBinding[];
    invocation: XemaResolvedCapabilityInvocation;
}
export type CapabilitySyncFieldDisposition = {
    readonly forwarded: true;
} | {
    readonly forwarded: false;
    readonly reason: string;
};
export declare const CAPABILITY_SYNC_DISPOSITION: Readonly<Record<keyof XemaCapabilityMetadata, CapabilitySyncFieldDisposition>>;
export interface GeneratedServiceManifest {
    serviceName: string;
    serviceKind: ServiceKind;
    discovery: DiscoveryMode;
    policy: PolicyMode;
    generatedAt: string;
}
export declare class XemaRuntimeScanner implements OnApplicationBootstrap, OnModuleDestroy {
    private readonly options;
    private readonly discovery;
    private readonly metadataScanner;
    private readonly logger;
    private readonly capabilityRegistrationState;
    private capabilityRetryTimer;
    private resolveCapabilityRetryWait;
    private authoredCapabilityRefs;
    getAuthoredCapabilityRefs(): ReadonlySet<string>;
    onModuleDestroy(): void;
    constructor(options: Required<Omit<XemaRuntimeServiceOptions, 'manifestOutputDir' | 'capabilityRegistryClient'>> & {
        manifestOutputDir: string;
        capabilityRegistryClient: XemaCapabilityRegistryClient | undefined;
    }, discovery: DiscoveryService, metadataScanner: MetadataScanner);
    onApplicationBootstrap(): void;
    private scheduleCapabilityRegistration;
    private isCapabilityRegistrationCancelled;
    private autoRegisterCapabilities;
    private buildCapabilitySyncPayloads;
    private assertOperationIdsUnique;
    private scanCapabilities;
    private emitManifests;
}
export interface XemaRuntimeServiceAsyncOptions {
    serviceName: string;
    serviceKind: ServiceKind;
    discovery?: DiscoveryMode;
    policy?: PolicyMode;
    manifestOutputDir?: string;
    registerCapabilities?: boolean;
    useCapabilityRegistryClient?: (...args: never[]) => XemaCapabilityRegistryClient | Promise<XemaCapabilityRegistryClient>;
    inject?: FactoryProvider['inject'];
    imports?: ModuleMetadata['imports'];
}
export declare class XemaRuntimeModule {
    static forService(opts: XemaRuntimeServiceOptions): DynamicModule;
    static forServiceAsync(opts: XemaRuntimeServiceAsyncOptions): DynamicModule;
}
//# sourceMappingURL=xema-runtime-module.d.ts.map