#!/usr/bin/env node
import { type ProviderCapability, type ProviderId, type TrustedServerSigningKeyset } from '@dharma-ai-labs/agent-fabric-contracts';
import { type TrajectoryCapsule } from '@dharma-ai-labs/agent-fabric-evidence-reduction';
import { type OrganizationPolicy } from '@dharma-ai-labs/agent-fabric-policy';
import { type ProviderSession } from '@dharma-ai-labs/agent-fabric-provider-adapters';
import { AgentFabricClient, type DeviceConfig, type SecureSecretStore } from '@dharma-ai-labs/agent-fabric-relay-client';
import { type SkillBundle } from '@dharma-ai-labs/agent-fabric-skill-manager';
import { type TaskEnvelope, type TaskReceipt } from '@dharma-ai-labs/agent-fabric-task-runner';
import { type RepositoryInstallerInput } from './repositoryInstallerFiles.js';
import { type CodexSetupFailureDiagnostic, type CodexSetupFailureObserver } from './codexSetupDiagnostic.js';
import { type BootstrapHostScope, type CodexBootstrapHostInput } from './bootstrapHostScope.js';
import { startCodexSetupNativeHost } from './codexSetupNativeHost.js';
export { startCodexSetupNativeHost } from './codexSetupNativeHost.js';
export { openCodexSetupVaultJournal } from './codexSetupVaultJournal.js';
export { createCodexSetupReadinessOwner } from './codexSetupReadiness.js';
import { type CodexSetupExecutionLease, type CodexSetupIntent } from './codexSetupAdmission.js';
import type { ScopedLocalVault } from '@dharma-ai-labs/agent-fabric-local-vault';
export { openCooperativeInboxSession, type CooperativeSessionContext } from './cooperativeInboxSession.js';
export type { CodexBootstrapHostInput } from './bootstrapHostScope.js';
type Output = unknown;
export declare function loadAgentFabricOnboardingContract(): Promise<{
    markdown: string;
    sha256: string;
}>;
interface WorkspaceRecord {
    workspaceId: string;
    organizationId: string;
    name: string;
    path: string;
    routeHash: string;
    repositoryRemoteHash: string | null;
    repositoryIdentityVersion?: 'normalized-v1' | 'legacy-v0';
    repositoryAgentId?: string | null;
    repositoryBindingId?: string | null;
    endpointId?: string | null;
    repositoryPackage?: {
        state: 'absent' | 'accepted' | 'processing' | 'published' | 'blocked';
        candidateId: string | null;
        operationId: string | null;
        snapshotHash: string | null;
        sourceManifestHash: string | null;
        releaseId: string | null;
        generation: number;
        consolidationMode: 'initial_repository' | 'repository_update' | null;
        sourcePolicyGenerationId?: string | null;
        localBaselineSnapshotHash?: string | null;
        publishedLocalSnapshotHash?: string | null;
        pendingLocalSnapshotHash?: string | null;
        pendingLocalOperationId?: string | null;
    };
    repositoryRole?: {
        revision: number;
        profileHash: string;
    } | null;
    repositoryAgentKey?: string | null;
    controlBranch?: string | null;
    defaultBranch: string | null;
    status: 'active';
    accessMode?: 'source' | 'knowledge_only';
}
export declare function parseCliOptions(args: string[]): {
    positional: string[];
    flags: Map<string, string | boolean>;
    repeated: Map<string, Array<string | boolean>>;
};
export declare function portalUrl(flags: Map<string, string | boolean>, fallback?: string): string;
export declare function commandExitCode(argv: string[], value: Output): number;
export declare function isDirectExecution(argvPath: string | undefined, moduleUrl: string): boolean;
export declare function loadOrCreateInstallationId(path?: string): Promise<string>;
export declare function pathExistsOrThrow(path: string, check?: (path: string) => Promise<unknown>): Promise<boolean>;
export declare function canonicalFilesystemPath(path: string): Promise<string>;
export declare function rawLocalRetentionDays(policy: Pick<OrganizationPolicy, 'retention'>): number;
export declare function syncPendingRetentionCapsules(vault: {
    listPendingCapsuleSyncs<T>(limit?: number, offset?: number): Promise<Array<{
        trajectoryId: string;
        revision: number;
        capsule: T;
    }>>;
    markCapsuleSynced(trajectoryId: string, revision: number): void | Promise<void>;
    discardPendingCapsuleSync(trajectoryId: string, revision: number, reason?: string): void | Promise<void>;
}, fabric: AgentFabricClient, policy: OrganizationPolicy, workspaceId: string): Promise<number>;
export declare function assertCapsuleIntegrity(capsule: Record<string, unknown>): void;
export declare function assertCapsuleAuthorizedByCurrentPolicy(capsule: Record<string, unknown>, policy: OrganizationPolicy): void;
export declare function reserveDailyContentUpload(capsule: Record<string, unknown>, policy: OrganizationPolicy, store?: SecureSecretStore): Promise<void>;
export declare function releaseDailyContentUpload(capsule: Record<string, unknown>, policy: OrganizationPolicy, _store?: SecureSecretStore): Promise<void>;
export declare function relayProcessState(home?: string): Promise<'running' | 'stopped' | 'unknown'>;
export declare function relaySupervisorProcessState(home?: string): Promise<'running' | 'stopped' | 'unknown'>;
export declare function acquireRelayProcessLease(home?: string): Promise<() => Promise<void>>;
export declare function acquireRelaySupervisorLease(home?: string): Promise<() => Promise<void>>;
export declare function materializeWorkspacePolicy(input: {
    workspace: string;
    organizationId: string;
    revision: string;
    serverPolicyAuthorization?: unknown;
    serverPublicKeyEd25519?: string;
    workspaceId?: string;
    dryRun?: boolean;
    secureStore?: SecureSecretStore;
}): Promise<{
    relativePath: string;
    policy: OrganizationPolicy;
    applied: boolean;
}>;
export declare function withRelayStartupMutation<T>(operation: () => Promise<T>, home?: string): Promise<T>;
export declare function withWorkspacePolicyRefreshLock<T>(workspaceId: string, operation: () => Promise<T>): Promise<T>;
export declare function withWorkspaceSkillActivationLock<T>(workspaceId: string, provider: ProviderId, operation: () => Promise<T>): Promise<T>;
export declare function applyServerEvidencePolicy(base: OrganizationPolicy, value: unknown, serverPublicKeyEd25519: string, organizationId: string, workspaceId: string, now?: Date): OrganizationPolicy;
export declare function normalizeGitRemoteIdentity(value: string): string;
export declare function sourceRepositoryFingerprint(remote: string | null, explicitKey?: string | null): {
    fingerprint: string;
    source: 'remote' | 'explicit_key';
};
export declare function preflightBootstrapWorkspaceIdentity(workspace: string, explicitKey?: string | null): Promise<ReturnType<typeof sourceRepositoryFingerprint>>;
export declare function responseTextFromEvent(value: unknown): string | null;
export declare function taskResponsePreview(receipt: TaskReceipt): {
    text: string;
    truncated: boolean;
    redactionClasses: string[];
    redactedValues: number;
} | null;
export declare function assertTaskSkillPin(pinned: TaskEnvelope['skillBundle'], active: {
    bundleId: string;
    bundleHash: string;
} | null): void;
export declare function taskSkillPinFailureCode(error: unknown): string;
type RelayProbeClient = Pick<AgentFabricClient, 'config' | 'openSession'>;
export declare function probeRelayConnection(openClient?: () => Promise<RelayProbeClient>): Promise<{
    ok: boolean;
    connected: boolean;
    organizationId: string;
    deviceId: string;
    relayVersion: string;
}>;
export declare function isTransientBootstrapError(error: unknown): boolean;
export declare function retryBootstrapOnboarding<T>(operation: () => Promise<T>, options?: {
    delaysMs?: readonly number[];
    wait?: (delayMs: number) => Promise<void>;
}): Promise<T>;
type BootstrapEvidenceSynchronization = {
    state: 'synchronized' | 'deferred' | 'denied_disclosure';
    captured: number | null;
    synced: number | null;
    reason?: 'policy_boundary' | 'capture_unavailable' | 'retention_not_ready';
    errorCode?: string;
};
export declare function publishedPackageCanDeferSecretEvidence(evidence: BootstrapEvidenceSynchronization, repositoryPackage: NonNullable<WorkspaceRecord['repositoryPackage']>, sourcePolicyGenerationId: string): boolean;
export declare function initialBootstrapEvidenceDisposition(discovered: number, disclosureReady: boolean): BootstrapEvidenceSynchronization;
export declare function synchronizeBootstrapEvidence(operation: () => Promise<{
    captured: number;
    synced: number;
}>): Promise<BootstrapEvidenceSynchronization>;
export declare function deferUnavailableRelayRetention<T>(operation: () => Promise<T>): Promise<{
    state: 'completed';
    value: T;
} | {
    state: 'deferred';
    reason: 'retention_not_ready';
}>;
export declare function requireCompletedBootstrapEvidence(result: BootstrapEvidenceSynchronization, discovered: number): void;
export declare function stableRepositoryLauncherContents(version?: string, runtime?: {
    platform: NodeJS.Platform;
    nodeDirectory: string;
    npmCliPath?: string;
    codexDirectory?: string;
}): {
    shell: string;
    windows: string;
};
export declare function waitForRelayReadiness(options?: {
    processState?: () => Promise<'running' | 'stopped' | 'unknown'>;
    probe?: () => Promise<Awaited<ReturnType<typeof probeRelayConnection>>>;
    attempts?: number;
    delayMs?: number;
    wait?: (delayMs: number) => Promise<void>;
    expectedVersion?: string;
}): Promise<{
    state: "running";
    probe: {
        ok: boolean;
        connected: boolean;
        organizationId: string;
        deviceId: string;
        relayVersion: string;
    };
}>;
export declare function providerHintFromEnvironment(env?: NodeJS.ProcessEnv): ProviderId | null;
export declare function providerHintFromProcessArgv(lineage: string[][]): ProviderId | null;
export declare function assertBootstrapResumeAuthority(input: {
    flags: Map<string, string | boolean>;
    existing: Pick<DeviceConfig, 'organizationId' | 'hqUrl'> | null;
    organizationId: string;
    hqUrl: string;
}): void;
/** Planning-only trusted host entry. Effectful admission remains unavailable
 * until the full continuation and native owner lifecycle are qualified. */
export declare function bootstrapFromCodexSetup(input: CodexBootstrapHostInput): Promise<Output>;
/** Native-owner continuation: no caller-selected flags or replacement authority. */
export declare function bootstrapFromCodexSetupScope(scope: BootstrapHostScope, observeFailure?: CodexSetupFailureObserver): Promise<Output>;
type CodexCompletionVault = Pick<ScopedLocalVault, 'recordCodexSetupReadiness' | 'getCodexSetupReadiness' | 'getProviderSessionBinding' | 'stageCodexSetupSession' | 'readCodexSetupSession'>;
/** Trusted native host composition, not an MCP/model/peer tool. */
export declare function createCodexBootstrapCompletionOwner(scope: BootstrapHostScope, vault: CodexCompletionVault, observeFailure?: CodexSetupFailureObserver): Promise<Readonly<{
    execute: (lease: Readonly<CodexSetupExecutionLease>) => Promise<{
        state: "completed";
        readinessReceiptId: string;
    } | {
        state: "unconfirmed";
        code: "setup_execution_unconfirmed";
    }>;
    verify: (receiptId: string, requested: Readonly<CodexSetupIntent>, intentDigest: string) => Promise<boolean>;
}>>;
/** Controller entry: owns the official connection and never accepts a peer transport. */
export declare function openCodexBootstrapNativeHost(input: Omit<Parameters<typeof startCodexBootstrapNativeHost>[0], 'transport' | 'additionalFilesystemRules'> & {
    expectedAccountEmail: string;
}): Promise<Readonly<{
    threadId: string;
    turnId: string;
    close: () => Promise<void>;
    settled: Promise<void>;
    readonly diagnostics: readonly Readonly<CodexSetupFailureDiagnostic>[];
}>>;
/** Prepared controller ingress for the portal's public command, never a shell evaluator. */
export declare function openCodexBootstrapFromPortalCommand(input: Parameters<typeof openCodexBootstrapNativeHost>[0] & {
    portalArgs: readonly string[];
}): Promise<Readonly<{
    threadId: string;
    turnId: string;
    close: () => Promise<void>;
    settled: Promise<void>;
    readonly diagnostics: readonly Readonly<CodexSetupFailureDiagnostic>[];
}>>;
/** Official native-host composition. The caller supplies its already owned
 * transport and qualification, never a vault, executor or readiness callback. */
export declare function startCodexBootstrapNativeHost(input: Omit<Parameters<typeof startCodexSetupNativeHost>[0], 'openJournal' | 'execute' | 'verifyReadiness'>): Promise<Readonly<{
    diagnostics: readonly Readonly<CodexSetupFailureDiagnostic>[];
    threadId: string;
    turnId: string;
    close: () => Promise<void>;
    settled: Promise<void>;
}>>;
export declare function summarizeBootstrapOrganizationApi(input: {
    organizationId: string;
    organization: unknown;
    agents: unknown;
    experiments: unknown;
    failures: unknown;
    remediations: unknown;
    skills: unknown;
    usage: unknown;
}): {
    ready: boolean;
    organizationId: string;
    counts: {
        agents: number | null;
        experiments: number | null;
        failures: number | null;
        remediations: number | null;
        skills: number | null;
        usage: number | null;
    };
};
export declare function requireExplicitConfirmation(flags: Map<string, string | boolean>, action: string): void;
export type ControlAgentCliClient = Pick<AgentFabricClient, 'listControlAgentSessions' | 'createControlAgentSession' | 'submitControlAgentMessage' | 'listControlAgentEvents'>;
type ControlAgentCliClientFactory = () => Promise<ControlAgentCliClient>;
export declare function controlAgentDecisionUrl(input: {
    portalOrigin: string;
    organizationId: string;
    toolCallId: string;
    decision: 'approve' | 'reject';
    sessionId?: string;
}): string;
export declare function runAssistantCommand(subcommand: string | undefined, flags: Map<string, string | boolean>, openClient?: ControlAgentCliClientFactory, openUrl?: (url: string) => Promise<boolean>): Promise<Record<string, unknown>>;
type AcceptedTrajectoryHead = {
    revision: number;
    capsuleHash: string;
} | null;
export declare function acceptedTrajectoryHead(value: unknown, trajectoryId: string): AcceptedTrajectoryHead;
export declare function parseSelectedProviderIds(values: Array<string | boolean>): ProviderId[] | null;
export declare function actionDecisionCapabilityFreshUntil(keyset: TrustedServerSigningKeyset, trustedKeyVersions: string[], now?: Date): string;
export declare function receiptAwareProviderCapabilities(providers: ProviderCapability[], now?: Date): Promise<ProviderCapability[]>;
export declare function repositorySharedReady(item: WorkspaceRecord, loadInstalled?: (workspace: WorkspaceRecord) => Promise<unknown>): Promise<boolean>;
export declare function canonicalRepositoryPackage(value: unknown): NonNullable<WorkspaceRecord['repositoryPackage']>;
export declare function canonicalRepositoryPackagePolicyGeneration(value: unknown): string | null | undefined;
export declare function repositoryPackageNeedsPolicyRefresh(repositoryPackage: NonNullable<WorkspaceRecord['repositoryPackage']>, activeGenerationId: string): boolean;
export declare function canonicalEndpointRole(value: unknown): WorkspaceRecord['repositoryRole'];
export declare function installRepositoryAgentFabricSkill(input: RepositoryInstallerInput): Promise<{
    skillPath: string;
    connectionPath: string;
    repositoryAgentPath: string;
    repositoryPackage: {
        manifestPath: string;
        snapshotPath: string;
        snapshotHash: string;
        managedCopiesPath: string | null;
        disposition: "candidate_only" | "local_bootstrap_inventory";
        authority: "local_inventory_not_signed";
    };
    knowledge: import("./repositoryKnowledge.js").RepositoryKnowledgeInitializationResult | {
        catalog: import("./repositoryKnowledge.js").RepositoryDeliveredKnowledgeCatalog;
        relativePath: string;
        disposition: "signed_release_reused";
    } | null;
}>;
export declare function repositorySourceResolutionCommand(flags: Map<string, string | boolean>): Promise<{
    ok: boolean;
    stage: string;
    dryRun: boolean;
    localMutation: boolean;
    serverMutation: boolean;
    protocolSessionCreated: boolean;
    serverSourceMutation: boolean;
    durableRelayStateMutation: boolean;
    authority: string;
    plan: import("./repositorySourceReconciliation.js").RepositorySourceResolutionPlan;
    planHash: string;
    resolvedSnapshotHash: string;
    published: boolean;
}>;
export declare function taskReceiptSession(task: TaskEnvelope, receipt: TaskReceipt, workspace: string): ProviderSession;
export declare function assertRecoveredTaskWorkspacePolicy(input: {
    recoveryWorkspaceId: string;
    workspace: {
        workspaceId: string;
        organizationId: string;
    };
    policy: Pick<OrganizationPolicy, 'organizationId' | 'serverAuthorization'>;
}): void;
export declare function recoveredTaskPolicyWasSuperseded(capsule: Pick<TrajectoryCapsule, 'redactionReceipt'>, currentPolicy: Pick<OrganizationPolicy, 'revision'>): boolean;
export declare function assertTaskWorkspacePolicy(input: {
    task: Pick<TaskEnvelope, 'organizationId' | 'workspaceId'>;
    workspace: {
        workspaceId: string;
        organizationId: string;
    };
    policy: Pick<OrganizationPolicy, 'organizationId' | 'serverAuthorization'>;
}): void;
export declare function acknowledgeTaskActionDecision(input: {
    task: Pick<TaskEnvelope, 'taskId' | 'actionDecision'>;
    receipt: Pick<TaskReceipt, 'actionAcknowledgement'>;
    postEnforcement: (decisionId: string, acknowledgement: NonNullable<TaskReceipt['actionAcknowledgement']>) => Promise<unknown>;
}): Promise<boolean>;
export declare function postTaskOutcome(input: {
    task: Pick<TaskEnvelope, 'taskId' | 'actionDecision'>;
    receipt: Pick<TaskReceipt, 'status' | 'actionAcknowledgement'>;
    payload: Record<string, unknown>;
    postEnforcement: (decisionId: string, acknowledgement: NonNullable<TaskReceipt['actionAcknowledgement']>) => Promise<unknown>;
    postEvent: (taskId: string, eventType: TaskReceipt['status'], payload: Record<string, unknown>) => Promise<unknown>;
}): Promise<unknown>;
export declare function nativeSkillDirectory(provider: ProviderId, env?: NodeJS.ProcessEnv, home?: string): string;
export declare function nativeSkillDirectoryForWorkspace(input: {
    provider: ProviderId;
    workspaceId: string;
    workspace?: string;
    env?: NodeJS.ProcessEnv;
    home?: string;
}): Promise<string>;
export declare function nativeSkillRootMatchingAuthorization(input: {
    roots: readonly string[];
    workspaceId: string;
    bundleId: string;
    receiptHash: string;
}): Promise<string | null>;
export declare function installClaudeReadOnlyProjectPermissions(workspaceInput: string): Promise<{
    path: string;
    addedRules: number;
    totalRules: number;
    scope: string;
}>;
type HermesSkillExecutor = (executable: string, argv: string[], options: {
    timeout: number;
    env: NodeJS.ProcessEnv;
    cwd: string;
}) => Promise<{
    stdout?: string | Buffer;
}>;
export declare function trustHermesProject(input: {
    workspace: string;
    env?: NodeJS.ProcessEnv;
    execute?: HermesSkillExecutor;
}): Promise<{
    workspace: string;
    trusted: boolean;
}>;
export declare function installNativeAgentFabricBootstrap(input: {
    provider: ProviderId;
    workspace: string;
    workspaceId: string;
    organizationId: string;
    hqUrl: string;
    env?: NodeJS.ProcessEnv;
    home?: string;
    executeHermes?: HermesSkillExecutor;
}): Promise<{
    provider: ProviderId;
    nativeSkillDirectory: string;
    skillPath: string;
    activation: string;
    verified: boolean;
    projectPermissions: {
        path: string;
        addedRules: number;
        totalRules: number;
        scope: string;
    } | null;
}>;
type NativeBootstrapCapability = {
    provider: string;
    skillInstall: string;
};
type NativeBootstrapInstaller = typeof installNativeAgentFabricBootstrap;
export declare function installAvailableNativeAgentFabricBootstraps(input: {
    providers: NativeBootstrapCapability[];
    workspace: string;
    workspaceId: string;
    organizationId: string;
    hqUrl: string;
    install?: NativeBootstrapInstaller;
}): Promise<{
    installed: {
        provider: ProviderId;
        nativeSkillDirectory: string;
        skillPath: string;
        activation: string;
        verified: boolean;
        projectPermissions: {
            path: string;
            addedRules: number;
            totalRules: number;
            scope: string;
        } | null;
    }[];
    failures: {
        provider: string;
        code: "native_skill_install_failed";
        message: string;
    }[];
}>;
export declare function verifyAgentFabricSkillInstallation(input: {
    provider: ProviderId;
    workspace: string;
    env?: NodeJS.ProcessEnv;
    home?: string;
    listAgyPlugins?: (executable: string, argv: string[], options: {
        timeout: number;
        env: NodeJS.ProcessEnv;
    }) => Promise<{
        stdout: string | Buffer;
    }>;
    listHermesSkills?: HermesSkillExecutor;
}): Promise<{
    provider: ProviderId;
    ready: boolean;
    verificationScope: string;
    bootstrapReady: boolean;
    signedLifecycleReady: boolean;
    repositoryInstalled: boolean;
    nativeInstalled: boolean;
    nativeManaged: boolean;
    nativeDiscovered: boolean;
    activationAttested: boolean;
    repositorySkillPath: string;
    connectionPath: string;
    nativeSkillPath: string;
    workspaceId: string | null;
    activeBundleId: string | null;
    activeBundleHash: string | null;
    signedMarkerBundleId: string | null;
    activation: string;
    nextAction: string;
}>;
export declare function attestHermesSkillBundleActivation(input: {
    bundle: SkillBundle;
    workspace: string;
    nativeSkillDirectory?: string;
    env?: NodeJS.ProcessEnv;
    execute?: HermesSkillExecutor;
}): Promise<{
    name: string;
    status: "unavailable";
    details: string;
} | {
    name: string;
    status: "fail";
    details: string;
} | {
    name: string;
    status: "pass";
    details: string;
}>;
type AgyPluginExecutor = (executable: string, argv: string[], options: {
    timeout: number;
    env: NodeJS.ProcessEnv;
}) => Promise<unknown>;
export declare function activateAgyPlugin(input?: {
    env?: NodeJS.ProcessEnv;
    home?: string;
    execute?: AgyPluginExecutor;
}): Promise<void>;
export declare function ensureAgyReadOnlyAttestationPermission(input?: {
    env?: NodeJS.ProcessEnv;
    home?: string;
}): Promise<{
    changed: boolean;
    settingsPath: string;
    permission: string;
}>;
type AgyAttestationExecutor = (executable: string, argv: string[], options: {
    timeout: number;
    env: NodeJS.ProcessEnv;
    cwd: string;
}) => Promise<{
    stdout: string | Buffer;
}>;
export declare function attestAgySkillActivation(input: {
    skillId: string;
    skillPath: string;
    workspace: string;
    challenge?: string;
    env?: NodeJS.ProcessEnv;
    execute?: AgyAttestationExecutor;
}): Promise<{
    name: string;
    status: "unavailable";
    details: string;
} | {
    name: string;
    status: "fail";
    details: string;
} | {
    name: string;
    status: "pass";
    details: string;
}>;
export declare function attestAgySkillBundleActivation(input: {
    bundle: SkillBundle;
    nativeSkillDirectory: string;
    workspace: string;
}): Promise<{
    name: string;
    status: "unavailable";
    details: string;
} | {
    name: string;
    status: "fail";
    details: string;
} | {
    name: string;
    status: "pass";
    details: string;
}>;
export declare function materializeInlineSkillFiles(bundle: SkillBundle, sourceRoot: string, assertCurrent?: () => void): Promise<boolean>;
export declare function validateSkillBundleSources(bundle: SkillBundle): {
    inlineRequired: boolean;
    singleSource: boolean;
};
export declare function recoverLegacySkillBundleIdAfterAuthorizationFailure(input: {
    nativeSkillDirectory: string;
    workspaceId: string;
    authorizationError: unknown;
}): Promise<string>;
export declare function installedBundleIdForSkillPollAfterAuthorizationFailure(input: {
    nativeSkillDirectory: string;
    workspaceId: string;
    authorizationError: unknown;
}): Promise<string>;
export declare function loadSkillSynchronizationPolicy(policyPath: string, workspaceId: string, secureStore?: SecureSecretStore): Promise<{
    workspace: WorkspaceRecord;
    policy: OrganizationPolicy;
    config: DeviceConfig;
    enrollment: import("@dharma-ai-labs/agent-fabric-relay-client").DeviceEnrollmentAnchor;
}>;
export declare function parseSkillRolloutResponse(response: unknown, organizationId: string): {
    id: string;
    bundle: unknown;
    repositoryPackage?: unknown;
} | null;
export declare function prepareSkillUpdate(input: {
    workspaceId: string;
    provider: ProviderId;
    policyPath: string;
    fabric?: AgentFabricClient;
    store?: SecureSecretStore;
    automatic?: boolean;
    assertRunning?: () => void;
}): Promise<{
    workspace: WorkspaceRecord;
    policy: OrganizationPolicy;
    config: DeviceConfig;
    destination: string;
    fabric: AgentFabricClient;
    rollout: {
        id: string;
        bundle: unknown;
        repositoryPackage?: unknown;
    };
    bundle: SkillBundle;
    sourceRoot: string;
    repositoryDelivery: {
        files: import("./repositoryPackageTransfer.js").RepositoryTransferFile[];
        bundle: SkillBundle;
        envelope: {
            [x: string]: unknown;
        };
        index: import("./repositoryPackageTransfer.js").RepositoryTransferIndexV2;
        assertCurrent: () => void;
    } | undefined;
    assertCurrent: () => void;
} | null>;
export declare function skillSync(flags: Map<string, string | boolean>, dryRunStore?: SecureSecretStore): Promise<Output>;
export declare function run(argv: string[]): Promise<Output>;
//# sourceMappingURL=index.d.ts.map