import type { AiAuthoringContextLockV2, AiAuthoringContextSnapshotV2, AiAuthoringContextVerificationV1, AiContextSigningKeySetV1, DescribeAiAuthoringContextRequestV2, SignAiAuthoringContextLockRequestV2, ValidateExecutablePackageArtifactInputV1, ValidateExecutablePackageArtifactResultV1, VerifyAiAuthoringContextFreshnessRequestV2, WorkforceBundleSourceLockV1 } from '@nexusclaw/shared';
export interface CreateExecutablePackageUploadSessionInput {
    readonly schemaVersion: 'nexusclaw.create-executable-package-upload-session-input/v1';
    readonly targetWorkspaceId: string;
    readonly archiveFormat: 'zip-store-v1';
    readonly archiveDigest: `sha256:${string}`;
    readonly packageDigest: `sha256:${string}`;
    readonly archiveSizeBytes: number;
    readonly fileCount: number;
    readonly declaredSurfaces: ReadonlyArray<'config' | 'code' | 'flow' | 'employee'>;
}
export interface ExecutablePackageUploadSession {
    readonly uploadSessionId: string;
    readonly expiresAt: string;
    readonly receivedBytes: number;
    readonly chunkSizeBytes: number;
}
export interface WorkforceBundleArtifactOperationInput {
    readonly schemaVersion: string;
    readonly targetWorkspaceId: string;
    readonly stagedArtifactId: string;
    readonly expectedArchiveDigest: `sha256:${string}`;
    readonly expectedPackageDigest: `sha256:${string}`;
    readonly contextManifestContentDigest: `sha256:${string}`;
    readonly runtimeBindingsDigest: `sha256:${string}`;
    readonly expectedPortableBundleDigest: `sha256:${string}`;
    readonly targetAgentId?: string | null;
}
export type WorkforceBundleLockResult = WorkforceBundleSourceLockV1;
export interface WorkforceBundlePlanResult {
    readonly schemaVersion: 'nexusclaw.executable-workforce-bundle-plan/v1';
    readonly planDigest: `sha256:${string}`;
    readonly releaseItemSetDigest: `sha256:${string}`;
    readonly sourceLockDigest: `sha256:${string}`;
    readonly plannedItems: ReadonlyArray<{
        readonly itemKind: string;
        readonly canonicalKey: string;
        readonly checksum: `sha256:${string}`;
        readonly descriptorHash: `sha256:${string}` | null;
    }>;
    readonly headAtPlan: {
        readonly activeReleaseSetId: string | null;
        readonly generation: number;
    };
    readonly lock: WorkforceBundleSourceLockV1;
}
export interface CandidateStageReceiptResult {
    readonly schemaVersion: 'nexusclaw.candidate-stage-receipt/v1';
    readonly candidateReleaseSetId: string;
    readonly agentApiName: string;
    readonly eligibilityStatus: 'staged';
    readonly sourceLockDigest: `sha256:${string}`;
    readonly releaseItemSetDigest: `sha256:${string}`;
    readonly materializedItemRefsDigest: `sha256:${string}`;
    readonly releaseEnvelopeDigest: null;
    readonly previousReleaseSetId: string | null;
    readonly headAtStage: {
        readonly activeReleaseSetId: string | null;
        readonly generation: number;
    };
    readonly planDigest: `sha256:${string}`;
}
export interface CandidateReplacementStageReceiptResult {
    readonly schemaVersion: 'nexusclaw.candidate-replacement-stage-receipt/v1';
    readonly auditId: string;
    readonly replacementForCandidateReleaseSetId: string;
    readonly candidateReleaseSetId: string;
    readonly agentApiName: string;
    readonly eligibilityStatus: 'staged';
    readonly packageDigest: `sha256:${string}`;
    readonly requestedPackageDigest: `sha256:${string}`;
    readonly sourceLockDigest: `sha256:${string}`;
    readonly releaseItemSetDigest: `sha256:${string}`;
    readonly materializedItemRefsDigest: `sha256:${string}`;
    readonly headAtStage: {
        readonly activeReleaseSetId: string | null;
        readonly generation: number;
    };
    readonly policyVersion: string;
    readonly reason: string;
    readonly createdAt: string;
    readonly replayed: boolean;
}
export type WorkforceCandidateSelector = {
    readonly kind: 'action';
    readonly exportId: string;
    readonly suites: readonly string[];
} | {
    readonly kind: 'flow';
    readonly flowApiName: string;
    readonly suites: readonly string[];
} | {
    readonly kind: 'employee';
    readonly suites: readonly string[];
};
export interface WorkforceCandidateReleaseItem {
    readonly itemKind: string;
    readonly selectorKey: string;
}
export interface CandidateTestRunResult {
    readonly evidenceRunId: string;
    readonly evidenceRunDigest: `sha256:${string}`;
    readonly status: 'PASSED' | 'FAILED' | 'ABORTED';
    readonly failureCode: string | null;
    readonly passed: boolean;
    readonly refs: ReadonlyArray<{
        readonly kind: string;
        readonly evidenceId: string;
        readonly digest: `sha256:${string}`;
        readonly producer: string;
        readonly createdAt: string;
    }>;
    readonly suiteResults: ReadonlyArray<Record<string, unknown>>;
    readonly isolationBindingId: string;
    readonly isolationSnapshotHash: `sha256:${string}`;
    readonly resetReceiptId: string;
    readonly resetReceiptDigest: `sha256:${string}`;
    readonly newAuthorizationGeneration: number | null;
    readonly observability: CandidateObservabilitySnapshot;
}
export interface CandidateObservabilitySnapshot {
    readonly schemaVersion: 'nexusclaw.candidate-observability/v1';
    readonly build: {
        readonly coreVersion: string;
        readonly coreCommitSha: string;
        readonly cliCompatibilityVersion: string;
    };
    readonly candidate: {
        readonly releaseSetId: string;
        readonly eligibilityStatus: string;
    };
    readonly lifecycle: {
        readonly status: 'NOT_RUN' | 'RUNNING' | 'PASSED' | 'FAILED' | 'ABORTED';
        readonly evidenceRunId: string | null;
        readonly evidenceRunDigest: `sha256:${string}` | null;
        readonly startedAt: string | null;
        readonly completedAt: string | null;
        readonly failureCode: string | null;
        readonly failureDetails: Readonly<Record<string, unknown>> | null;
    };
    readonly sandbox: {
        readonly status: 'NOT_RUN' | 'PASSED' | 'FAILED';
        readonly evidenceId: string | null;
        readonly evidenceDigest: `sha256:${string}` | null;
        readonly stages: Readonly<Record<'preflight' | 'workspaceProvisioned' | 'tenantStarted' | 'firstHostRpc' | 'assertionsExecuted' | 'cleanup', 'NOT_RUN' | 'PENDING' | 'PASSED' | 'FAILED'>>;
    };
    readonly capacity: {
        readonly totalSlots: number;
        readonly readySlots: number;
        readonly leasedSlots: number;
        readonly resettingSlots: number;
        readonly unavailableSlots: number;
    };
    readonly lease: {
        readonly status: 'NOT_ALLOCATED' | 'ACTIVE' | 'RELEASED' | 'REVOKED' | 'EXPIRED';
        readonly leaseId: string | null;
        readonly leaseDigest: `sha256:${string}` | null;
        readonly released: boolean;
        readonly terminalAt: string | null;
        readonly expiresAt: string | null;
    };
    readonly cleanup: {
        readonly status: 'NOT_RUN' | 'PASSED' | 'FAILED' | 'PENDING';
        readonly resetReceiptId: string | null;
        readonly resetReceiptDigest: `sha256:${string}` | null;
        readonly completedAt: string | null;
        readonly deletedMutableCounts: Readonly<Record<string, number>>;
        readonly deletedMutableTotal: number;
        readonly failureCode: string | null;
    };
    readonly isolation: {
        readonly sourceWorkspaceId: string;
        readonly executionWorkspaceId: string | null;
        readonly workspaceIsolated: boolean | null;
        readonly productionMutationCount: number | null;
        readonly passed: boolean | null;
        readonly bindingId: string | null;
        readonly bindingSnapshotHash: `sha256:${string}` | null;
    };
    readonly runtime: {
        readonly providerId: string;
        readonly runtimeApi: string;
        readonly worker: string;
        readonly executionOwner: string;
        readonly readiness: Readonly<Record<string, unknown>>;
    };
    readonly suites: ReadonlyArray<Readonly<Record<string, unknown>>>;
    readonly evidence: ReadonlyArray<{
        readonly kind: string;
        readonly evidenceId: string;
        readonly digest: `sha256:${string}`;
        readonly producer: string;
        readonly createdAt: string;
    }>;
    readonly diagnostics: ReadonlyArray<{
        readonly code: string;
        readonly severity: 'info' | 'warning' | 'error';
        readonly retryable: boolean;
        readonly details?: Readonly<{
            [key: string]: unknown;
            dimension: string;
            callOrdinal: number;
            expectedOrdinal: number | null;
            expectedRequestDigest: string | null;
            actualRequestDigest: string | null;
            firstDivergingJsonPointer: string | null;
            unconsumedTailCount: number | null;
        }>;
    }>;
}
export interface WorkforceReleaseGateReceipt {
    readonly schemaVersion: string;
    readonly approvalId: string;
    readonly candidateReleaseSetId: string;
    readonly evidenceRunIds: readonly string[];
    readonly expectedSourceLockDigest: `sha256:${string}`;
    readonly expectedReleaseItemSetDigest: `sha256:${string}`;
    readonly expectedMaterializedItemRefsDigest: `sha256:${string}`;
    readonly governanceContextDigest: `sha256:${string}`;
    readonly decision: string;
    readonly decisionVersion: number;
    readonly expiresAt: string;
    readonly consumedAt: string | null;
    readonly receiptDigest: `sha256:${string}`;
}
export interface WorkforceReleaseTransitionResult {
    readonly schemaVersion: string;
    readonly operation: 'promote' | 'rollback';
    readonly beforeReleaseSetId: string | null;
    readonly afterReleaseSetId: string | null;
    readonly beforeGeneration: number;
    readonly afterGeneration: number;
    readonly receiptId: string;
    readonly outboxId: string;
    readonly alreadyApplied: boolean;
    readonly activationKind?: 'initial_promote' | 'rollback_repromote';
    readonly reusedAuthorization?: boolean;
    readonly priorPromotionReceiptId?: string | null;
    readonly rollbackReceiptId?: string | null;
    readonly approvalId?: string | null;
    readonly releaseEnvelopeDigest?: `sha256:${string}` | null;
}
export interface SealedExecutablePackageArtifact {
    readonly stagedArtifactId: string;
    readonly status: 'sealed';
    readonly archiveDigest: `sha256:${string}`;
    readonly packageDigest: `sha256:${string}`;
    readonly expiresAt: string;
    readonly receivedBytes: number;
    readonly nextOffset: number;
}
export interface ApiResponse<T = unknown> {
    success: boolean;
    data?: T;
    error?: string;
    errors?: string[];
}
export interface DeployResult {
    jobId: string;
    status: string;
    message?: string;
}
export interface DeployStatus {
    jobId: string;
    status: 'pending' | 'running' | 'success' | 'failed';
    progress?: number;
    message?: string;
    errors?: string[];
}
export interface ValidateResult {
    success: boolean;
    errors: string[];
    warnings: string[];
}
export interface ValidationReportIssue {
    code: string;
    severity: 'critical' | 'high' | 'medium' | 'low';
    category: string;
    message: string;
    recommendation?: string;
    path?: string;
    line?: number;
    column?: number;
    componentId?: string;
    componentName?: string;
    componentType?: string;
}
export interface ValidationReport {
    schemaVersion: 'deployment-validation-report/v1';
    operation: string;
    success: boolean;
    generatedAt: string;
    workspaceId?: string;
    targetEnvironment?: string;
    errors: ValidationReportIssue[];
    warnings: ValidationReportIssue[];
    suggestions: string[];
    affectedComponents: Array<Record<string, unknown>>;
    compatibility?: Record<string, unknown>;
    summary: {
        errorCount: number;
        warningCount: number;
        suggestionCount: number;
        affectedComponentCount: number;
    };
    metadata?: Record<string, unknown>;
}
export interface ManagedChangeSet {
    id: string;
    workspaceId: string;
    name: string;
    description?: string;
    sourceEnvironment: string;
    targetEnvironment: string;
    status: string;
    approvalRequired?: boolean;
    approvalStatus?: string;
    validationMessage?: string;
    createdBy?: string;
    createdAt: string;
    updatedAt: string;
    validatedAt?: string;
    deployedAt?: string;
    rolledBackAt?: string;
    metadata?: Record<string, unknown> | null;
    components?: Array<Record<string, unknown>>;
}
export interface RetrieveResult {
    downloadUrl: string;
    filename: string;
    size: number;
}
export interface RuntimeSourceFile {
    path: string;
    content: string;
}
export interface RuntimeRenderedFile extends RuntimeSourceFile {
    hash: string;
}
export interface RuntimeValidationResult {
    validation: {
        valid: boolean;
        summary: string[];
    };
}
export interface RuntimePlanResult extends RuntimeValidationResult {
    dryRun?: boolean;
    destructiveSync?: boolean;
    diff: {
        humanSummary: string[];
        summary: {
            objects: {
                created: number;
                updated: number;
                deleted: number;
            };
            fields: {
                created: number;
                updated: number;
                deleted: number;
            };
        };
    };
}
export interface RuntimeApplyResult {
    applied: boolean;
    dryRun: boolean;
    destructiveSync: boolean;
    beforeRevision?: string;
    afterRevision?: string;
    plan: RuntimePlanResult;
}
export interface RuntimeExportResult {
    snapshot: unknown;
    files: RuntimeRenderedFile[];
}
export interface MetadataPackageDependency {
    name: string;
    versionRange: string;
    optional?: boolean;
}
export interface MetadataKindSupportEntry {
    kind: string;
    executionMode: string;
    notes?: string;
}
export interface CodeKindSupportEntry {
    kind: 'function' | 'trigger' | 'library' | 'test' | 'ui-component';
    executionMode: 'sandboxed-runtime' | 'binding-only' | 'build-input' | 'workspace-only';
    notes?: string;
}
export interface MetadataPackageManifest {
    schemaVersion: 'v1';
    name: string;
    packageType: string;
    packageClass: 'metadata' | 'seed-data' | 'asset' | 'code-extension';
    description: string;
    version: string;
    dependencies: MetadataPackageDependency[];
    compatibleCoreVersion: string;
    installOrder: number;
    includedMetadataKinds: string[];
    includedSeedKinds: string[];
    includedCodeKinds?: Array<'function' | 'trigger' | 'library' | 'test' | 'ui-component'>;
    visibility: string;
    releaseChannel: string;
    kindSupport: MetadataKindSupportEntry[];
    codeKindSupport?: CodeKindSupportEntry[];
    runtimeProviderRequirement?: 'hardened-isolate' | 'nexusclaw-verified-isolate-v1';
    codeExtensionGovernance?: {
        contractVersion: 'code-extension-governance/v1';
        runtimeApiVersion: string;
    } | {
        contractVersion: 'code-extension-governance/v2';
        runtimeApiVersion: 'runtime/v2';
    };
    agentToolCatalogPath?: string;
    trialEvidence?: {
        extensionRuntimeLogPath: string;
        dependencyReportPath: string;
        failedExtensionEvidencePath: string;
        debugAttributionPath?: string;
        rollbackEvidencePath?: string;
        trackedExtensions?: Array<{
            packageName: string;
            extensionId: string;
            kind: 'function' | 'trigger';
        }>;
    };
    executableArtifacts?: Array<{
        extensionId?: string;
        apiName: string;
        kind: 'function' | 'trigger';
        sourcePath: string;
        dependsOn?: string[];
        functionType?: 'ACTION';
        entrypoint?: 'default';
        actionContractVersion?: 'nexus-code-action/v1';
        runtimeApiVersion?: 'runtime/v2';
    }>;
}
export interface ExtensionGovernanceCheckedExtension {
    extensionId: string;
    kind: 'function' | 'trigger';
    apiName: string;
    sourcePath: string;
    dependsOn: string[];
    errors: string[];
    warnings: string[];
}
export interface ExtensionGovernanceValidationResult {
    schemaVersion: 'code-extension-governance-validation/v1';
    status: 'passed' | 'warning' | 'failed';
    packageName: string;
    packageVersion: string;
    contractVersion: string | null;
    runtimeApiVersion: string | null;
    checkedExtensions: ExtensionGovernanceCheckedExtension[];
    errors: string[];
    warnings: string[];
    artifactRefs: string[];
    evidenceRefs: string[];
    comparedUpgradeFields: string[];
    attributionSummary: Array<'extension' | 'runtime' | 'dependency' | 'config'>;
}
export interface MetadataPackageInstallPlanResult {
    packageNames: string[];
    orderedSteps: Array<{
        phase: string;
        packageName: string;
        executionTrack?: string;
        rollbackHint?: string;
    }>;
    warnings: string[];
    summary?: string[];
    dependencies?: {
        missingDependencies: string[];
        circularDependencies?: string[];
        versionConflicts?: string[];
        coreVersionConflicts?: string[];
        conflictSummary?: string[];
    };
}
export interface MetadataPackageInstallResult {
    packageName: string;
    status: string;
    appliedMetadataKinds: string[];
    appliedSeedKinds: string[];
    warnings: string[];
    executionTrack?: string;
    installedStateId?: string;
    details?: Record<string, unknown>;
}
export interface EmployeePackageInstallResult {
    status: 'queued' | 'installed' | 'updated' | 'rejected';
    jobId?: string;
    agentId?: string;
    agentStatus?: 'draft' | 'active' | 'archived';
    activated: boolean;
    guardrails: {
        upserted: number;
    };
    knowledge: {
        upserted: number;
        embedded: number;
        skippedEmbeddings: number;
    };
    evalCases: {
        upserted: number;
        ran: number;
        skippedMutating: number;
    };
    gate: {
        passRate: number | null;
        minPassRate: number;
        baselinePassRate: number | null;
        regressed: boolean;
        passed: boolean;
        suiteRunId?: string;
        casesRun: number;
        failures: Array<{
            testCaseId: string;
            name: string;
            failureReason?: string;
        }>;
    } | null;
    errors: string[];
    deploymentReportId?: string;
    gateReportId?: string;
    auditId?: string;
}
export interface CoreHealthStatus {
    status: 'ok' | 'error';
    build: {
        coreVersion: string;
        coreCommitSha: string;
        cliCompatibilityVersion: string;
    };
}
export interface RuntimeDemoPreflightReport {
    id: string;
    workspaceId: string;
    actor?: string | null;
    overallStatus: 'REHEARSAL_READY' | 'REHEARSAL_BLOCKED';
    coreVersion?: string | null;
    cliVersion?: string | null;
    frontendImageSha?: string | null;
    mobileImageSha?: string | null;
    backendImageSha?: string | null;
    cliImageSha?: string | null;
    metadataInstallIds: string[];
    businessDataInstallIds: string[];
    deploymentReportId?: string | null;
    gateReportId?: string | null;
    auditId?: string | null;
    agentId?: string | null;
    checks: Array<{
        code: string;
        status: 'passed' | 'failed' | 'missing';
        evidence?: Record<string, unknown> | null;
        reason?: string | null;
    }>;
    blockers: string[];
    createdAt: string;
}
export interface EmployeeDeploymentReportRecord {
    id: string;
    jobId?: string | null;
    workspaceId: string;
    agentId: string;
    gateReportId?: string | null;
    auditId?: string | null;
    packageName: string;
    packageVersion: string;
    status: 'queued' | 'running' | 'installed' | 'updated' | 'rejected' | 'failed';
    activationStatus: 'draft' | 'active' | 'archived';
    activated: boolean;
    gatePassed: boolean;
    gateFailureReason?: string | null;
    coreVersion?: string | null;
    cliVersion?: string | null;
    errors: string[];
    createdAt: string;
    updatedAt: string;
}
export interface DeploymentJobRecord {
    id: string;
    workspaceId: string;
    phase: 'queued' | 'validating' | 'deploying' | 'verifying' | 'succeeded' | 'failed' | 'cancelled' | 'deployed_with_warnings';
    progressPercent: number;
    successCount: number;
    failureCount: number;
    totalComponents: number;
    metadata?: Record<string, unknown>;
}
export interface EmployeeGateReportRecord {
    id: string;
    deploymentReportId?: string | null;
    suiteRunId?: string | null;
    passRate: number | null;
    minPassRate: number;
    baselinePassRate: number | null;
    regressed: boolean;
    passed: boolean;
    casesRun: number;
    failures: Array<{
        testCaseId: string;
        name: string;
        failureReason?: string;
    }>;
}
export interface InstallationContractRecord {
    installationId: string;
    workspaceId: string;
    packageName?: string;
    version?: string;
    contractName?: string;
    contractVersion?: string;
    compatibleCoreSha: string | null;
    auditId?: string | null;
    sourceUri?: string | null;
    installedAt?: string | null;
    createdAt?: string;
    summary?: Record<string, unknown> | null;
}
export interface MetadataPackageUpgradeResult {
    packageName: string;
    status: string;
    warnings: string[];
    destructiveChanges?: string[];
    installResult?: MetadataPackageInstallResult;
}
export interface MetadataPackageRollbackResult {
    packageName: string;
    status: string;
    warnings: string[];
    restoredStateId?: string;
    snapshotTimestamp?: string;
    restoredVersion?: string | null;
    details?: Record<string, unknown>;
}
export interface MetadataPackageUninstallResult {
    packageName: string;
    status: string;
    warnings: string[];
    blockedBy?: string[];
}
export interface InstalledMetadataPackageRecord {
    id: string;
    workspaceId: string;
    packageName: string;
    version: string;
    packageDigest?: string | null;
    installSource: string;
    status: string;
    installedAt: string;
    updatedAt: string;
    manifest: MetadataPackageManifest;
    ownedCodeArtifacts?: Array<Record<string, unknown>> | null;
    runtimeProviderRequirement?: string | null;
}
export interface MetadataPackageInstallHistoryRecord {
    id: string;
    workspaceId: string;
    packageName: string;
    version: string;
    action: string;
    status: string;
    installSource: string;
    sourceUri?: string | null;
    manifest: MetadataPackageManifest;
    details?: Record<string, unknown> | null;
    sourceStateId?: string | null;
    targetStateId?: string | null;
    rollbackDetails?: Record<string, unknown> | null;
    createdAt: string;
}
export interface PromotionRecord {
    id: string;
    packageName: string;
    version: string;
    sourceChannel: string;
    targetChannel: string;
    promotedBy: string;
    promotedAt: string;
    approvalStatus: 'pending' | 'approved' | 'rejected';
    approvedBy?: string | null;
    approvedAt?: string | null;
    rejectionReason?: string | null;
    metadata?: Record<string, unknown> | null;
}
export interface RolloutStatusResult {
    packageName: string;
    version: string;
    channel: string;
    percentage: number;
    includedWorkspaceCount: number;
    totalEligibleWorkspaces: number;
    includedWorkspaceIds: string[];
    rollout: Record<string, unknown>;
}
export interface ChannelEntitlementRecord {
    id: string;
    workspaceId: string;
    channel: string;
    grantedBy: string;
    grantedAt: string;
    revokedBy?: string | null;
    revokedAt?: string | null;
    status: 'active' | 'revoked';
    metadata?: Record<string, unknown> | null;
}
export interface ChannelPolicyResult {
    path: string;
    policy: Record<string, unknown>;
}
export interface CodeEnvironmentPromotionPackageInput {
    manifest: MetadataPackageManifest;
    packageDirectory?: string;
    archivePath?: string;
    serializerChangeSetId?: string;
    sourceUri?: string;
}
export interface CodeEnvironmentPromotionPlanResult {
    valid: boolean;
    targetWorkspaceId: string;
    sourceEnvironment?: string | null;
    runtimePolicyRef?: string | null;
    runtimeProviderId: string;
    allowPartialFailure: boolean;
    warnings: string[];
    errors: string[];
    packages: Array<{
        packageName: string;
        version: string;
        packageClass?: string;
        action: 'install' | 'upgrade' | 'noop';
        valid: boolean;
        warnings: string[];
        errors: string[];
        executionTrack?: string;
        installedVersion?: string | null;
        runtimeProviderRequirement?: string | null;
    }>;
    drift: {
        missingPackages: string[];
        versionMismatches: string[];
        extraCodePackages: string[];
    };
}
export interface CodeEnvironmentPromotionResult {
    success: boolean;
    targetWorkspaceId: string;
    sourceEnvironment?: string | null;
    runtimePolicyRef?: string | null;
    warnings: string[];
    errors: string[];
    precheck: CodeEnvironmentPromotionPlanResult;
    appliedPackages: Array<{
        packageName: string;
        version: string;
        action: 'install' | 'upgrade' | 'noop';
        status: string;
        warnings: string[];
        executionTrack?: string;
        installedStateId?: string;
        deploymentHistoryId?: string | null;
    }>;
    rollbackResults: Array<{
        packageName: string;
        status: string;
        warnings: string[];
        details?: Record<string, unknown>;
    }>;
}
export interface SourceMemberRecord {
    id: string;
    componentType: string;
    componentId: string;
    componentName: string;
    changeType: string;
    changeSource: string;
    changedAt: string;
}
export interface SourceStatusFileRecord {
    path: string;
    hash: string;
    componentKey?: string;
    baselineHash?: string | null;
    track?: 'metadata-runtime' | 'code-extension' | 'employee-source';
    semanticHash?: string;
    aggregateDigest?: string;
    releaseSetId?: string;
}
export interface SourceDriftResult {
    baselineAvailable: boolean;
    baselineSource?: string | null;
    diff?: Record<string, unknown> | null;
    totalChanges: number;
    humanSummary: string[];
}
export interface SourceStatusResult {
    remoteRevision: string;
    remoteHash?: string;
    baselineRevision?: string | null;
    baselineHash?: string | null;
    baselineSource?: string | null;
    baselineAvailable: boolean;
    files: SourceStatusFileRecord[];
    baselineFiles: SourceStatusFileRecord[];
    drift: SourceDriftResult;
    changedComponentCount: number;
    tracking?: Record<string, unknown> | null;
}
export interface SourceFilesResult {
    remoteRevision: string;
    files: Array<SourceStatusFileRecord & {
        content: string;
    }>;
}
export interface PushSourceFileInput {
    path: string;
    content?: string | null;
    deleted?: boolean;
}
export interface PushSourceResult {
    success: boolean;
    count: number;
    dryRun: boolean;
    beforeRevision?: string;
    afterRevision?: string;
    plan?: {
        humanSummary: string[];
        summary: Record<string, unknown>;
    };
}
export interface SourceBaselineRebuildResult {
    success: boolean;
    baselineAvailable: boolean;
    baselineRevision?: string | null;
    baselineSource?: string | null;
    filesCount: number;
    warnings: string[];
}
export interface RuntimeComposerPackageRef {
    packageName: string;
    version?: string;
    packageType: string;
    source?: 'local' | 'registry' | 'workspace';
}
export interface RuntimeComposerInput {
    tenantId: string;
    baseline: RuntimeComposerPackageRef;
    genericOverlay?: RuntimeComposerPackageRef | null;
    industryOverlay?: RuntimeComposerPackageRef | null;
    extensionPacks: RuntimeComposerPackageRef[];
    demoPack?: RuntimeComposerPackageRef | null;
    environmentProfile?: RuntimeComposerPackageRef | null;
}
export interface RuntimeComposerPreviewResult {
    plan: {
        tenantId: string;
        orderedPackages: RuntimeComposerPackageRef[];
        warnings: string[];
    };
    effective: {
        warnings: string[];
        destructiveSummary: string[];
        diff: {
            humanSummary: string[];
            changes: Array<Record<string, unknown>>;
        };
        validation: {
            valid: boolean;
            summary: string[];
        };
    };
    fromCache: boolean;
    materializedSnapshotId?: string;
}
export interface DeploymentRollbackResult {
    id: string;
    result?: string;
    errorMessage?: string | null;
}
export interface PromoteSandboxInput {
    sandboxId: string;
    promoteFrontend: boolean;
    promoteBackend: boolean;
    reason: string;
}
export interface SandboxPromotionPrecheckResult {
    canPromote: boolean;
    warnings: string[];
    errors: string[];
    frontendDiff: {
        from: string;
        to: string;
        changes: string[];
    };
    backendDiff: {
        from: string;
        to: string;
        changes: string[];
    };
}
export type MfaFactorType = 'totp' | 'webauthn' | 'recovery_code' | 'backup_email';
export interface MfaFactorView {
    id: string;
    userId: string;
    type: MfaFactorType;
    label: string;
    isVerified: boolean;
    isPrimary: boolean;
    createdAt?: string;
    lastUsedAt?: string | null;
    recoveryCodesRemaining?: number | null;
}
export interface GraphQLApiErrorDetail {
    message: string;
    code?: string;
    path?: ReadonlyArray<string | number> | string;
    ruleId?: string;
    retryable?: boolean;
    details?: Readonly<Record<string, unknown>>;
    challengeId?: string;
    stepUpAction?: string;
}
export declare class GraphQLApiError extends Error {
    readonly errors: ReadonlyArray<GraphQLApiErrorDetail>;
    constructor(errors: ReadonlyArray<GraphQLApiErrorDetail>);
}
export declare function extractStepUpRequirement(error: unknown): {
    challengeId: string;
    action: string;
} | null;
export declare function resolveEmployeeDeployRequestTimeoutMs(input: {
    dryRun?: boolean;
    currentTimeoutMs: number;
    environment?: NodeJS.ProcessEnv;
}): number;
export declare function normalizeEmployeeDeployTimeoutError(error: unknown, input: {
    dryRun?: boolean;
    timeoutMs: number;
}): unknown;
export declare class ApiClient {
    private baseUrl;
    private token?;
    private orgAlias?;
    private requestTimeoutMs;
    private readonly tokenRefreshDisabled;
    private tokenRefreshInFlight?;
    constructor(baseUrl?: string, token?: string, orgAlias?: string, requestTimeoutMs?: number);
    ensureValidToken(): Promise<void>;
    getCoreHealth(): Promise<CoreHealthStatus>;
    private refreshOAuthTokenPair;
    private getHeaders;
    private request;
    private putRawBytes;
    uploadContentDocument(input: {
        filename: string;
        bytes: Uint8Array;
        idempotencyKey: string;
    }): Promise<{
        documentId: string;
        currentVersionId?: string;
        scanStatus?: string;
    }>;
    isContentDocumentReady(documentId: string): Promise<boolean>;
    get<T>(endpoint: string): Promise<ApiResponse<T>>;
    post<T>(endpoint: string, body?: unknown): Promise<ApiResponse<T>>;
    postSse(endpoint: string, body: unknown): Promise<Array<{
        event: string;
        data: unknown;
    }>>;
    put<T>(endpoint: string, body?: unknown): Promise<ApiResponse<T>>;
    delete<T>(endpoint: string): Promise<ApiResponse<T>>;
    graphql<T>(query: string, variables?: Record<string, unknown>): Promise<T>;
    graphqlWithStepUp<T>(query: string, variables: Record<string, unknown>, stepUpToken: string): Promise<T>;
    getCurrentUser(): Promise<{
        id: string;
        username?: string;
        email?: string;
    }>;
    listMfaFactors(): Promise<MfaFactorView[]>;
    stepUpVerify(input: {
        challengeId: string;
        factorId: string;
        factorType: MfaFactorType;
        credential: unknown;
    }): Promise<{
        challengeId: string;
        stepUpToken: string;
        expiresAt: Date;
    }>;
    getAiContextSigningKeys(): Promise<AiContextSigningKeySetV1>;
    createExecutablePackageUploadSession(input: CreateExecutablePackageUploadSessionInput, idempotencyKey: string): Promise<ExecutablePackageUploadSession>;
    uploadExecutablePackageArtifact(input: {
        readonly targetWorkspaceId: string;
        readonly uploadSessionId: string;
        readonly bytes: Uint8Array;
        readonly archiveDigest: `sha256:${string}`;
        readonly packageDigest: `sha256:${string}`;
        readonly idempotencyKey: string;
        readonly receivedBytes?: number;
        readonly chunkSizeBytes?: number;
    }): Promise<SealedExecutablePackageArtifact>;
    resolveWorkforceBundleLock(input: WorkforceBundleArtifactOperationInput): Promise<WorkforceBundleLockResult>;
    planExecutableWorkforceBundle(input: WorkforceBundleArtifactOperationInput & {
        readonly expectedActiveReleaseSetId: string;
        readonly expectedGeneration: number;
    }): Promise<WorkforceBundlePlanResult>;
    stageExecutableWorkforceBundle(input: WorkforceBundleArtifactOperationInput & {
        readonly expectedActiveReleaseSetId: string;
        readonly expectedGeneration: number;
        readonly planDigest: `sha256:${string}`;
        readonly authoringContext: VerifyAiAuthoringContextFreshnessRequestV2;
    }, idempotencyKey: string): Promise<CandidateStageReceiptResult>;
    replacementStageWorkforceCandidate(input: {
        readonly schemaVersion: 'nexusclaw.replacement-stage-workforce-candidate-input/v1';
        readonly targetWorkspaceId: string;
        readonly sourceCandidateReleaseSetId: string;
        readonly expectedSourceLockDigest: `sha256:${string}`;
        readonly expectedReleaseItemSetDigest: `sha256:${string}`;
        readonly expectedMaterializedItemRefsDigest: `sha256:${string}`;
        readonly expectedPackageDigest: `sha256:${string}`;
        readonly expectedActiveReleaseSetId: string;
        readonly expectedGeneration: number;
        readonly reason: string;
    }, idempotencyKey: string): Promise<CandidateReplacementStageReceiptResult>;
    workforceCandidateReplacementStatus(input: {
        readonly targetWorkspaceId: string;
        readonly sourceCandidateReleaseSetId: string;
    }): Promise<CandidateReplacementStageReceiptResult | null>;
    runWorkforceCandidateTests(input: {
        readonly targetWorkspaceId: string;
        readonly candidateReleaseSetId: string;
        readonly selectors: readonly WorkforceCandidateSelector[];
        readonly expectedSourceLockDigest: `sha256:${string}`;
        readonly expectedReleaseItemSetDigest: `sha256:${string}`;
        readonly expectedMaterializedItemRefsDigest: `sha256:${string}`;
    }, idempotencyKey: string): Promise<CandidateTestRunResult>;
    getWorkforceCandidateStatus(input: {
        readonly targetWorkspaceId: string;
        readonly candidateReleaseSetId: string;
        readonly evidenceRunId?: string;
    }): Promise<CandidateObservabilitySnapshot>;
    getWorkforceCandidateDiagnostics(input: {
        readonly targetWorkspaceId: string;
        readonly candidateReleaseSetId: string;
        readonly evidenceRunId?: string;
    }): Promise<CandidateObservabilitySnapshot>;
    cancelWorkforceCandidateTestRun(input: {
        readonly targetWorkspaceId: string;
        readonly evidenceRunId: string;
    }, idempotencyKey: string): Promise<{
        evidenceRunId: string;
        status: string;
        failureCode: string | null;
        completedAt: string | null;
        alreadyTerminal: boolean;
        capacityReleased: boolean;
    }>;
    getWorkforceCandidateReleaseItems(input: {
        readonly targetWorkspaceId: string;
        readonly candidateReleaseSetId: string;
    }): Promise<readonly WorkforceCandidateReleaseItem[]>;
    requestWorkforceReleaseApproval(input: {
        readonly targetWorkspaceId: string;
        readonly candidateReleaseSetId: string;
        readonly evidenceRunIds: readonly string[];
        readonly expectedSourceLockDigest: `sha256:${string}`;
        readonly expectedReleaseItemSetDigest: `sha256:${string}`;
        readonly expectedMaterializedItemRefsDigest: `sha256:${string}`;
    }, idempotencyKey: string): Promise<WorkforceReleaseGateReceipt>;
    getWorkforceReleaseApprovalStatus(input: {
        readonly targetWorkspaceId: string;
        readonly candidateReleaseSetId: string;
        readonly approvalId: string;
    }): Promise<WorkforceReleaseGateReceipt>;
    evaluateAndSealWorkforceCandidateRelease(input: {
        readonly targetWorkspaceId: string;
        readonly candidateReleaseSetId: string;
        readonly evidenceRunIds: readonly string[];
        readonly expectedSourceLockDigest: `sha256:${string}`;
        readonly expectedReleaseItemSetDigest: `sha256:${string}`;
        readonly expectedMaterializedItemRefsDigest: `sha256:${string}`;
        readonly approvalId: string;
    }, idempotencyKey: string): Promise<{
        releaseSetId: string;
        evidenceId: string;
        eligibilityStatus: 'eligible' | 'rejected';
        releaseEnvelopeDigest: `sha256:${string}`;
        alreadySealed: boolean;
    }>;
    promoteWorkforceRelease(input: Record<string, unknown>, idempotencyKey: string): Promise<WorkforceReleaseTransitionResult>;
    rollbackWorkforceRelease(input: Record<string, unknown>, idempotencyKey: string): Promise<WorkforceReleaseTransitionResult>;
    revokeExecutableToolExport(input: Record<string, unknown>, idempotencyKey: string): Promise<Record<string, unknown>>;
    private workforceGateReceiptMutation;
    private workforceTransitionMutation;
    validateExecutablePackageArtifact(input: ValidateExecutablePackageArtifactInputV1): Promise<ValidateExecutablePackageArtifactResultV1>;
    describeAiAuthoringContext(input: DescribeAiAuthoringContextRequestV2): Promise<AiAuthoringContextSnapshotV2>;
    verifyAiAuthoringContextFreshness(input: VerifyAiAuthoringContextFreshnessRequestV2): Promise<AiAuthoringContextVerificationV1>;
    signAiAuthoringContextLock(input: SignAiAuthoringContextLockRequestV2): Promise<AiAuthoringContextLockV2>;
    validate(changeSetId: string): Promise<ValidateResult>;
    validateDeploymentSource(input: {
        files: RuntimeSourceFile[];
        targetEnvironment?: string;
        format?: 'json' | 'markdown';
    }): Promise<{
        report: ValidationReport;
        rendered: string;
    }>;
    validateDeploymentPackage(input: {
        manifest: MetadataPackageManifest;
        operation: 'install' | 'upgrade';
        workspaceId?: string;
        targetEnvironment?: string;
        format?: 'json' | 'markdown';
    }): Promise<{
        report: ValidationReport;
        rendered: string;
    }>;
    createManagedChangeSet(input: Record<string, unknown>): Promise<ManagedChangeSet>;
    listManagedChangeSets(filters?: Record<string, unknown>): Promise<ManagedChangeSet[]>;
    getManagedChangeSet(id: string): Promise<ManagedChangeSet>;
    validateManagedChangeSet(id: string): Promise<{
        changeSet: ManagedChangeSet;
        report: ValidationReport;
    }>;
    deployManagedChangeSet(id: string): Promise<Record<string, unknown>>;
    rollbackManagedChangeSet(id: string): Promise<Record<string, unknown>>;
    getManagedChangeSetDependencies(id: string): Promise<Record<string, unknown>>;
    getManagedChangeSetConflicts(id: string): Promise<Record<string, unknown>>;
    approveManagedChangeSet(id: string, reason?: string): Promise<ManagedChangeSet>;
    rejectManagedChangeSet(id: string, reason?: string): Promise<ManagedChangeSet>;
    listDeploymentHistory(filters?: Record<string, unknown>): Promise<{
        records: Record<string, unknown>[];
        rendered: string;
    }>;
    compareDeployments(leftId: string, rightId: string): Promise<Record<string, unknown>>;
    deploy(changeSetId: string): Promise<DeployResult>;
    getDeployStatus(jobId: string): Promise<DeployStatus>;
    retrieve(changeSetId: string): Promise<RetrieveResult>;
    exportRuntimeMetadata(): Promise<RuntimeExportResult>;
    validateRuntimeMetadata(files: RuntimeSourceFile[]): Promise<RuntimeValidationResult>;
    diffRuntimeMetadata(files: RuntimeSourceFile[]): Promise<RuntimePlanResult>;
    getSourceStatus(): Promise<SourceStatusResult>;
    getRemoteChanges(workspaceId?: string): Promise<SourceMemberRecord[]>;
    getLocalChanges(workspaceId?: string): Promise<SourceMemberRecord[]>;
    getSourceFiles(input?: {
        paths?: string[];
        recordAccess?: boolean;
    }): Promise<SourceFilesResult>;
    pushSource(input: {
        files: PushSourceFileInput[];
        dryRun?: boolean;
    }): Promise<PushSourceResult>;
    rebuildSourceBaseline(reason?: string): Promise<SourceBaselineRebuildResult>;
    importRuntimeMetadata(files: RuntimeSourceFile[], options?: {
        dryRun?: boolean;
        destructiveSync?: boolean;
    }): Promise<RuntimeApplyResult>;
    getMetadataPackageInstallPlan(input: {
        workspaceId: string;
        manifests: MetadataPackageManifest[];
        dryRun?: boolean;
        packageDirectory?: string;
        coreVersion?: string;
    }): Promise<MetadataPackageInstallPlanResult>;
    installMetadataPackage(input: {
        workspaceId: string;
        manifest: MetadataPackageManifest;
        dryRun?: boolean;
        packageDirectory?: string;
        archivePath?: string;
        serializerChangeSetId?: string;
        sourceUri?: string;
        coreVersion?: string;
    }): Promise<MetadataPackageInstallResult>;
    deployEmployeePackage(input: {
        workspaceId: string;
        manifest: Record<string, unknown>;
        dryRun?: boolean;
        allowMutatingEvals?: boolean;
        skipEmbeddings?: boolean;
        forceAdopt?: boolean;
    }): Promise<EmployeePackageInstallResult>;
    getEmployeeDeploymentReport(input: {
        workspaceId: string;
        deploymentReportId: string;
    }): Promise<EmployeeDeploymentReportRecord | null>;
    listEmployeeDeploymentReports(workspaceId: string): Promise<EmployeeDeploymentReportRecord[]>;
    getDeploymentJob(id: string): Promise<DeploymentJobRecord>;
    getEmployeeGateReport(input: {
        workspaceId: string;
        gateReportId: string;
    }): Promise<EmployeeGateReportRecord | null>;
    resumeEmployeePackageDeployment(id: string): Promise<DeploymentJobRecord>;
    runRuntimeDemoPreflight(input: {
        workspaceId: string;
        expectedCoreSha?: string | null;
        imageEvidence?: {
            backendImageSha?: string | null;
            frontendImageSha?: string | null;
            mobileImageSha?: string | null;
            cliImageSha?: string | null;
        } | null;
    }): Promise<RuntimeDemoPreflightReport>;
    getRuntimeDemoPreflightReport(input: {
        workspaceId: string;
        preflightReportId: string;
    }): Promise<RuntimeDemoPreflightReport | null>;
    registerMetadataInstall(input: {
        workspaceId: string;
        packageName: string;
        version: string;
        installedStateId: string;
        compatibleCoreSha: string;
        auditId?: string | null;
        sourceUri?: string | null;
    }): Promise<InstallationContractRecord>;
    registerBusinessDataInstall(input: {
        workspaceId: string;
        contractName: string;
        contractVersion: string;
        compatibleCoreSha: string;
        sourceUri?: string | null;
        auditId?: string | null;
        summary?: Record<string, unknown> | null;
    }): Promise<InstallationContractRecord>;
    listMetadataInstallations(workspaceId: string): Promise<InstallationContractRecord[]>;
    listBusinessDataInstallations(workspaceId: string): Promise<InstallationContractRecord[]>;
    upgradeMetadataPackage(input: {
        workspaceId: string;
        manifest: MetadataPackageManifest;
        allowDestructiveChanges?: boolean;
        packageDirectory?: string;
        archivePath?: string;
        serializerChangeSetId?: string;
        coreVersion?: string;
    }): Promise<MetadataPackageUpgradeResult>;
    uninstallMetadataPackage(input: {
        workspaceId: string;
        packageName: string;
        force?: boolean;
        purgeMetadata?: boolean;
    }): Promise<MetadataPackageUninstallResult>;
    rollbackMetadataPackageInstall(input: {
        workspaceId: string;
        manifest: MetadataPackageManifest;
        deploymentHistoryId?: string;
        targetStateId?: string;
        cascade?: boolean;
        dryRun?: boolean;
    }): Promise<MetadataPackageRollbackResult>;
    runtimeComposerPreview(input: {
        input: RuntimeComposerInput;
        registryRootDirectories?: string[];
    }): Promise<RuntimeComposerPreviewResult>;
    rollbackDeployment(input: {
        historyId: string;
        componentIds?: string[];
    }): Promise<DeploymentRollbackResult>;
    promoteSandbox(input: PromoteSandboxInput): Promise<boolean>;
    getSandboxPromotionPrecheck(input: {
        sandboxId: string;
    }): Promise<SandboxPromotionPrecheckResult>;
    codeEnvironmentPromotionPlan(input: {
        targetWorkspaceId: string;
        sourceEnvironment?: string | null;
        runtimePolicyRef?: string | null;
        allowPartialFailure?: boolean;
        packages: CodeEnvironmentPromotionPackageInput[];
    }): Promise<CodeEnvironmentPromotionPlanResult>;
    promoteCodeEnvironment(input: {
        targetWorkspaceId: string;
        sourceEnvironment?: string | null;
        runtimePolicyRef?: string | null;
        allowPartialFailure?: boolean;
        reason?: string | null;
        packages: CodeEnvironmentPromotionPackageInput[];
    }): Promise<CodeEnvironmentPromotionResult>;
    listInstalledMetadataPackages(input: {
        workspaceId: string;
        includeUninstalled?: boolean;
    }): Promise<InstalledMetadataPackageRecord[]>;
    listMetadataPackageInstallHistory(input: {
        workspaceId: string;
        packageName?: string;
    }): Promise<MetadataPackageInstallHistoryRecord[]>;
    verifyMetadataPackageSnapshots(input: {
        workspaceId: string;
        packageName: string;
    }): Promise<{
        workspaceId: string;
        packageName: string;
        verification: Array<{
            snapshotId: string;
            valid: boolean;
            status: string;
        }>;
    }>;
    promotePackage(input: {
        packageName: string;
        version: string;
        sourceChannel: string;
        targetChannel: string;
        rootDirectory?: string;
    }): Promise<PromotionRecord>;
    getPromotionHistory(input: {
        packageName?: string;
        version?: string;
        channel?: string;
        status?: string;
    }): Promise<PromotionRecord[]>;
    getPromotion(id: string): Promise<PromotionRecord>;
    getRolloutStatus(input: {
        packageName: string;
        version: string;
        channel: string;
    }): Promise<RolloutStatusResult | null>;
    updateRolloutPercentage(input: {
        packageName: string;
        version: string;
        channel: string;
        percentage: number;
    }): Promise<Record<string, unknown>>;
    getRolloutWorkspaces(input: {
        packageName: string;
        version: string;
        channel: string;
        limit?: number;
    }): Promise<Array<{
        workspaceId: string;
        included: boolean;
    }>>;
    deprecatePackageVersion(input: {
        packageName: string;
        version: string;
        channel: string;
        reason: string;
        replacementVersion?: string;
        gracePeriodDays?: number;
    }): Promise<Record<string, unknown>>;
    getChannelPolicy(): Promise<ChannelPolicyResult>;
    grantChannelAccess(input: {
        workspaceId: string;
        channel: string;
        reason?: string;
        expiresAt?: string;
    }): Promise<ChannelEntitlementRecord>;
    revokeChannelAccess(input: {
        entitlementId: string;
        reason?: string;
    }): Promise<ChannelEntitlementRecord>;
    listChannelEntitlements(input: {
        workspaceId: string;
        status?: 'active' | 'revoked' | 'all';
    }): Promise<ChannelEntitlementRecord[]>;
}
export declare class ApiClientConfigurationError extends Error {
    readonly code: 'CLI_TARGET_UNCONFIGURED' | 'CLI_TOKEN_WITHOUT_BASE_URL' | 'CLI_CREDENTIAL_NOT_FOUND';
    constructor(code: 'CLI_TARGET_UNCONFIGURED' | 'CLI_TOKEN_WITHOUT_BASE_URL' | 'CLI_CREDENTIAL_NOT_FOUND', message: string);
}
export declare function createApiClient(targetOrg?: string, requestTimeoutMs?: number): ApiClient;