/** Canonical FeltDB application contract. Rust validation and hashing are authoritative. */
export interface ManifestField {
    name: string;
    type: string;
    required?: boolean;
    nullable?: boolean;
    default?: unknown;
    enum_values?: string[];
    reference?: string;
    computed?: string;
}
export interface ManifestCollection {
    name: string;
    fields: ManifestField[];
}
export interface ApplicationManifest {
    application_id: string;
    tenant_id: string;
    schema: number;
    state_schema_version?: number;
    metadata: {
        name: string;
        description?: string;
        labels?: Record<string, string>;
    };
    collections: ManifestCollection[];
    indexes: {
        name: string;
        collection: string;
        fields: string[];
        unique?: boolean;
        sparse?: boolean;
        version?: number;
    }[];
    references: {
        name: string;
        from_collection: string;
        from_field: string;
        to_collection: string;
        to_field: string;
    }[];
    queries: {
        name: string;
        collection: string;
        filter?: unknown;
        fields?: string[];
    }[];
    actions: {
        name: string;
        operation: 'create' | 'update' | 'delete';
        collection: string;
        input_fields?: string[];
        required_capabilities?: string[];
        audit?: boolean;
    }[];
    workflows: {
        name: string;
        steps: {
            name: string;
            capability?: string;
        }[];
    }[];
    triggers: {
        name: string;
        event: string;
        workflow: string;
    }[];
    schedules: {
        name: string;
        expression: string;
        workflow: string;
    }[];
    agents: {
        name: string;
        capabilities: string[];
    }[];
    capabilities: {
        name: string;
        provider?: string;
        visibility?: 'public' | 'agent' | 'workflow' | 'internal';
    }[];
    modules?: import('./module.js').FeltDBModuleDefinition[];
    connections: {
        name: string;
        connection_id: string;
        configuration?: unknown;
        secrets?: {
            binding: string;
            secret_id: string;
        }[];
    }[];
    policies: {
        name: string;
        resource: string;
        read?: string;
        write?: string;
        capabilities: string[];
    }[];
    ui: {
        routes: {
            path: string;
            view: string;
        }[];
        bindings: {
            name: string;
            collection?: string;
            query?: string;
            fields?: string[];
        }[];
        forms: {
            name: string;
            collection: string;
            fields: string[];
        }[];
        dashboards: {
            name: string;
            bindings: string[];
        }[];
    };
    environments: {
        name: string;
        configuration?: Record<string, string>;
    }[];
    artifacts: {
        name: string;
        uri: string;
        media_type: string;
        content?: string;
    }[];
    deployment: {
        environments: string[];
        placement?: string;
    };
    runtime: {
        contract: number;
        minimum_engine: string;
        maximum_engine_exclusive?: string;
    };
}
export interface ApplicationDraft {
    draft_id: string;
    application_id: string;
    tenant_id: string;
    base_revision_id?: string;
    manifest: ApplicationManifest;
    version: number;
    updated_at: number;
    updated_by: string;
}
export interface ApplicationRevision {
    revision_id: string;
    application_id: string;
    tenant_id: string;
    revision_number: number;
    parent_revision_id?: string;
    manifest_hash: string;
    manifest: ApplicationManifest;
    created_by: string;
    created_at: number;
    status: 'committed';
}
export interface ApplicationProposal {
    proposal_id?: string;
    base_revision_id?: string;
    manifest: ApplicationManifest;
    rationale?: string;
    proposed_by: string;
}
export type ManifestCompatibility = 'compatible' | 'requires_migration' | 'breaking' | 'invalid';
export interface ManifestValidation {
    valid: boolean;
    compatibility: ManifestCompatibility;
    issues: {
        category: string;
        path: string;
        message: string;
    }[];
}
export type ChangeSafety = 'SAFE' | 'ADDITIVE' | 'MODIFIED' | 'REQUIRES_MIGRATION' | 'BREAKING' | 'SECURITY_SENSITIVE' | 'RUNTIME_SENSITIVE';
export interface ManifestDiff {
    application_id: string;
    from_revision?: string;
    to_revision: string;
    classification: 'UNCHANGED' | 'ADDITIVE' | 'MODIFIED' | 'MIGRATION_REQUIRED' | 'BREAKING' | 'SECURITY_SENSITIVE' | 'RUNTIME_SENSITIVE';
    compatibility: ManifestCompatibility;
    changes: {
        section: string;
        name: string;
        kind: 'added' | 'removed' | 'modified';
        safety: ChangeSafety;
        detail?: string;
    }[];
    migrations: {
        section: string;
        resource: string;
        operation: string;
        destructive: boolean;
    }[];
    security_changes: {
        section: string;
        resource: string;
        description: string;
    }[];
    migration_plan: {
        from_revision?: string;
        to_revision: string;
        operations: unknown[];
        destructive_operations: unknown[];
        reversible: boolean;
    };
    diff_hash: string;
}
export interface RuntimeReadiness {
    revision_id: string;
    environment: string;
    status: 'READY' | 'READY_WITH_WARNINGS' | 'BLOCKED';
    checks: {
        name: string;
        passed: boolean;
        blocking: boolean;
        message: string;
    }[];
}
export interface RevisionPromotion {
    application_id: string;
    from_revision?: string;
    to_revision: string;
    environment: string;
    promoted_by: string;
    promoted_at: number;
    reason: string;
    diff_hash: string;
    correlation_id: string;
    rollback: boolean;
}
export interface ApplicationRuntimeContract {
    application_id: string;
    tenant_id: string;
    revision_id: string;
    revision_number: number;
    metadata: ApplicationManifest['metadata'];
    state: unknown;
    queries: {
        definitions: ApplicationManifest['queries'];
        live_bindings: boolean;
    };
    actions: {
        definitions: ApplicationManifest['actions'];
    };
    workflows: unknown;
    triggers: unknown;
    schedules: unknown;
    agents: unknown;
    capabilities: unknown;
    connections: unknown;
    policies: unknown;
    ui: unknown;
    artifacts: unknown;
    environment: {
        name: string;
        configuration: Record<string, string>;
        state_namespace: string;
        isolated: boolean;
    };
    compatibility: {
        manifest_version: number;
        runtime_contract_version: number;
        engine_version: string;
        minimum_engine: string;
        maximum_engine_exclusive?: string;
    };
}
export declare class ApplicationManifestClient {
    private readonly baseUrl;
    private readonly token;
    constructor(baseUrl?: string, token?: string);
    private request;
    createDraft(applicationId: string, baseRevisionId?: string): Promise<ApplicationDraft>;
    getDraft(applicationId: string, draftId: string): Promise<ApplicationDraft>;
    updateDraft(applicationId: string, draft: ApplicationDraft, manifest: ApplicationManifest): Promise<ApplicationDraft>;
    validateDraft(applicationId: string, draftId: string): Promise<ManifestValidation>;
    commitDraft(applicationId: string, draftId: string): Promise<ApplicationRevision>;
    revisions(applicationId: string): Promise<{
        revisions: ApplicationRevision[];
        environment_pointers: Record<string, string>;
    }>;
    diff(applicationId: string, revision: number | string, from?: number | string): Promise<ManifestDiff>;
    preview(applicationId: string, revision: number | string, policy?: unknown): Promise<unknown>;
    environments(applicationId: string): Promise<{
        environments: Record<string, string>;
    }>;
    readiness(applicationId: string, environment: string, revision?: number | string): Promise<RuntimeReadiness>;
    promoteEnvironment(applicationId: string, environment: string, revision: string, expectedCurrentRevision?: string, reason?: string, approveDestructiveChanges?: boolean): Promise<{
        promotion: RevisionPromotion;
        readiness: RuntimeReadiness;
    }>;
    rollback(applicationId: string, environment: string, targetRevision: string, expectedCurrentRevision: string, reason?: string): Promise<{
        promotion: RevisionPromotion;
        readiness: RuntimeReadiness;
    }>;
    history(applicationId: string, environment: string): Promise<{
        history: RevisionPromotion[];
    }>;
    promote(applicationId: string, revision: number | string, environment: string, reason?: string, expectedCurrentRevision?: string, approveDestructiveChanges?: boolean): Promise<unknown>;
    runtime(applicationId: string, revision: number | string, environment?: string): Promise<ApplicationRuntimeContract>;
    run(applicationId: string, revision: number | string, environment?: string): Promise<unknown>;
    stop(applicationId: string, revision: number | string, environment?: string): Promise<unknown>;
    executeAction(applicationId: string, revision: number | string, action: string, input: unknown, environment?: string): Promise<unknown>;
    executeQuery(applicationId: string, revision: number | string, query: string, environment?: string): Promise<unknown>;
}
//# sourceMappingURL=application-manifest.d.ts.map