import type { CredentialRef } from "../agent_modelAdapter/authProfileLayer/credentialRef.js";
import type { ProviderReasoningConfig } from "../agent_modelAdapter/providerAccessLayer/providerCarrier.js";
export type AgentIdentity = string | {
    id: string;
    name?: string;
    version?: string;
    description?: string;
};
export type ModelSpec = {
    provider: "openai" | "anthropic" | "deepmind" | "customFormat" | (string & {});
    model: string;
    endpointShape?: "responses" | "chat_completions" | "messages" | "custom" | (string & {});
    carrierId?: string;
    credentialRef?: CredentialRef;
    reasoning?: ProviderReasoningConfig;
    baseURL?: string;
    clientName?: string;
    clientVersion?: string;
    metadata?: Readonly<Record<string, unknown>>;
};
export type ModelEndpointPath = "/v1/messages" | "/v1/responses" | "/v1/chat/completions" | "/v1/images" | "/v1/batches" | "/v1/realtime";
export type ModelEndpointFamily = "messages" | "responses" | "chat_completions" | "images" | "batches" | "realtime";
export type ModelProtocolFamily = "anthropic-messages" | "openai-responses" | "openai-images" | "openai-batches" | "openai-realtime" | "openai-compatible" | "custom";
export type ModelCapabilityRole = "reasoning" | "background" | "image-generation" | "batch" | "realtime" | "embedding" | "rerank" | (string & {});
export type ModelEndpointProbeResult = {
    status: "unknown" | "available" | "unavailable" | "degraded";
    checkedAt?: string;
    latencyMs?: number;
    errorCode?: string;
    publicSafeMessage?: string;
    metadata?: Readonly<Record<string, unknown>>;
};
export type ModelCapabilityMatrix = {
    text?: boolean;
    reasoning?: boolean;
    toolCalling?: boolean;
    visionInput?: boolean;
    imageGeneration?: boolean;
    batch?: boolean;
    realtime?: boolean;
    streaming?: boolean;
    metadata?: Readonly<Record<string, unknown>>;
};
export type ModelFailurePolicy = {
    onUnavailable?: "fallback" | "skip" | "fail" | "degrade";
    fallbackEndpointRef?: string;
    maxRetries?: number;
    timeoutMs?: number;
    metadata?: Readonly<Record<string, unknown>>;
};
export type ModelEndpointSpec = {
    endpointId: string;
    endpoint: ModelEndpointPath;
    endpointFamily: ModelEndpointFamily;
    protocolFamily: ModelProtocolFamily;
    role: ModelCapabilityRole;
    provider?: ModelSpec["provider"];
    model?: string;
    carrierId?: string;
    baseURL?: string;
    credentialRef?: CredentialRef;
    probe?: ModelEndpointProbeResult;
    capabilityMatrix?: ModelCapabilityMatrix;
    failurePolicy?: ModelFailurePolicy;
    metadata?: Readonly<Record<string, unknown>>;
};
export type ModelFleetSpec = {
    mode: "auto" | "manual";
    endpoints: Readonly<Record<string, ModelEndpointSpec>>;
    primaryRef?: string;
    probeStrategy?: "lazy" | "startup" | "manual";
    capabilityMatrix?: Readonly<Record<string, ModelCapabilityMatrix>>;
    failurePolicy?: ModelFailurePolicy;
    metadata?: Readonly<Record<string, unknown>>;
};
export type ToolSpec = {
    toolId: string;
    family?: string;
    group?: string;
    description?: string;
    inputSchema?: Readonly<Record<string, unknown>>;
    scopes?: readonly string[];
    metadata?: Readonly<Record<string, unknown>>;
};
export type PolicySpec = {
    scopes?: readonly string[];
    allowedTools?: readonly string[];
    requireApproval?: readonly string[];
    allowProviderCall?: boolean;
    allowToolExecution?: boolean;
    workspaceRoot?: string;
    allowedRoots?: readonly string[];
    metadata?: Readonly<Record<string, unknown>>;
};
export type LoopSpec = {
    strategy: "single" | "tool-calling-v1" | "custom" | (string & {});
    maxModelTurns?: number;
    /** Maximum tool calls accepted inside one model turn. */
    maxToolCalls?: number;
    metadata?: Readonly<Record<string, unknown>>;
};
export type MainLoopHookName = "onStart" | "buildPrompt" | "chooseModel" | "beforeTool" | "afterTool" | "onApproval" | "shouldContinue" | "shouldBreak" | "onError" | "onResume";
export type MainLoopHookRef = {
    hook: MainLoopHookName;
    strategyRef?: string;
    handlerRef?: string;
    policyRef?: string;
    metadata?: Readonly<Record<string, unknown>>;
};
export type MainLoopSpec = {
    kind: "praxis.mainLoopSpec";
    strategy: "standard" | "custom" | (string & {});
    hooks: readonly MainLoopHookRef[];
    stepRecordCompatible: true;
    modelDecisionCompatible: true;
    ephemeralProcedureCompatible: true;
    promptPackCompatible: true;
    metadata?: Readonly<Record<string, unknown>>;
};
export type ContextSpec = {
    refs?: readonly string[];
    metadata?: Readonly<Record<string, unknown>>;
};
export type MemorySpec = {
    mode?: "none" | "session" | "longTerm" | (string & {});
    pool?: string;
    metadata?: Readonly<Record<string, unknown>>;
};
export type StorageSpec = {
    kind?: "memory" | "sqlite" | "rax-workspace" | (string & {});
    path?: string;
    homeRef?: string;
    workspaceRef?: string;
    sessionStoreRef?: string;
    artifactRootRef?: string;
    cacheRootRef?: string;
    sandboxRootRef?: string;
    init?: "manual" | "on-run" | "never";
    metadata?: Readonly<Record<string, unknown>>;
};
export type PromptMaterialSource = {
    kind: "markdown";
    text: string;
    ref?: string;
} | {
    kind: "markdownFile";
    path: string;
    ref?: string;
} | {
    kind: "materialRef";
    ref: string;
};
export type PromptPatchOperation = "append" | "prepend" | "overwrite" | "replace" | "range" | "replaceLastLines";
export type PromptPatchSpec = {
    patchId: string;
    operation: PromptPatchOperation;
    targetRef: string;
    material: PromptMaterialSource;
    range?: {
        startLine: number;
        endLine: number;
    };
    lastLines?: number;
    sceneTrigger?: string;
    stateTrigger?: string;
    auditRefs?: readonly string[];
    metadata?: Readonly<Record<string, unknown>>;
};
export type PromptPackSpec = {
    promptPackId?: string;
    base?: PromptMaterialSource;
    inherits?: readonly string[];
    patches?: readonly PromptPatchSpec[];
    sceneTriggers?: readonly string[];
    stateMachineMutations?: readonly PromptPatchSpec[];
    auditRefs?: readonly string[];
    materials?: readonly string[];
    designOwner?: "user" | "runtime-shim" | "archetype";
    metadata?: Readonly<Record<string, unknown>>;
};
type PromptPatchHelperInput = Partial<Pick<PromptPatchSpec, "patchId">> & Omit<PromptPatchSpec, "patchId" | "operation" | "targetRef" | "material">;
export declare abstract class PromptPack {
    promptPackId?: string;
    base?: PromptMaterialSource;
    patches?: readonly PromptPatchSpec[];
    inherits?: readonly string[];
    sceneTriggers?: readonly string[];
    stateMachineMutations?: readonly PromptPatchSpec[];
    auditRefs?: readonly string[];
    materials?: readonly string[];
    designOwner?: "user" | "runtime-shim" | "archetype";
    metadata?: Readonly<Record<string, unknown>>;
}
export type SandboxFilesystemPolicy = "workspace-only" | "read-only" | "temp-only" | "deny" | (string & {});
export type SandboxNetworkPolicy = "allow" | "deny-by-default" | "deny" | "approval" | (string & {});
export type SandboxShellPolicy = "deny" | "read-only" | "guarded" | "approval-for-write" | (string & {});
export type SandboxResourceLimits = {
    timeoutMs?: number;
    maxProcesses?: number;
    maxMemoryMb?: number;
    maxOutputBytes?: number;
    maxFileBytes?: number;
    cpuTimeMs?: number;
    memoryWarningPercent?: number;
    memoryAlertPercent?: number;
    memoryThrottlePercent?: number;
    metadata?: Readonly<Record<string, unknown>>;
};
export type SandboxProfile = "host-observed" | "workspace-only" | "linux-bubblewrap" | "rootless-container" | "windows-sandbox" | "macos-containerization" | "remote-worker" | "temp" | "workspace" | "strict" | "custom" | (string & {});
export type SandboxProviderFamily = "host-observed" | "workspace-policy" | "linux-bubblewrap" | "rootless-container" | "windows-sandbox" | "macos-containerization" | "remote-worker" | "custom" | (string & {});
export type SandboxIsolationLevel = "none" | "workspace-policy" | "process-namespace" | "container" | "light-vm" | "remote" | "custom" | (string & {});
export type SandboxPlatformSupportStatus = "supported" | "contract-only" | "unsupported" | "requires-provider" | "unknown";
export type SandboxMountPolicy = {
    workspaceRootRef?: string;
    allowedReadRoots?: readonly string[];
    allowedWriteRoots?: readonly string[];
    readonlyRoot?: boolean;
    tmpfsRefs?: readonly string[];
    metadata?: Readonly<Record<string, unknown>>;
};
export type SandboxNetworkRuntimePolicy = {
    outbound: "allow" | "deny" | "approval" | "provider-policy";
    allowedHosts?: readonly string[];
    metadata?: Readonly<Record<string, unknown>>;
};
export type SandboxProcessPolicy = {
    allowShell: boolean;
    maxProcesses?: number;
    allowedCommands?: readonly string[];
    metadata?: Readonly<Record<string, unknown>>;
};
export type SandboxPlatformSupport = {
    linux?: SandboxPlatformSupportStatus;
    macos?: SandboxPlatformSupportStatus;
    windows?: SandboxPlatformSupportStatus;
    minimumVersions?: Readonly<Record<string, string>>;
    metadata?: Readonly<Record<string, unknown>>;
};
export type SandboxSpec = {
    sandboxId: string;
    profile: SandboxProfile;
    providerFamily?: SandboxProviderFamily;
    isolationLevel?: SandboxIsolationLevel;
    dependencyRefs?: readonly string[];
    filesystem: SandboxFilesystemPolicy;
    network: SandboxNetworkPolicy;
    shell: SandboxShellPolicy;
    mountPolicy?: SandboxMountPolicy;
    networkPolicy?: SandboxNetworkRuntimePolicy;
    processPolicy?: SandboxProcessPolicy;
    platformSupport?: SandboxPlatformSupport;
    scratchRoot?: string;
    resourceLimits: SandboxResourceLimits;
    reusableProfileRef?: string;
    metadata?: Readonly<Record<string, unknown>>;
};
export type BaseToolPolicyDecision = "allow" | "deny" | "approval" | "guarded" | "approval-on-destructive" | (string & {});
export type BaseToolPolicyProfile = "bapr" | "yolo" | "permissive" | "standard" | "restricted" | "codingAgentFull" | "custom";
export type BaseToolPolicyRisk = "safe" | "risky" | "dangerous" | "low" | "medium" | "high" | "destructive" | (string & {});
export type BaseToolPolicyRule = {
    scope: "family" | "group" | "toolId" | "action";
    family?: string;
    group?: string;
    toolId?: string;
    action?: string;
    decision: BaseToolPolicyDecision;
    risk?: BaseToolPolicyRisk;
    log?: "none" | "summary" | "full";
    approval?: "none" | "required" | "on-risk" | "on-destructive";
    sandboxRef?: string;
    resourceLimits?: SandboxResourceLimits;
    metadata?: Readonly<Record<string, unknown>>;
};
export type BaseToolPolicyMatrixSpec = {
    matrixId: string;
    profile: BaseToolPolicyProfile;
    defaultDecision: BaseToolPolicyDecision;
    familyRules: readonly BaseToolPolicyRule[];
    groupRules: readonly BaseToolPolicyRule[];
    toolRules: readonly BaseToolPolicyRule[];
    actionRules: readonly BaseToolPolicyRule[];
    readinessPolicy?: "observe" | "strict" | "disabled";
    eventLogLevel?: "summary" | "full";
    metadata?: Readonly<Record<string, unknown>>;
};
export type SessionSpec = {
    persistence: "memory" | "sqlite" | (string & {});
    resume: "manual" | "auto" | "disabled" | (string & {});
    thread: "ephemeral" | "durable" | (string & {});
    logs: "none" | "summary" | "full" | (string & {});
    storeRef?: string;
    metadata?: Readonly<Record<string, unknown>>;
};
export type StatePlaneSpec = {
    expose: readonly string[];
    control: readonly string[];
    audit: "none" | "summary" | "full";
    metadata?: Readonly<Record<string, unknown>>;
};
export declare const STATE_PLANE_STANDARD_CONTROLS: readonly ["pause", "resume", "interrupt", "approve", "deny", "rollback", "inspect", "repair", "configure", "rotateSecretRef"];
export type FrameworkCoreContractSpec = {
    kind: "praxis.frameworkCoreContract";
    contractVersion: "praxis.frameworkCore.v1";
    phase: "framework-core";
    runtimeTruth: "agentManifest";
    promptPack: {
        layer: "formal";
        providerPayloadBuilder: false;
        sourceCategories: readonly ["declared-built-in", "process-product", "user-request"];
        bindRef: "runtime.execEngine.bindPromptPack";
        loweringRef: "runtime.modelAdapter.promptLoweringRuntime";
        promptPackId: string;
    };
    mainLoop: {
        layer: "formal";
        arbitraryUserJs: false;
        stepRecordCompatible: true;
        modelDecisionCompatible: true;
        ephemeralProcedureCompatible: true;
        bindRef: "runtime.execEngine.bindCoreLogic";
        strategy: MainLoopSpec["strategy"];
    };
    modelDecision: {
        providerNeutral: true;
        variants: readonly ["finalOutput", "toolCall", "ephemeralProcedurePlan", "requestApproval", "continue", "fail"];
    };
    baseToolGovernance: {
        identityAxis: "family/group/toolId";
        canonicalMountChain: readonly [
            "adaptRuntimeToolInvocation",
            "bridgeExecEngineInvocation",
            "createBaseToolRegistry.lookupHandler",
            "BaseToolHandler.invoke",
            "BaseToolExecutorPort"
        ];
        policyMatrixId: string;
        sandboxId: string;
    };
    sessionStateEvent: {
        session: SessionSpec;
        statePlane: StatePlaneSpec;
        records: readonly ["session", "state", "event", "modelInvocation", "toolInvocation", "mainLoopStep"];
    };
    approval: {
        interfaceSurface: true;
        defaultBehavior: "public-safe-pending";
    };
    inspectionDebug: {
        manifestInspectable: true;
        debugSnapshotReady: boolean;
        selfRepairContractReady: boolean;
    };
    officialModuleBridge: {
        tap: "contract-only";
        cmp: "contract-only";
        mp: "contract-only";
        multiagent: "contract-only";
    };
    verificationGates: readonly string[];
};
export type HarnessSpec = {
    modelRef?: string;
    modelFleetRef?: string;
    promptPackRef?: string;
    toolPolicyRef?: string;
    mainLoopRef?: string;
    sandboxRef?: string;
    storageRef?: string;
    sessionRef?: string;
    statePlaneRef?: string;
    interfaceRefs?: readonly string[];
    contextRefs?: readonly string[];
    memoryRefs?: readonly string[];
    context?: ContextSpec;
    memory?: MemorySpec;
    storage?: StorageSpec;
    promptPack?: PromptPackSpec;
    tools?: readonly ToolSpec[];
    policy?: PolicySpec;
    loop?: LoopSpec;
    modelFleet?: ModelFleetSpec;
    mainLoop?: MainLoopSpec;
    sandbox?: SandboxSpec;
    toolPolicy?: BaseToolPolicyMatrixSpec;
    session?: SessionSpec;
    statePlane?: StatePlaneSpec;
    modules?: Readonly<Record<string, unknown>>;
    runtimeRequirements?: readonly string[];
    metadata?: Readonly<Record<string, unknown>>;
};
export type BehaviorSpec = Readonly<Record<string, unknown>>;
export type AgentHooks = Readonly<Record<string, unknown>>;
export declare abstract class PraxisAgent {
    abstract identity: AgentIdentity;
    abstract model: ModelSpec;
    abstract harness: HarnessSpec;
    modelFleet?: ModelFleetSpec;
    storage?: StorageSpec;
    promptPack?: PromptPackSpec | PromptPack;
    mainLoop?: MainLoopSpec;
    sandbox?: SandboxSpec;
    toolPolicy?: BaseToolPolicyMatrixSpec;
    session?: SessionSpec;
    statePlane?: StatePlaneSpec;
    behaviors?: BehaviorSpec;
    hooks?: AgentHooks;
}
export declare abstract class PraxisAgentArchetype extends PraxisAgent {
    modelFleet?: ModelFleetSpec;
    storage?: StorageSpec;
    promptPack?: PromptPackSpec | PromptPack;
    mainLoop?: MainLoopSpec;
    sandbox?: SandboxSpec;
    toolPolicy?: BaseToolPolicyMatrixSpec;
    session?: SessionSpec;
    statePlane?: StatePlaneSpec;
}
export type AgentSourceKind = "class" | "instance";
export type AgentManifest = {
    kind: "praxis.agentManifest";
    schemaVersion: "praxis.agentManifest.v1";
    manifestId: string;
    manifestHash: string;
    compiledAt: string;
    source: {
        kind: AgentSourceKind;
        className?: string;
        constructorSideEffectsAllowed: false;
    };
    identity: {
        id: string;
        name?: string;
        version?: string;
        description?: string;
    };
    model: ModelSpec & {
        carrierId: string;
        endpointShape: string;
    };
    modelFleet: ModelFleetSpec;
    promptPack: Required<Pick<PromptPackSpec, "materials" | "inherits" | "patches" | "sceneTriggers" | "stateMachineMutations" | "auditRefs">> & {
        promptPackId: string;
        base?: PromptMaterialSource;
        designOwner: "user" | "runtime-shim" | "archetype";
        metadata: Readonly<Record<string, unknown>>;
    };
    mainLoop: MainLoopSpec;
    storage: StorageSpec;
    sandbox: SandboxSpec;
    toolPolicy: BaseToolPolicyMatrixSpec;
    session: SessionSpec;
    statePlane: StatePlaneSpec;
    frameworkCore: FrameworkCoreContractSpec;
    harness: Required<Pick<HarnessSpec, "context" | "memory" | "storage" | "promptPack" | "tools" | "policy" | "loop">> & {
        modelRef: string;
        modelFleetRef: string;
        promptPackRef: string;
        toolPolicyRef: string;
        mainLoopRef: string;
        sandboxRef: string;
        storageRef: string;
        sessionRef: string;
        statePlaneRef: string;
        interfaceRefs: readonly string[];
        contextRefs: readonly string[];
        memoryRefs: readonly string[];
        modelFleet: ModelFleetSpec;
        mainLoop: MainLoopSpec;
        sandbox: SandboxSpec;
        toolPolicy: BaseToolPolicyMatrixSpec;
        session: SessionSpec;
        statePlane: StatePlaneSpec;
        frameworkCore: FrameworkCoreContractSpec;
        modules: Readonly<Record<string, unknown>>;
        runtimeRequirements: readonly string[];
        metadata: Readonly<Record<string, unknown>>;
    };
    behaviors?: BehaviorSpec;
    hooks?: AgentHooks;
    verification: {
        compiled: true;
        harnessDeclarative: true;
        runtimeExecutesManifestOnly: true;
    };
};
export type AgentCompileErrorCode = "MISSING_AGENT" | "INVALID_AGENT_CLASS" | "MISSING_IDENTITY" | "MISSING_MODEL" | "MISSING_MODEL_NAME" | "MISSING_HARNESS" | "INVALID_MODEL_FLEET" | "INVALID_PROMPT_PACK" | "INVALID_MAIN_LOOP" | "INVALID_SANDBOX" | "INVALID_TOOL_POLICY" | "INVALID_TOOL_SPEC" | "INVALID_SESSION" | "INVALID_STATE_PLANE" | "INVALID_MANIFEST";
export type AgentManifestValidationErrorCode = "MISSING_MANIFEST" | "INVALID_KIND" | "INVALID_SCHEMA_VERSION" | "MISSING_MANIFEST_ID" | "MISSING_HASH" | "HASH_MISMATCH" | "MISSING_FRAMEWORK_CORE" | "HARNESS_VIEW_MISMATCH" | "RAW_SECRET_REJECTED";
export type AgentManifestValidationResult = {
    ok: true;
    manifest: AgentManifest;
    events: readonly string[];
} | {
    ok: false;
    error: {
        code: AgentManifestValidationErrorCode;
        message: string;
        boundary: "input" | "manifest" | "security" | "consistency";
        publicSafe: true;
    };
    events: readonly string[];
};
export type AgentManifestInspection = {
    manifestId: string;
    manifestHash: string;
    identityId: string;
    model: {
        provider: string;
        model: string;
        carrierId: string;
        endpointShape: string;
        fleetMode: ModelFleetSpec["mode"];
        endpoints: readonly string[];
    };
    promptPack: {
        promptPackId: string;
        designOwner: AgentManifest["promptPack"]["designOwner"];
        patchCount: number;
        materialCount: number;
    };
    mainLoop: {
        strategy: MainLoopSpec["strategy"];
        hookCount: number;
        formalLayer: boolean;
    };
    governance: {
        sandboxProfile: SandboxProfile;
        sandboxId: string;
        toolPolicyProfile: BaseToolPolicyProfile;
        policyMatrixId: string;
    };
    sessionState: {
        persistence: SessionSpec["persistence"];
        resume: SessionSpec["resume"];
        thread: SessionSpec["thread"];
        storageKind: string;
        sessionStoreRef?: string;
        exposedState: readonly string[];
        controls: readonly string[];
    };
    frameworkCore: {
        contractVersion: FrameworkCoreContractSpec["contractVersion"];
        promptPackBindRef: FrameworkCoreContractSpec["promptPack"]["bindRef"];
        mainLoopBindRef: FrameworkCoreContractSpec["mainLoop"]["bindRef"];
        officialModules: FrameworkCoreContractSpec["officialModuleBridge"];
    };
    runtimeRequirements: readonly string[];
    verificationGates: readonly string[];
};
export type AgentCompileResult = {
    ok: true;
    manifest: AgentManifest;
    events: readonly string[];
} | {
    ok: false;
    error: {
        code: AgentCompileErrorCode;
        message: string;
        boundary: "input" | "agent-object" | "manifest";
        publicSafe: true;
    };
    events: readonly string[];
};
export type PraxisAgentClass<TAgent extends PraxisAgent = PraxisAgent> = new () => TAgent;
export type PraxisAgentInput<TAgent extends PraxisAgent = PraxisAgent> = TAgent | PraxisAgentClass<TAgent>;
export declare function model(modelName: string, input?: Omit<ModelSpec, "provider" | "model"> & {
    provider?: ModelSpec["provider"];
}): ModelSpec;
export declare function endpoint(endpointPath: ModelEndpointPath, input: Omit<ModelEndpointSpec, "endpoint" | "endpointFamily" | "protocolFamily" | "endpointId"> & {
    endpointId?: string;
    protocolFamily?: ModelProtocolFamily;
}): ModelEndpointSpec;
export declare const modelFleet: {
    auto(endpoints: Readonly<Record<string, ModelEndpointSpec>>, input?: Omit<ModelFleetSpec, "mode" | "endpoints">): ModelFleetSpec;
};
export declare function tool(toolId: string, input?: Omit<ToolSpec, "toolId">): ToolSpec;
export declare function tools(items: readonly ToolSpec[]): readonly ToolSpec[];
export declare function policy(input?: PolicySpec): PolicySpec;
export declare const storage: {
    memory(input?: Omit<StorageSpec, "kind">): StorageSpec;
    sqlite(input?: Omit<StorageSpec, "kind">): StorageSpec;
    raxWorkspace(input?: Omit<StorageSpec, "kind">): StorageSpec;
};
export declare const loop: ((input?: LoopSpec) => LoopSpec) & {
    standard(input?: Omit<LoopSpec, "strategy">): LoopSpec;
    single(input?: Omit<LoopSpec, "strategy">): LoopSpec;
    custom(strategy: string, input?: Omit<LoopSpec, "strategy">): LoopSpec;
};
export type MainLoopStandardInput = {
    hooks?: Partial<Record<MainLoopHookName, string | Omit<MainLoopHookRef, "hook">>>;
    buildPromptRef?: string;
    chooseModelRef?: string;
    beforeToolRef?: string;
    afterToolRef?: string;
    onApprovalRef?: string;
    onErrorRef?: string;
    onResumeRef?: string;
    metadata?: Readonly<Record<string, unknown>>;
};
export declare const mainLoop: {
    standard(input?: MainLoopStandardInput): MainLoopSpec;
    custom(input: Omit<MainLoopStandardInput, "metadata"> & {
        strategy: string;
        metadata?: Readonly<Record<string, unknown>>;
    }): MainLoopSpec;
};
export declare function markdown(text: string, ref?: string): PromptMaterialSource;
export declare function markdownFile(path: string, ref?: string): PromptMaterialSource;
export declare function append(targetRef: string, material: PromptMaterialSource, input?: PromptPatchHelperInput): PromptPatchSpec;
export declare function prepend(targetRef: string, material: PromptMaterialSource, input?: PromptPatchHelperInput): PromptPatchSpec;
export declare function overwrite(targetRef: string, material: PromptMaterialSource, input?: PromptPatchHelperInput): PromptPatchSpec;
export declare function replaceLastLines(targetRef: string, lastLines: number, material: PromptMaterialSource, input?: Omit<PromptPatchHelperInput, "lastLines">): PromptPatchSpec;
export declare const sandbox: {
    hostObserved(input?: Partial<Omit<SandboxSpec, "sandboxId" | "profile" | "resourceLimits">> & {
        sandboxId?: string;
        resourceLimits?: SandboxResourceLimits;
    }): SandboxSpec;
    temp(input?: Partial<Omit<SandboxSpec, "sandboxId" | "profile" | "resourceLimits">> & {
        sandboxId?: string;
        resourceLimits?: SandboxResourceLimits;
    }): SandboxSpec;
    workspaceOnly(input?: Partial<Omit<SandboxSpec, "sandboxId" | "profile" | "providerFamily" | "isolationLevel" | "resourceLimits">> & {
        sandboxId?: string;
        resourceLimits?: SandboxResourceLimits;
    }): SandboxSpec;
    linuxBubblewrap(input?: Partial<Omit<SandboxSpec, "sandboxId" | "profile" | "providerFamily" | "isolationLevel" | "resourceLimits">> & {
        sandboxId?: string;
        resourceLimits?: SandboxResourceLimits;
    }): SandboxSpec;
    linuxBubblewrapReadonly(input?: Partial<Omit<SandboxSpec, "sandboxId" | "profile" | "providerFamily" | "isolationLevel" | "resourceLimits">> & {
        sandboxId?: string;
        resourceLimits?: SandboxResourceLimits;
    }): SandboxSpec;
    linuxBubblewrapWorkspaceWrite(input?: Partial<Omit<SandboxSpec, "sandboxId" | "profile" | "providerFamily" | "isolationLevel" | "resourceLimits">> & {
        sandboxId?: string;
        resourceLimits?: SandboxResourceLimits;
    }): SandboxSpec;
    linuxBubblewrapNetworked(input?: Partial<Omit<SandboxSpec, "sandboxId" | "profile" | "providerFamily" | "isolationLevel" | "resourceLimits">> & {
        sandboxId?: string;
        resourceLimits?: SandboxResourceLimits;
    }): SandboxSpec;
    rootlessContainer(input?: Partial<Omit<SandboxSpec, "sandboxId" | "profile" | "providerFamily" | "isolationLevel" | "resourceLimits">> & {
        sandboxId?: string;
        resourceLimits?: SandboxResourceLimits;
    }): SandboxSpec;
    windowsSandbox(input?: Partial<Omit<SandboxSpec, "sandboxId" | "profile" | "providerFamily" | "isolationLevel" | "resourceLimits">> & {
        sandboxId?: string;
        resourceLimits?: SandboxResourceLimits;
    }): SandboxSpec;
    macosContainerization(input?: Partial<Omit<SandboxSpec, "sandboxId" | "profile" | "providerFamily" | "isolationLevel" | "resourceLimits">> & {
        sandboxId?: string;
        resourceLimits?: SandboxResourceLimits;
    }): SandboxSpec;
    remoteWorker(input?: Partial<Omit<SandboxSpec, "sandboxId" | "profile" | "providerFamily" | "isolationLevel" | "resourceLimits">> & {
        sandboxId?: string;
        resourceLimits?: SandboxResourceLimits;
    }): SandboxSpec;
    profile(input: SandboxSpec): SandboxSpec;
};
type ToolPolicyProfileInput = {
    matrixId?: string;
    metadata?: Readonly<Record<string, unknown>>;
};
export type ToolPolicyCustomInput = ToolPolicyProfileInput & {
    defaultDecision?: BaseToolPolicyDecision;
    familyRules?: readonly BaseToolPolicyRule[];
    groupRules?: readonly BaseToolPolicyRule[];
    toolRules?: readonly BaseToolPolicyRule[];
    actionRules?: readonly BaseToolPolicyRule[];
    readinessPolicy?: BaseToolPolicyMatrixSpec["readinessPolicy"];
    eventLogLevel?: BaseToolPolicyMatrixSpec["eventLogLevel"];
};
export declare const toolPolicies: {
    custom(input?: ToolPolicyCustomInput): BaseToolPolicyMatrixSpec;
    bapr(input?: ToolPolicyProfileInput): BaseToolPolicyMatrixSpec;
    yolo(input?: ToolPolicyProfileInput): BaseToolPolicyMatrixSpec;
    permissive(input?: ToolPolicyProfileInput): BaseToolPolicyMatrixSpec;
    standard(input?: ToolPolicyProfileInput): BaseToolPolicyMatrixSpec;
    restricted(input?: ToolPolicyProfileInput): BaseToolPolicyMatrixSpec;
    codingAgentFull(input?: {
        read?: BaseToolPolicyDecision;
        write?: BaseToolPolicyDecision;
        shell?: BaseToolPolicyDecision;
        git?: BaseToolPolicyDecision;
        matrixId?: string;
        metadata?: Readonly<Record<string, unknown>>;
    }): BaseToolPolicyMatrixSpec;
};
export declare function session(input?: Partial<SessionSpec>): SessionSpec;
export declare function statePlane(input?: Partial<StatePlaneSpec>): StatePlaneSpec;
export declare function harness(input: HarnessSpec): HarnessSpec;
export declare function compileAgent<TAgent extends PraxisAgent>(input?: PraxisAgentInput<TAgent>, options?: {
    compiledAt?: string;
    manifestId?: string;
}): AgentCompileResult;
export declare function validateAgentManifest(input: unknown): AgentManifestValidationResult;
export declare function inspectAgentManifest(manifest: AgentManifest): AgentManifestInspection;
export {};
