import { SignatureProvider } from '@happyvertical/signatures';
import { AssetRuntimeLike } from '@happyvertical/smrt-assets';
import { AgreementExecutionCollection } from '../collections/AgreementExecutionCollection.js';
import { AgreementExecutionEventCollection } from '../collections/AgreementExecutionEventCollection.js';
import { ExecutedAgreementCollection } from '../collections/ExecutedAgreementCollection.js';
import { AgreementExecutionResult, AgreementWebhookIngestionResult, CreateAgreementExecutionInput, IngestAgreementWebhookInput } from '../types.js';
export interface AgreementExecutionServiceDeps {
    provider: SignatureProvider;
    assets: AssetRuntimeLike;
    executions: AgreementExecutionCollection;
    events: AgreementExecutionEventCollection;
    executedAgreements: ExecutedAgreementCollection;
    now?: () => Date;
    createLeaseDurationMs?: number;
}
export interface AdoptAgreementProviderRequestInput {
    tenantId: string;
    executionId: string;
    providerRequestId: string;
    signal?: AbortSignal;
}
export interface AgreementExecutionOperationInput {
    tenantId: string;
    executionId: string;
    signal?: AbortSignal;
}
export interface CancelAgreementExecutionInput extends AgreementExecutionOperationInput {
    reason: string;
}
export interface ExtendAgreementExecutionInput extends AgreementExecutionOperationInput {
    expiresAt: Date | string;
    warnPrior?: boolean;
}
export declare class AgreementExecutionService {
    private readonly deps;
    private readonly now;
    private readonly createLeaseDurationMs;
    constructor(deps: AgreementExecutionServiceDeps);
    createExecution(input: CreateAgreementExecutionInput): Promise<AgreementExecutionResult>;
    private sendProviderRequest;
    private resumeOrReplayCreate;
    /**
     * Bind an operator-reconciled provider request after an uncertain create.
     * This is the safe recovery path for providers without atomic idempotency.
     */
    adoptProviderRequest(input: AdoptAgreementProviderRequestInput): Promise<AgreementExecutionResult>;
    reconcile(input: AgreementExecutionOperationInput): Promise<AgreementExecutionResult>;
    cancel(input: CancelAgreementExecutionInput): Promise<AgreementExecutionResult>;
    extendExpiry(input: ExtendAgreementExecutionInput): Promise<AgreementExecutionResult>;
    ingestWebhook(input: IngestAgreementWebhookInput): Promise<AgreementWebhookIngestionResult>;
    private finalizeExecution;
    private ensureEvidenceArtifact;
    private retrieveAndStoreArtifact;
    private getStoredArtifactMetadata;
    private requireStoredArtifactMetadata;
    private removeStoredAsset;
    private ensureExecutedAgreementAssociations;
    private applyProviderState;
    private persistLifecycleState;
    private assertProviderRequest;
    private assertArtifact;
    private assertProviderCapabilities;
    private assertSameIntent;
    private assertCreateInput;
    private requireExecution;
    private requireProviderRequestId;
    private assertProviderRequestAvailable;
    private bindProviderRequest;
    private canSafelyRetryCreate;
    private isAbandonedCreate;
    private isCreateLeaseActive;
    private newCreateLeaseExpiry;
    private failOwnedCreateAttempt;
    private ensureAssetAssociation;
    private beginAuditedOperation;
    private completeAuditedOperation;
    private failAuditedOperation;
    private recordOperationAudit;
    private assertNonTerminalOperation;
    private result;
    private assertTenant;
    private assertTenantValue;
}
export default AgreementExecutionService;
//# sourceMappingURL=AgreementExecutionService.d.ts.map