import { z } from 'zod';
import { type DappDeploymentIntentV1 } from './deploymentIntent.ts';
import type { DappDeploymentLockIssue } from './deploymentLock.ts';
import { type CreateDappDeploymentLockV2Input } from './deploymentLockV2.ts';
export declare const DappDeploymentLockV3PreimageZod: z.ZodObject<{
    schema: z.ZodLiteral<"network.xyo.dapp.deployment.lock" & {
        readonly __schema: true;
    }>;
    schemaVersion: z.ZodLiteral<3>;
    hashAlgorithm: z.ZodLiteral<"jcs-sha256-v1">;
    project: z.ZodObject<{
        schemaVersion: z.ZodLiteral<1>;
        projectHash: z.ZodString;
    }, z.core.$strict>;
    deployment: z.ZodObject<{
        name: z.ZodString;
        requestHash: z.ZodString;
        manifest: z.ZodObject<{
            schemaVersion: z.ZodLiteral<2>;
            deploymentManifestId: z.ZodString;
        }, z.core.$strict>;
        intent: z.ZodObject<{
            schemaVersion: z.ZodLiteral<1>;
            deploymentIntentId: z.ZodString;
        }, z.core.$strict>;
    }, z.core.$strict>;
    things: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"website">;
        artifactId: z.ZodString;
        exposure: z.ZodEnum<{
            public: "public";
            private: "private";
        }>;
        routes: z.ZodArray<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"api">;
        artifactId: z.ZodString;
        ports: z.ZodArray<z.ZodString>;
        routes: z.ZodArray<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"datalake">;
        resourceId: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"event-ingress">;
        artifactId: z.ZodString;
        eventStreamResource: z.ZodString;
        routes: z.ZodArray<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"event-stream">;
        resourceId: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"subscription-runner">;
        subscriptionResource: z.ZodString;
        consumerActor: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"indexer">;
        subscriptionResource: z.ZodString;
        consumerActor: z.ZodString;
        projectionResource: z.ZodString;
        checkpointResource: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"controller">;
        subscriptionResource: z.ZodString;
        consumerActor: z.ZodString;
        effectJournalResource: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"publisher">;
        subscriptionResource: z.ZodString;
        consumerActor: z.ZodString;
        publicationResources: z.ZodArray<z.ZodString>;
    }, z.core.$strict>], "kind">>;
    placements: z.ZodObject<{
        things: z.ZodArray<z.ZodObject<{
            thingId: z.ZodString;
            infrastructureId: z.ZodString;
        }, z.core.$strict>>;
        resources: z.ZodArray<z.ZodObject<{
            resourceId: z.ZodString;
            infrastructureId: z.ZodString;
        }, z.core.$strict>>;
        hosts: z.ZodArray<z.ZodObject<{
            hostPartitionId: z.ZodString;
            infrastructureId: z.ZodString;
        }, z.core.$strict>>;
    }, z.core.$strict>;
    infrastructure: z.ZodArray<z.ZodObject<{
        infrastructureId: z.ZodString;
        kind: z.ZodEnum<{
            vercel: "vercel";
            cloudflare: "cloudflare";
            kubernetes: "kubernetes";
            proxmox: "proxmox";
        }>;
        adapterId: z.ZodString;
        adapterVersion: z.ZodString;
        adapterDescriptorHash: z.ZodString;
        infrastructureDescriptorHash: z.ZodString;
        infrastructurePolicyHash: z.ZodString;
        expectedScopeCommitment: z.ZodString;
    }, z.core.$strict>>;
    definitionHash: z.ZodString;
    configurationHash: z.ZodString;
    configuration: z.ZodObject<{
        applicationProviders: z.ZodOptional<z.ZodArray<z.ZodObject<{
            instanceId: z.ZodString;
            artifactId: z.ZodString;
            descriptor: z.ZodObject<{
                id: z.ZodString;
                version: z.ZodNumber;
            }, z.core.$strict>;
            host: z.ZodString;
            config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
            dependencies: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"application-provider">;
                instanceId: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"resource">;
                resourceId: z.ZodString;
            }, z.core.$strict>], "kind">>;
        }, z.core.$strict>>>;
        schema: z.ZodLiteral<"network.xyo.dapp.configuration" & {
            readonly __schema: true;
        }>;
        schemaVersion: z.ZodLiteral<1>;
        dappId: z.ZodString;
        definitionVersion: z.ZodString;
        network: z.ZodObject<{
            networkId: z.ZodString;
            expectedChainId: z.ZodString;
        }, z.core.$strict>;
        actors: z.ZodArray<z.ZodObject<{
            instanceId: z.ZodString;
            roleId: z.ZodString;
            host: z.ZodString;
            executionMode: z.ZodEnum<{
                "on-demand": "on-demand";
                "event-driven": "event-driven";
                scheduled: "scheduled";
                resident: "resident";
            }>;
            config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
        }, z.core.$strict>>;
        supervision: z.ZodDiscriminatedUnion<[z.ZodObject<{
            policy: z.ZodLiteral<"sequential">;
            actorOrder: z.ZodArray<z.ZodString>;
        }, z.core.$strict>, z.ZodObject<{
            policy: z.ZodLiteral<"parallel">;
        }, z.core.$strict>], "policy">;
        providerBindings: z.ZodRecord<z.ZodString, z.ZodObject<{
            descriptorId: z.ZodString;
            config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
        }, z.core.$strict>>;
        identityBindings: z.ZodArray<z.ZodObject<{
            roleId: z.ZodString;
            capabilityId: z.ZodString;
            derivation: z.ZodOptional<z.ZodObject<{
                algorithm: z.ZodLiteral<"bip44-secp256k1-v1">;
                rootCapabilityId: z.ZodString;
                fullPath: z.ZodString;
                expectedAddress: z.ZodString;
                networkScope: z.ZodString;
                migration: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    mode: z.ZodLiteral<"none">;
                }, z.core.$strict>, z.ZodObject<{
                    mode: z.ZodLiteral<"rotate-from">;
                    predecessorAddress: z.ZodString;
                    authorization: z.ZodLiteral<"application-protocol">;
                }, z.core.$strict>], "mode">;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
        sideChannelPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
            profile: z.ZodLiteral<"none">;
        }, z.core.$strict>, z.ZodObject<{
            unavailableBehavior: z.ZodLiteral<"continue-without-channel">;
            channelCapabilityId: z.ZodString;
            detachedSigningCapabilityId: z.ZodString;
            transport: z.ZodEnum<{
                "in-memory": "in-memory";
                "post-message": "post-message";
                http: "http";
                websocket: "websocket";
                webrtc: "webrtc";
                chatter: "chatter";
            }>;
            maximumMessageBytes: z.ZodNumber;
            replayRetentionSeconds: z.ZodNumber;
            acceptedClockSkewMilliseconds: z.ZodNumber;
            profile: z.ZodLiteral<"optional-optimization">;
        }, z.core.$strict>, z.ZodObject<{
            unavailableBehavior: z.ZodEnum<{
                pending: "pending";
                expire: "expire";
                "fail-operation": "fail-operation";
            }>;
            channelCapabilityId: z.ZodString;
            detachedSigningCapabilityId: z.ZodString;
            transport: z.ZodEnum<{
                "in-memory": "in-memory";
                "post-message": "post-message";
                http: "http";
                websocket: "websocket";
                webrtc: "webrtc";
                chatter: "chatter";
            }>;
            maximumMessageBytes: z.ZodNumber;
            replayRetentionSeconds: z.ZodNumber;
            acceptedClockSkewMilliseconds: z.ZodNumber;
            profile: z.ZodLiteral<"required-for-liveness">;
        }, z.core.$strict>], "profile">;
        externalInteractionPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
            mode: z.ZodLiteral<"none">;
        }, z.core.$strict>, z.ZodObject<{
            mode: z.ZodLiteral<"observe">;
            sources: z.ZodArray<z.ZodObject<{
                sourceId: z.ZodString;
                sourceKind: z.ZodEnum<{
                    api: "api";
                    "evm-chain": "evm-chain";
                    sensor: "sensor";
                    clock: "clock";
                    other: "other";
                }>;
                observerCapabilityId: z.ZodString;
                config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
            }, z.core.$strict>>;
        }, z.core.$strict>, z.ZodObject<{
            mode: z.ZodLiteral<"attest-import">;
            sources: z.ZodArray<z.ZodObject<{
                sourceId: z.ZodString;
                sourceKind: z.ZodEnum<{
                    api: "api";
                    "evm-chain": "evm-chain";
                    sensor: "sensor";
                    clock: "clock";
                    other: "other";
                }>;
                observerCapabilityId: z.ZodString;
                config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
            }, z.core.$strict>>;
            commitBeforeReduction: z.ZodLiteral<true>;
        }, z.core.$strict>], "mode">;
        datalakePolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
            mode: z.ZodLiteral<"none">;
        }, z.core.$strict>, z.ZodObject<{
            mode: z.ZodLiteral<"optional">;
            readAccess: z.ZodEnum<{
                "public-read": "public-read";
                "capability-read": "capability-read";
                "private-network": "private-network";
            }>;
            contentProtection: z.ZodEnum<{
                plaintext: "plaintext";
                encrypted: "encrypted";
                "selectively-disclosed": "selectively-disclosed";
            }>;
            writeBeforeBroadcast: z.ZodBoolean;
            requiredCopies: z.ZodNumber;
            retentionSeconds: z.ZodNumber;
            unavailableBehavior: z.ZodEnum<{
                "fail-closed": "fail-closed";
                "degrade-read-only": "degrade-read-only";
                "ignore-missing": "ignore-missing";
            }>;
        }, z.core.$strict>, z.ZodObject<{
            mode: z.ZodLiteral<"required">;
            readAccess: z.ZodEnum<{
                "public-read": "public-read";
                "capability-read": "capability-read";
                "private-network": "private-network";
            }>;
            contentProtection: z.ZodEnum<{
                plaintext: "plaintext";
                encrypted: "encrypted";
                "selectively-disclosed": "selectively-disclosed";
            }>;
            writeBeforeBroadcast: z.ZodLiteral<true>;
            requiredCopies: z.ZodNumber;
            retentionSeconds: z.ZodNumber;
            unavailableBehavior: z.ZodEnum<{
                "fail-closed": "fail-closed";
                "degrade-read-only": "degrade-read-only";
                "ignore-missing": "ignore-missing";
            }>;
        }, z.core.$strict>], "mode">;
        auxiliaryStores: z.ZodArray<z.ZodObject<{
            class: z.ZodEnum<{
                secret: "secret";
                "private-draft": "private-draft";
                "effect-journal": "effect-journal";
                "replay-checkpoint": "replay-checkpoint";
                projection: "projection";
                "disposable-cache": "disposable-cache";
            }>;
            capabilityId: z.ZodString;
            durability: z.ZodEnum<{
                "host-ephemeral": "host-ephemeral";
                "crash-durable": "crash-durable";
            }>;
        }, z.core.$strict>>;
        projectionPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
            profile: z.ZodLiteral<"none">;
        }, z.core.$strict>, z.ZodObject<{
            projectionCapabilityId: z.ZodString;
            floor: z.ZodDiscriminatedUnion<[z.ZodObject<{
                mode: z.ZodLiteral<"bounded">;
                block: z.ZodNumber;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"genesis">;
                block: z.ZodLiteral<0>;
            }, z.core.$strict>], "mode">;
            maximumLagBlocks: z.ZodNumber;
            progressWatermark: z.ZodBoolean;
            profile: z.ZodLiteral<"ephemeral">;
        }, z.core.$strict>, z.ZodObject<{
            checkpointCapabilityId: z.ZodString;
            projectionCapabilityId: z.ZodString;
            floor: z.ZodDiscriminatedUnion<[z.ZodObject<{
                mode: z.ZodLiteral<"bounded">;
                block: z.ZodNumber;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"genesis">;
                block: z.ZodLiteral<0>;
            }, z.core.$strict>], "mode">;
            maximumLagBlocks: z.ZodNumber;
            progressWatermark: z.ZodBoolean;
            profile: z.ZodEnum<{
                "private-durable": "private-durable";
                "public-served": "public-served";
                "signed-publication": "signed-publication";
            }>;
        }, z.core.$strict>], "profile">;
        consistency: z.ZodObject<{
            read: z.ZodLiteral<"finalized">;
            readinessMaxLag: z.ZodNumber;
        }, z.core.$strict>;
    }, z.core.$strict>;
    plan: z.ZodObject<{
        schema: z.ZodLiteral<"network.xyo.dapp.plan" & {
            readonly __schema: true;
        }>;
        schemaVersion: z.ZodLiteral<1>;
        definitionHash: z.ZodString;
        configurationHash: z.ZodString;
        definition: z.ZodObject<{
            schema: z.ZodLiteral<"network.xyo.dapp.definition" & {
                readonly __schema: true;
            }>;
            schemaVersion: z.ZodLiteral<1>;
            dappId: z.ZodString;
            definitionVersion: z.ZodString;
            protocolVersion: z.ZodString;
            substrate: z.ZodObject<{
                canonicalSource: z.ZodLiteral<"xl1-finalized">;
                relationships: z.ZodArray<z.ZodEnum<{
                    "consumes-finalized": "consumes-finalized";
                    "projects-finalized": "projects-finalized";
                    "bridges-external": "bridges-external";
                }>>;
            }, z.core.$strict>;
            schemas: z.ZodArray<z.ZodObject<{
                schema: z.ZodString;
                version: z.ZodNumber;
            }, z.core.$strict>>;
            actors: z.ZodArray<z.ZodObject<{
                roleId: z.ZodString;
                descriptor: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                supportedExecutionModes: z.ZodArray<z.ZodEnum<{
                    "on-demand": "on-demand";
                    "event-driven": "event-driven";
                    scheduled: "scheduled";
                    resident: "resident";
                }>>;
                effectAuthority: z.ZodEnum<{
                    "read-only": "read-only";
                    "user-mediated": "user-mediated";
                    "service-authorized": "service-authorized";
                    "multi-party": "multi-party";
                }>;
                requiredCapabilities: z.ZodArray<z.ZodObject<{
                    moniker: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>>;
            }, z.core.$strict>>;
            ports: z.ZodArray<z.ZodObject<{
                portId: z.ZodString;
                version: z.ZodString;
                commands: z.ZodArray<z.ZodString>;
                queries: z.ZodArray<z.ZodString>;
                subscriptions: z.ZodArray<z.ZodString>;
            }, z.core.$strict>>;
            identityRoles: z.ZodArray<z.ZodString>;
            coordination: z.ZodDiscriminatedUnion<[z.ZodObject<{
                profile: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                messageKinds: z.ZodArray<z.ZodEnum<{
                    ephemeral: "ephemeral";
                    proposal: "proposal";
                    attestation: "attestation";
                    "projection-hint": "projection-hint";
                }>>;
                authorizedSenderRoles: z.ZodArray<z.ZodString>;
                delivery: z.ZodLiteral<"unordered-at-least-once">;
                historyCanonical: z.ZodLiteral<false>;
                detachedSignatures: z.ZodLiteral<true>;
                maximumMessageBytes: z.ZodNumber;
                minimumReplayRetentionSeconds: z.ZodNumber;
                maximumClockSkewMilliseconds: z.ZodNumber;
                profile: z.ZodLiteral<"optional-optimization">;
            }, z.core.$strict>, z.ZodObject<{
                messageKinds: z.ZodArray<z.ZodEnum<{
                    ephemeral: "ephemeral";
                    proposal: "proposal";
                    attestation: "attestation";
                    "projection-hint": "projection-hint";
                }>>;
                authorizedSenderRoles: z.ZodArray<z.ZodString>;
                delivery: z.ZodLiteral<"unordered-at-least-once">;
                historyCanonical: z.ZodLiteral<false>;
                detachedSignatures: z.ZodLiteral<true>;
                maximumMessageBytes: z.ZodNumber;
                minimumReplayRetentionSeconds: z.ZodNumber;
                maximumClockSkewMilliseconds: z.ZodNumber;
                profile: z.ZodLiteral<"required-for-liveness">;
            }, z.core.$strict>], "profile">;
            externalInteraction: z.ZodDiscriminatedUnion<[z.ZodObject<{
                mode: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                allowedSourceKinds: z.ZodArray<z.ZodEnum<{
                    api: "api";
                    "evm-chain": "evm-chain";
                    sensor: "sensor";
                    clock: "clock";
                    other: "other";
                }>>;
                provenancePolicy: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                finalityPolicy: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                mode: z.ZodLiteral<"observe">;
            }, z.core.$strict>, z.ZodObject<{
                observationSchemas: z.ZodArray<z.ZodObject<{
                    schema: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>>;
                commitBeforeReduction: z.ZodLiteral<true>;
                allowedSourceKinds: z.ZodArray<z.ZodEnum<{
                    api: "api";
                    "evm-chain": "evm-chain";
                    sensor: "sensor";
                    clock: "clock";
                    other: "other";
                }>>;
                provenancePolicy: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                finalityPolicy: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                mode: z.ZodLiteral<"attest-import">;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"actuate-export">;
                effectFamily: z.ZodString;
            }, z.core.$strict>], "mode">;
            durability: z.ZodObject<{
                contentMode: z.ZodEnum<{
                    "chain-only": "chain-only";
                    "commitment-only": "commitment-only";
                    "datalake-backed": "datalake-backed";
                }>;
                datalake: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    mode: z.ZodLiteral<"none">;
                }, z.core.$strict>, z.ZodObject<{
                    allowedReadAccess: z.ZodArray<z.ZodEnum<{
                        "public-read": "public-read";
                        "capability-read": "capability-read";
                        "private-network": "private-network";
                    }>>;
                    allowedContentProtection: z.ZodArray<z.ZodEnum<{
                        plaintext: "plaintext";
                        encrypted: "encrypted";
                        "selectively-disclosed": "selectively-disclosed";
                    }>>;
                    minimumCopies: z.ZodNumber;
                    minimumRetentionSeconds: z.ZodNumber;
                    unavailableBehavior: z.ZodEnum<{
                        "fail-closed": "fail-closed";
                        "degrade-read-only": "degrade-read-only";
                        "ignore-missing": "ignore-missing";
                    }>;
                    mode: z.ZodLiteral<"optional">;
                }, z.core.$strict>, z.ZodObject<{
                    minimumCopies: z.ZodNumber;
                    allowedReadAccess: z.ZodArray<z.ZodEnum<{
                        "public-read": "public-read";
                        "capability-read": "capability-read";
                        "private-network": "private-network";
                    }>>;
                    allowedContentProtection: z.ZodArray<z.ZodEnum<{
                        plaintext: "plaintext";
                        encrypted: "encrypted";
                        "selectively-disclosed": "selectively-disclosed";
                    }>>;
                    minimumRetentionSeconds: z.ZodNumber;
                    unavailableBehavior: z.ZodEnum<{
                        "fail-closed": "fail-closed";
                        "degrade-read-only": "degrade-read-only";
                        "ignore-missing": "ignore-missing";
                    }>;
                    mode: z.ZodLiteral<"required">;
                }, z.core.$strict>], "mode">;
                projection: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    profile: z.ZodLiteral<"none">;
                }, z.core.$strict>, z.ZodObject<{
                    profile: z.ZodEnum<{
                        ephemeral: "ephemeral";
                        "private-durable": "private-durable";
                        "public-served": "public-served";
                        "signed-publication": "signed-publication";
                    }>;
                    reducer: z.ZodObject<{
                        id: z.ZodString;
                        version: z.ZodNumber;
                    }, z.core.$strict>;
                    inputSchemas: z.ZodArray<z.ZodObject<{
                        schema: z.ZodString;
                        version: z.ZodNumber;
                    }, z.core.$strict>>;
                    temporality: z.ZodEnum<{
                        bounded: "bounded";
                        unbounded: "unbounded";
                    }>;
                    replayOrder: z.ZodLiteral<"forward">;
                    finalizedOnly: z.ZodLiteral<true>;
                    rebuildable: z.ZodLiteral<true>;
                    queryAccess: z.ZodEnum<{
                        "public-read": "public-read";
                        "capability-read": "capability-read";
                        "private-network": "private-network";
                    }>;
                    publication: z.ZodEnum<{
                        none: "none";
                        "query-service": "query-service";
                        "generation-head-last": "generation-head-last";
                    }>;
                    progressWatermark: z.ZodBoolean;
                }, z.core.$strict>], "profile">;
                auxiliaryStores: z.ZodArray<z.ZodObject<{
                    class: z.ZodEnum<{
                        secret: "secret";
                        "private-draft": "private-draft";
                        "effect-journal": "effect-journal";
                        "replay-checkpoint": "replay-checkpoint";
                        projection: "projection";
                        "disposable-cache": "disposable-cache";
                    }>;
                    requirement: z.ZodEnum<{
                        optional: "optional";
                        required: "required";
                    }>;
                    minimumDurability: z.ZodEnum<{
                        "host-ephemeral": "host-ephemeral";
                        "crash-durable": "crash-durable";
                    }>;
                }, z.core.$strict>>;
                consistency: z.ZodLiteral<"finalized">;
            }, z.core.$strict>;
            compatibility: z.ZodObject<{
                minimumHostProtocol: z.ZodString;
                acceptedPriorProtocolVersions: z.ZodArray<z.ZodString>;
            }, z.core.$strict>;
        }, z.core.$strict>;
        configuration: z.ZodObject<{
            applicationProviders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                instanceId: z.ZodString;
                artifactId: z.ZodString;
                descriptor: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                host: z.ZodString;
                config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
                dependencies: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
                    kind: z.ZodLiteral<"application-provider">;
                    instanceId: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    kind: z.ZodLiteral<"resource">;
                    resourceId: z.ZodString;
                }, z.core.$strict>], "kind">>;
            }, z.core.$strict>>>;
            schema: z.ZodLiteral<"network.xyo.dapp.configuration" & {
                readonly __schema: true;
            }>;
            schemaVersion: z.ZodLiteral<1>;
            dappId: z.ZodString;
            definitionVersion: z.ZodString;
            network: z.ZodObject<{
                networkId: z.ZodString;
                expectedChainId: z.ZodString;
            }, z.core.$strict>;
            actors: z.ZodArray<z.ZodObject<{
                instanceId: z.ZodString;
                roleId: z.ZodString;
                host: z.ZodString;
                executionMode: z.ZodEnum<{
                    "on-demand": "on-demand";
                    "event-driven": "event-driven";
                    scheduled: "scheduled";
                    resident: "resident";
                }>;
                config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
            }, z.core.$strict>>;
            supervision: z.ZodDiscriminatedUnion<[z.ZodObject<{
                policy: z.ZodLiteral<"sequential">;
                actorOrder: z.ZodArray<z.ZodString>;
            }, z.core.$strict>, z.ZodObject<{
                policy: z.ZodLiteral<"parallel">;
            }, z.core.$strict>], "policy">;
            providerBindings: z.ZodRecord<z.ZodString, z.ZodObject<{
                descriptorId: z.ZodString;
                config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
            }, z.core.$strict>>;
            identityBindings: z.ZodArray<z.ZodObject<{
                roleId: z.ZodString;
                capabilityId: z.ZodString;
                derivation: z.ZodOptional<z.ZodObject<{
                    algorithm: z.ZodLiteral<"bip44-secp256k1-v1">;
                    rootCapabilityId: z.ZodString;
                    fullPath: z.ZodString;
                    expectedAddress: z.ZodString;
                    networkScope: z.ZodString;
                    migration: z.ZodDiscriminatedUnion<[z.ZodObject<{
                        mode: z.ZodLiteral<"none">;
                    }, z.core.$strict>, z.ZodObject<{
                        mode: z.ZodLiteral<"rotate-from">;
                        predecessorAddress: z.ZodString;
                        authorization: z.ZodLiteral<"application-protocol">;
                    }, z.core.$strict>], "mode">;
                }, z.core.$strict>>;
            }, z.core.$strict>>;
            sideChannelPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                profile: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                unavailableBehavior: z.ZodLiteral<"continue-without-channel">;
                channelCapabilityId: z.ZodString;
                detachedSigningCapabilityId: z.ZodString;
                transport: z.ZodEnum<{
                    "in-memory": "in-memory";
                    "post-message": "post-message";
                    http: "http";
                    websocket: "websocket";
                    webrtc: "webrtc";
                    chatter: "chatter";
                }>;
                maximumMessageBytes: z.ZodNumber;
                replayRetentionSeconds: z.ZodNumber;
                acceptedClockSkewMilliseconds: z.ZodNumber;
                profile: z.ZodLiteral<"optional-optimization">;
            }, z.core.$strict>, z.ZodObject<{
                unavailableBehavior: z.ZodEnum<{
                    pending: "pending";
                    expire: "expire";
                    "fail-operation": "fail-operation";
                }>;
                channelCapabilityId: z.ZodString;
                detachedSigningCapabilityId: z.ZodString;
                transport: z.ZodEnum<{
                    "in-memory": "in-memory";
                    "post-message": "post-message";
                    http: "http";
                    websocket: "websocket";
                    webrtc: "webrtc";
                    chatter: "chatter";
                }>;
                maximumMessageBytes: z.ZodNumber;
                replayRetentionSeconds: z.ZodNumber;
                acceptedClockSkewMilliseconds: z.ZodNumber;
                profile: z.ZodLiteral<"required-for-liveness">;
            }, z.core.$strict>], "profile">;
            externalInteractionPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                mode: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"observe">;
                sources: z.ZodArray<z.ZodObject<{
                    sourceId: z.ZodString;
                    sourceKind: z.ZodEnum<{
                        api: "api";
                        "evm-chain": "evm-chain";
                        sensor: "sensor";
                        clock: "clock";
                        other: "other";
                    }>;
                    observerCapabilityId: z.ZodString;
                    config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
                }, z.core.$strict>>;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"attest-import">;
                sources: z.ZodArray<z.ZodObject<{
                    sourceId: z.ZodString;
                    sourceKind: z.ZodEnum<{
                        api: "api";
                        "evm-chain": "evm-chain";
                        sensor: "sensor";
                        clock: "clock";
                        other: "other";
                    }>;
                    observerCapabilityId: z.ZodString;
                    config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
                }, z.core.$strict>>;
                commitBeforeReduction: z.ZodLiteral<true>;
            }, z.core.$strict>], "mode">;
            datalakePolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                mode: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"optional">;
                readAccess: z.ZodEnum<{
                    "public-read": "public-read";
                    "capability-read": "capability-read";
                    "private-network": "private-network";
                }>;
                contentProtection: z.ZodEnum<{
                    plaintext: "plaintext";
                    encrypted: "encrypted";
                    "selectively-disclosed": "selectively-disclosed";
                }>;
                writeBeforeBroadcast: z.ZodBoolean;
                requiredCopies: z.ZodNumber;
                retentionSeconds: z.ZodNumber;
                unavailableBehavior: z.ZodEnum<{
                    "fail-closed": "fail-closed";
                    "degrade-read-only": "degrade-read-only";
                    "ignore-missing": "ignore-missing";
                }>;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"required">;
                readAccess: z.ZodEnum<{
                    "public-read": "public-read";
                    "capability-read": "capability-read";
                    "private-network": "private-network";
                }>;
                contentProtection: z.ZodEnum<{
                    plaintext: "plaintext";
                    encrypted: "encrypted";
                    "selectively-disclosed": "selectively-disclosed";
                }>;
                writeBeforeBroadcast: z.ZodLiteral<true>;
                requiredCopies: z.ZodNumber;
                retentionSeconds: z.ZodNumber;
                unavailableBehavior: z.ZodEnum<{
                    "fail-closed": "fail-closed";
                    "degrade-read-only": "degrade-read-only";
                    "ignore-missing": "ignore-missing";
                }>;
            }, z.core.$strict>], "mode">;
            auxiliaryStores: z.ZodArray<z.ZodObject<{
                class: z.ZodEnum<{
                    secret: "secret";
                    "private-draft": "private-draft";
                    "effect-journal": "effect-journal";
                    "replay-checkpoint": "replay-checkpoint";
                    projection: "projection";
                    "disposable-cache": "disposable-cache";
                }>;
                capabilityId: z.ZodString;
                durability: z.ZodEnum<{
                    "host-ephemeral": "host-ephemeral";
                    "crash-durable": "crash-durable";
                }>;
            }, z.core.$strict>>;
            projectionPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                profile: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                projectionCapabilityId: z.ZodString;
                floor: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    mode: z.ZodLiteral<"bounded">;
                    block: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    mode: z.ZodLiteral<"genesis">;
                    block: z.ZodLiteral<0>;
                }, z.core.$strict>], "mode">;
                maximumLagBlocks: z.ZodNumber;
                progressWatermark: z.ZodBoolean;
                profile: z.ZodLiteral<"ephemeral">;
            }, z.core.$strict>, z.ZodObject<{
                checkpointCapabilityId: z.ZodString;
                projectionCapabilityId: z.ZodString;
                floor: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    mode: z.ZodLiteral<"bounded">;
                    block: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    mode: z.ZodLiteral<"genesis">;
                    block: z.ZodLiteral<0>;
                }, z.core.$strict>], "mode">;
                maximumLagBlocks: z.ZodNumber;
                progressWatermark: z.ZodBoolean;
                profile: z.ZodEnum<{
                    "private-durable": "private-durable";
                    "public-served": "public-served";
                    "signed-publication": "signed-publication";
                }>;
            }, z.core.$strict>], "profile">;
            consistency: z.ZodObject<{
                read: z.ZodLiteral<"finalized">;
                readinessMaxLag: z.ZodNumber;
            }, z.core.$strict>;
        }, z.core.$strict>;
        actorDescriptors: z.ZodArray<z.ZodObject<{
            descriptor: z.ZodObject<{
                id: z.ZodString;
                version: z.ZodNumber;
            }, z.core.$strict>;
            configSchemaHash: z.ZodString;
            implementationHash: z.ZodString;
        }, z.core.$strict>>;
        resolvedProviders: z.ZodArray<z.ZodObject<{
            instanceId: z.ZodString;
            descriptor: z.ZodObject<{
                descriptor: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                configSchemaHash: z.ZodString;
                implementationHash: z.ZodString;
            }, z.core.$strict>;
            config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
            providedCapabilities: z.ZodArray<z.ZodObject<{
                moniker: z.ZodString;
                version: z.ZodNumber;
            }, z.core.$strict>>;
            dependencies: z.ZodArray<z.ZodString>;
        }, z.core.$strict>>;
        portBindings: z.ZodArray<z.ZodObject<{
            portId: z.ZodString;
            host: z.ZodString;
        }, z.core.$strict>>;
        hostPartitions: z.ZodArray<z.ZodObject<{
            host: z.ZodString;
            actorInstanceIds: z.ZodArray<z.ZodString>;
            portIds: z.ZodArray<z.ZodString>;
        }, z.core.$strict>>;
        planId: z.ZodString;
    }, z.core.$strict>;
    source: z.ZodPipe<z.ZodObject<{
        remote: z.ZodOptional<z.ZodString>;
        commit: z.ZodString;
        worktree: z.ZodEnum<{
            clean: "clean";
            dirty: "dirty";
        }>;
        buildInputHash: z.ZodString;
    }, z.core.$strict>, z.ZodTransform<{
        commit: string;
        worktree: "clean" | "dirty";
        buildInputHash: string;
    } | {
        remote: string;
        commit: string;
        worktree: "clean" | "dirty";
        buildInputHash: string;
    }, {
        commit: string;
        worktree: "clean" | "dirty";
        buildInputHash: string;
        remote?: string | undefined;
    }>>;
    packageManager: z.ZodObject<{
        name: z.ZodEnum<{
            pnpm: "pnpm";
            npm: "npm";
            yarn: "yarn";
        }>;
        version: z.ZodString;
        lockfileHash: z.ZodString;
    }, z.core.$strict>;
    environment: z.ZodObject<{
        catalogId: z.ZodString;
        catalogVersion: z.ZodString;
    }, z.core.$strict>;
    resources: z.ZodArray<z.ZodObject<{
        resourceId: z.ZodString;
        resourceClass: z.ZodEnum<{
            secret: "secret";
            "effect-journal": "effect-journal";
            datalake: "datalake";
            "xl1-network": "xl1-network";
            "projection-store": "projection-store";
            "checkpoint-store": "checkpoint-store";
            identity: "identity";
            "side-channel": "side-channel";
            "external-source": "external-source";
            "event-stream": "event-stream";
            "event-subscription": "event-subscription";
        }>;
        provision: z.ZodEnum<{
            external: "external";
            "managed-local": "managed-local";
            managed: "managed";
        }>;
        persistence: z.ZodEnum<{
            ephemeral: "ephemeral";
            external: "external";
            retained: "retained";
        }>;
        adapterId: z.ZodString;
        adapterVersion: z.ZodString;
        dependencies: z.ZodArray<z.ZodString>;
        providerInstanceId: z.ZodOptional<z.ZodString>;
        providerDescriptor: z.ZodObject<{
            descriptor: z.ZodObject<{
                id: z.ZodString;
                version: z.ZodNumber;
            }, z.core.$strict>;
            configSchemaHash: z.ZodString;
            implementationHash: z.ZodString;
        }, z.core.$strict>;
        providerConfig: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
    }, z.core.$strict>>;
    artifacts: z.ZodArray<z.ZodObject<{
        artifactId: z.ZodString;
        artifactManifestHash: z.ZodString;
        contentRoot: z.ZodString;
    }, z.core.$strict>>;
    promotable: z.ZodBoolean;
}, z.core.$strict>;
export type DappDeploymentLockV3Preimage = z.infer<typeof DappDeploymentLockV3PreimageZod>;
export declare const DappDeploymentLockV3Zod: z.ZodObject<{
    schema: z.ZodLiteral<"network.xyo.dapp.deployment.lock" & {
        readonly __schema: true;
    }>;
    schemaVersion: z.ZodLiteral<3>;
    hashAlgorithm: z.ZodLiteral<"jcs-sha256-v1">;
    project: z.ZodObject<{
        schemaVersion: z.ZodLiteral<1>;
        projectHash: z.ZodString;
    }, z.core.$strict>;
    deployment: z.ZodObject<{
        name: z.ZodString;
        requestHash: z.ZodString;
        manifest: z.ZodObject<{
            schemaVersion: z.ZodLiteral<2>;
            deploymentManifestId: z.ZodString;
        }, z.core.$strict>;
        intent: z.ZodObject<{
            schemaVersion: z.ZodLiteral<1>;
            deploymentIntentId: z.ZodString;
        }, z.core.$strict>;
    }, z.core.$strict>;
    things: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"website">;
        artifactId: z.ZodString;
        exposure: z.ZodEnum<{
            public: "public";
            private: "private";
        }>;
        routes: z.ZodArray<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"api">;
        artifactId: z.ZodString;
        ports: z.ZodArray<z.ZodString>;
        routes: z.ZodArray<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"datalake">;
        resourceId: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"event-ingress">;
        artifactId: z.ZodString;
        eventStreamResource: z.ZodString;
        routes: z.ZodArray<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"event-stream">;
        resourceId: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"subscription-runner">;
        subscriptionResource: z.ZodString;
        consumerActor: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"indexer">;
        subscriptionResource: z.ZodString;
        consumerActor: z.ZodString;
        projectionResource: z.ZodString;
        checkpointResource: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"controller">;
        subscriptionResource: z.ZodString;
        consumerActor: z.ZodString;
        effectJournalResource: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"publisher">;
        subscriptionResource: z.ZodString;
        consumerActor: z.ZodString;
        publicationResources: z.ZodArray<z.ZodString>;
    }, z.core.$strict>], "kind">>;
    placements: z.ZodObject<{
        things: z.ZodArray<z.ZodObject<{
            thingId: z.ZodString;
            infrastructureId: z.ZodString;
        }, z.core.$strict>>;
        resources: z.ZodArray<z.ZodObject<{
            resourceId: z.ZodString;
            infrastructureId: z.ZodString;
        }, z.core.$strict>>;
        hosts: z.ZodArray<z.ZodObject<{
            hostPartitionId: z.ZodString;
            infrastructureId: z.ZodString;
        }, z.core.$strict>>;
    }, z.core.$strict>;
    infrastructure: z.ZodArray<z.ZodObject<{
        infrastructureId: z.ZodString;
        kind: z.ZodEnum<{
            vercel: "vercel";
            cloudflare: "cloudflare";
            kubernetes: "kubernetes";
            proxmox: "proxmox";
        }>;
        adapterId: z.ZodString;
        adapterVersion: z.ZodString;
        adapterDescriptorHash: z.ZodString;
        infrastructureDescriptorHash: z.ZodString;
        infrastructurePolicyHash: z.ZodString;
        expectedScopeCommitment: z.ZodString;
    }, z.core.$strict>>;
    definitionHash: z.ZodString;
    configurationHash: z.ZodString;
    configuration: z.ZodObject<{
        applicationProviders: z.ZodOptional<z.ZodArray<z.ZodObject<{
            instanceId: z.ZodString;
            artifactId: z.ZodString;
            descriptor: z.ZodObject<{
                id: z.ZodString;
                version: z.ZodNumber;
            }, z.core.$strict>;
            host: z.ZodString;
            config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
            dependencies: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"application-provider">;
                instanceId: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"resource">;
                resourceId: z.ZodString;
            }, z.core.$strict>], "kind">>;
        }, z.core.$strict>>>;
        schema: z.ZodLiteral<"network.xyo.dapp.configuration" & {
            readonly __schema: true;
        }>;
        schemaVersion: z.ZodLiteral<1>;
        dappId: z.ZodString;
        definitionVersion: z.ZodString;
        network: z.ZodObject<{
            networkId: z.ZodString;
            expectedChainId: z.ZodString;
        }, z.core.$strict>;
        actors: z.ZodArray<z.ZodObject<{
            instanceId: z.ZodString;
            roleId: z.ZodString;
            host: z.ZodString;
            executionMode: z.ZodEnum<{
                "on-demand": "on-demand";
                "event-driven": "event-driven";
                scheduled: "scheduled";
                resident: "resident";
            }>;
            config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
        }, z.core.$strict>>;
        supervision: z.ZodDiscriminatedUnion<[z.ZodObject<{
            policy: z.ZodLiteral<"sequential">;
            actorOrder: z.ZodArray<z.ZodString>;
        }, z.core.$strict>, z.ZodObject<{
            policy: z.ZodLiteral<"parallel">;
        }, z.core.$strict>], "policy">;
        providerBindings: z.ZodRecord<z.ZodString, z.ZodObject<{
            descriptorId: z.ZodString;
            config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
        }, z.core.$strict>>;
        identityBindings: z.ZodArray<z.ZodObject<{
            roleId: z.ZodString;
            capabilityId: z.ZodString;
            derivation: z.ZodOptional<z.ZodObject<{
                algorithm: z.ZodLiteral<"bip44-secp256k1-v1">;
                rootCapabilityId: z.ZodString;
                fullPath: z.ZodString;
                expectedAddress: z.ZodString;
                networkScope: z.ZodString;
                migration: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    mode: z.ZodLiteral<"none">;
                }, z.core.$strict>, z.ZodObject<{
                    mode: z.ZodLiteral<"rotate-from">;
                    predecessorAddress: z.ZodString;
                    authorization: z.ZodLiteral<"application-protocol">;
                }, z.core.$strict>], "mode">;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
        sideChannelPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
            profile: z.ZodLiteral<"none">;
        }, z.core.$strict>, z.ZodObject<{
            unavailableBehavior: z.ZodLiteral<"continue-without-channel">;
            channelCapabilityId: z.ZodString;
            detachedSigningCapabilityId: z.ZodString;
            transport: z.ZodEnum<{
                "in-memory": "in-memory";
                "post-message": "post-message";
                http: "http";
                websocket: "websocket";
                webrtc: "webrtc";
                chatter: "chatter";
            }>;
            maximumMessageBytes: z.ZodNumber;
            replayRetentionSeconds: z.ZodNumber;
            acceptedClockSkewMilliseconds: z.ZodNumber;
            profile: z.ZodLiteral<"optional-optimization">;
        }, z.core.$strict>, z.ZodObject<{
            unavailableBehavior: z.ZodEnum<{
                pending: "pending";
                expire: "expire";
                "fail-operation": "fail-operation";
            }>;
            channelCapabilityId: z.ZodString;
            detachedSigningCapabilityId: z.ZodString;
            transport: z.ZodEnum<{
                "in-memory": "in-memory";
                "post-message": "post-message";
                http: "http";
                websocket: "websocket";
                webrtc: "webrtc";
                chatter: "chatter";
            }>;
            maximumMessageBytes: z.ZodNumber;
            replayRetentionSeconds: z.ZodNumber;
            acceptedClockSkewMilliseconds: z.ZodNumber;
            profile: z.ZodLiteral<"required-for-liveness">;
        }, z.core.$strict>], "profile">;
        externalInteractionPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
            mode: z.ZodLiteral<"none">;
        }, z.core.$strict>, z.ZodObject<{
            mode: z.ZodLiteral<"observe">;
            sources: z.ZodArray<z.ZodObject<{
                sourceId: z.ZodString;
                sourceKind: z.ZodEnum<{
                    api: "api";
                    "evm-chain": "evm-chain";
                    sensor: "sensor";
                    clock: "clock";
                    other: "other";
                }>;
                observerCapabilityId: z.ZodString;
                config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
            }, z.core.$strict>>;
        }, z.core.$strict>, z.ZodObject<{
            mode: z.ZodLiteral<"attest-import">;
            sources: z.ZodArray<z.ZodObject<{
                sourceId: z.ZodString;
                sourceKind: z.ZodEnum<{
                    api: "api";
                    "evm-chain": "evm-chain";
                    sensor: "sensor";
                    clock: "clock";
                    other: "other";
                }>;
                observerCapabilityId: z.ZodString;
                config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
            }, z.core.$strict>>;
            commitBeforeReduction: z.ZodLiteral<true>;
        }, z.core.$strict>], "mode">;
        datalakePolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
            mode: z.ZodLiteral<"none">;
        }, z.core.$strict>, z.ZodObject<{
            mode: z.ZodLiteral<"optional">;
            readAccess: z.ZodEnum<{
                "public-read": "public-read";
                "capability-read": "capability-read";
                "private-network": "private-network";
            }>;
            contentProtection: z.ZodEnum<{
                plaintext: "plaintext";
                encrypted: "encrypted";
                "selectively-disclosed": "selectively-disclosed";
            }>;
            writeBeforeBroadcast: z.ZodBoolean;
            requiredCopies: z.ZodNumber;
            retentionSeconds: z.ZodNumber;
            unavailableBehavior: z.ZodEnum<{
                "fail-closed": "fail-closed";
                "degrade-read-only": "degrade-read-only";
                "ignore-missing": "ignore-missing";
            }>;
        }, z.core.$strict>, z.ZodObject<{
            mode: z.ZodLiteral<"required">;
            readAccess: z.ZodEnum<{
                "public-read": "public-read";
                "capability-read": "capability-read";
                "private-network": "private-network";
            }>;
            contentProtection: z.ZodEnum<{
                plaintext: "plaintext";
                encrypted: "encrypted";
                "selectively-disclosed": "selectively-disclosed";
            }>;
            writeBeforeBroadcast: z.ZodLiteral<true>;
            requiredCopies: z.ZodNumber;
            retentionSeconds: z.ZodNumber;
            unavailableBehavior: z.ZodEnum<{
                "fail-closed": "fail-closed";
                "degrade-read-only": "degrade-read-only";
                "ignore-missing": "ignore-missing";
            }>;
        }, z.core.$strict>], "mode">;
        auxiliaryStores: z.ZodArray<z.ZodObject<{
            class: z.ZodEnum<{
                secret: "secret";
                "private-draft": "private-draft";
                "effect-journal": "effect-journal";
                "replay-checkpoint": "replay-checkpoint";
                projection: "projection";
                "disposable-cache": "disposable-cache";
            }>;
            capabilityId: z.ZodString;
            durability: z.ZodEnum<{
                "host-ephemeral": "host-ephemeral";
                "crash-durable": "crash-durable";
            }>;
        }, z.core.$strict>>;
        projectionPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
            profile: z.ZodLiteral<"none">;
        }, z.core.$strict>, z.ZodObject<{
            projectionCapabilityId: z.ZodString;
            floor: z.ZodDiscriminatedUnion<[z.ZodObject<{
                mode: z.ZodLiteral<"bounded">;
                block: z.ZodNumber;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"genesis">;
                block: z.ZodLiteral<0>;
            }, z.core.$strict>], "mode">;
            maximumLagBlocks: z.ZodNumber;
            progressWatermark: z.ZodBoolean;
            profile: z.ZodLiteral<"ephemeral">;
        }, z.core.$strict>, z.ZodObject<{
            checkpointCapabilityId: z.ZodString;
            projectionCapabilityId: z.ZodString;
            floor: z.ZodDiscriminatedUnion<[z.ZodObject<{
                mode: z.ZodLiteral<"bounded">;
                block: z.ZodNumber;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"genesis">;
                block: z.ZodLiteral<0>;
            }, z.core.$strict>], "mode">;
            maximumLagBlocks: z.ZodNumber;
            progressWatermark: z.ZodBoolean;
            profile: z.ZodEnum<{
                "private-durable": "private-durable";
                "public-served": "public-served";
                "signed-publication": "signed-publication";
            }>;
        }, z.core.$strict>], "profile">;
        consistency: z.ZodObject<{
            read: z.ZodLiteral<"finalized">;
            readinessMaxLag: z.ZodNumber;
        }, z.core.$strict>;
    }, z.core.$strict>;
    plan: z.ZodObject<{
        schema: z.ZodLiteral<"network.xyo.dapp.plan" & {
            readonly __schema: true;
        }>;
        schemaVersion: z.ZodLiteral<1>;
        definitionHash: z.ZodString;
        configurationHash: z.ZodString;
        definition: z.ZodObject<{
            schema: z.ZodLiteral<"network.xyo.dapp.definition" & {
                readonly __schema: true;
            }>;
            schemaVersion: z.ZodLiteral<1>;
            dappId: z.ZodString;
            definitionVersion: z.ZodString;
            protocolVersion: z.ZodString;
            substrate: z.ZodObject<{
                canonicalSource: z.ZodLiteral<"xl1-finalized">;
                relationships: z.ZodArray<z.ZodEnum<{
                    "consumes-finalized": "consumes-finalized";
                    "projects-finalized": "projects-finalized";
                    "bridges-external": "bridges-external";
                }>>;
            }, z.core.$strict>;
            schemas: z.ZodArray<z.ZodObject<{
                schema: z.ZodString;
                version: z.ZodNumber;
            }, z.core.$strict>>;
            actors: z.ZodArray<z.ZodObject<{
                roleId: z.ZodString;
                descriptor: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                supportedExecutionModes: z.ZodArray<z.ZodEnum<{
                    "on-demand": "on-demand";
                    "event-driven": "event-driven";
                    scheduled: "scheduled";
                    resident: "resident";
                }>>;
                effectAuthority: z.ZodEnum<{
                    "read-only": "read-only";
                    "user-mediated": "user-mediated";
                    "service-authorized": "service-authorized";
                    "multi-party": "multi-party";
                }>;
                requiredCapabilities: z.ZodArray<z.ZodObject<{
                    moniker: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>>;
            }, z.core.$strict>>;
            ports: z.ZodArray<z.ZodObject<{
                portId: z.ZodString;
                version: z.ZodString;
                commands: z.ZodArray<z.ZodString>;
                queries: z.ZodArray<z.ZodString>;
                subscriptions: z.ZodArray<z.ZodString>;
            }, z.core.$strict>>;
            identityRoles: z.ZodArray<z.ZodString>;
            coordination: z.ZodDiscriminatedUnion<[z.ZodObject<{
                profile: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                messageKinds: z.ZodArray<z.ZodEnum<{
                    ephemeral: "ephemeral";
                    proposal: "proposal";
                    attestation: "attestation";
                    "projection-hint": "projection-hint";
                }>>;
                authorizedSenderRoles: z.ZodArray<z.ZodString>;
                delivery: z.ZodLiteral<"unordered-at-least-once">;
                historyCanonical: z.ZodLiteral<false>;
                detachedSignatures: z.ZodLiteral<true>;
                maximumMessageBytes: z.ZodNumber;
                minimumReplayRetentionSeconds: z.ZodNumber;
                maximumClockSkewMilliseconds: z.ZodNumber;
                profile: z.ZodLiteral<"optional-optimization">;
            }, z.core.$strict>, z.ZodObject<{
                messageKinds: z.ZodArray<z.ZodEnum<{
                    ephemeral: "ephemeral";
                    proposal: "proposal";
                    attestation: "attestation";
                    "projection-hint": "projection-hint";
                }>>;
                authorizedSenderRoles: z.ZodArray<z.ZodString>;
                delivery: z.ZodLiteral<"unordered-at-least-once">;
                historyCanonical: z.ZodLiteral<false>;
                detachedSignatures: z.ZodLiteral<true>;
                maximumMessageBytes: z.ZodNumber;
                minimumReplayRetentionSeconds: z.ZodNumber;
                maximumClockSkewMilliseconds: z.ZodNumber;
                profile: z.ZodLiteral<"required-for-liveness">;
            }, z.core.$strict>], "profile">;
            externalInteraction: z.ZodDiscriminatedUnion<[z.ZodObject<{
                mode: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                allowedSourceKinds: z.ZodArray<z.ZodEnum<{
                    api: "api";
                    "evm-chain": "evm-chain";
                    sensor: "sensor";
                    clock: "clock";
                    other: "other";
                }>>;
                provenancePolicy: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                finalityPolicy: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                mode: z.ZodLiteral<"observe">;
            }, z.core.$strict>, z.ZodObject<{
                observationSchemas: z.ZodArray<z.ZodObject<{
                    schema: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>>;
                commitBeforeReduction: z.ZodLiteral<true>;
                allowedSourceKinds: z.ZodArray<z.ZodEnum<{
                    api: "api";
                    "evm-chain": "evm-chain";
                    sensor: "sensor";
                    clock: "clock";
                    other: "other";
                }>>;
                provenancePolicy: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                finalityPolicy: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                mode: z.ZodLiteral<"attest-import">;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"actuate-export">;
                effectFamily: z.ZodString;
            }, z.core.$strict>], "mode">;
            durability: z.ZodObject<{
                contentMode: z.ZodEnum<{
                    "chain-only": "chain-only";
                    "commitment-only": "commitment-only";
                    "datalake-backed": "datalake-backed";
                }>;
                datalake: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    mode: z.ZodLiteral<"none">;
                }, z.core.$strict>, z.ZodObject<{
                    allowedReadAccess: z.ZodArray<z.ZodEnum<{
                        "public-read": "public-read";
                        "capability-read": "capability-read";
                        "private-network": "private-network";
                    }>>;
                    allowedContentProtection: z.ZodArray<z.ZodEnum<{
                        plaintext: "plaintext";
                        encrypted: "encrypted";
                        "selectively-disclosed": "selectively-disclosed";
                    }>>;
                    minimumCopies: z.ZodNumber;
                    minimumRetentionSeconds: z.ZodNumber;
                    unavailableBehavior: z.ZodEnum<{
                        "fail-closed": "fail-closed";
                        "degrade-read-only": "degrade-read-only";
                        "ignore-missing": "ignore-missing";
                    }>;
                    mode: z.ZodLiteral<"optional">;
                }, z.core.$strict>, z.ZodObject<{
                    minimumCopies: z.ZodNumber;
                    allowedReadAccess: z.ZodArray<z.ZodEnum<{
                        "public-read": "public-read";
                        "capability-read": "capability-read";
                        "private-network": "private-network";
                    }>>;
                    allowedContentProtection: z.ZodArray<z.ZodEnum<{
                        plaintext: "plaintext";
                        encrypted: "encrypted";
                        "selectively-disclosed": "selectively-disclosed";
                    }>>;
                    minimumRetentionSeconds: z.ZodNumber;
                    unavailableBehavior: z.ZodEnum<{
                        "fail-closed": "fail-closed";
                        "degrade-read-only": "degrade-read-only";
                        "ignore-missing": "ignore-missing";
                    }>;
                    mode: z.ZodLiteral<"required">;
                }, z.core.$strict>], "mode">;
                projection: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    profile: z.ZodLiteral<"none">;
                }, z.core.$strict>, z.ZodObject<{
                    profile: z.ZodEnum<{
                        ephemeral: "ephemeral";
                        "private-durable": "private-durable";
                        "public-served": "public-served";
                        "signed-publication": "signed-publication";
                    }>;
                    reducer: z.ZodObject<{
                        id: z.ZodString;
                        version: z.ZodNumber;
                    }, z.core.$strict>;
                    inputSchemas: z.ZodArray<z.ZodObject<{
                        schema: z.ZodString;
                        version: z.ZodNumber;
                    }, z.core.$strict>>;
                    temporality: z.ZodEnum<{
                        bounded: "bounded";
                        unbounded: "unbounded";
                    }>;
                    replayOrder: z.ZodLiteral<"forward">;
                    finalizedOnly: z.ZodLiteral<true>;
                    rebuildable: z.ZodLiteral<true>;
                    queryAccess: z.ZodEnum<{
                        "public-read": "public-read";
                        "capability-read": "capability-read";
                        "private-network": "private-network";
                    }>;
                    publication: z.ZodEnum<{
                        none: "none";
                        "query-service": "query-service";
                        "generation-head-last": "generation-head-last";
                    }>;
                    progressWatermark: z.ZodBoolean;
                }, z.core.$strict>], "profile">;
                auxiliaryStores: z.ZodArray<z.ZodObject<{
                    class: z.ZodEnum<{
                        secret: "secret";
                        "private-draft": "private-draft";
                        "effect-journal": "effect-journal";
                        "replay-checkpoint": "replay-checkpoint";
                        projection: "projection";
                        "disposable-cache": "disposable-cache";
                    }>;
                    requirement: z.ZodEnum<{
                        optional: "optional";
                        required: "required";
                    }>;
                    minimumDurability: z.ZodEnum<{
                        "host-ephemeral": "host-ephemeral";
                        "crash-durable": "crash-durable";
                    }>;
                }, z.core.$strict>>;
                consistency: z.ZodLiteral<"finalized">;
            }, z.core.$strict>;
            compatibility: z.ZodObject<{
                minimumHostProtocol: z.ZodString;
                acceptedPriorProtocolVersions: z.ZodArray<z.ZodString>;
            }, z.core.$strict>;
        }, z.core.$strict>;
        configuration: z.ZodObject<{
            applicationProviders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                instanceId: z.ZodString;
                artifactId: z.ZodString;
                descriptor: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                host: z.ZodString;
                config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
                dependencies: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
                    kind: z.ZodLiteral<"application-provider">;
                    instanceId: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    kind: z.ZodLiteral<"resource">;
                    resourceId: z.ZodString;
                }, z.core.$strict>], "kind">>;
            }, z.core.$strict>>>;
            schema: z.ZodLiteral<"network.xyo.dapp.configuration" & {
                readonly __schema: true;
            }>;
            schemaVersion: z.ZodLiteral<1>;
            dappId: z.ZodString;
            definitionVersion: z.ZodString;
            network: z.ZodObject<{
                networkId: z.ZodString;
                expectedChainId: z.ZodString;
            }, z.core.$strict>;
            actors: z.ZodArray<z.ZodObject<{
                instanceId: z.ZodString;
                roleId: z.ZodString;
                host: z.ZodString;
                executionMode: z.ZodEnum<{
                    "on-demand": "on-demand";
                    "event-driven": "event-driven";
                    scheduled: "scheduled";
                    resident: "resident";
                }>;
                config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
            }, z.core.$strict>>;
            supervision: z.ZodDiscriminatedUnion<[z.ZodObject<{
                policy: z.ZodLiteral<"sequential">;
                actorOrder: z.ZodArray<z.ZodString>;
            }, z.core.$strict>, z.ZodObject<{
                policy: z.ZodLiteral<"parallel">;
            }, z.core.$strict>], "policy">;
            providerBindings: z.ZodRecord<z.ZodString, z.ZodObject<{
                descriptorId: z.ZodString;
                config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
            }, z.core.$strict>>;
            identityBindings: z.ZodArray<z.ZodObject<{
                roleId: z.ZodString;
                capabilityId: z.ZodString;
                derivation: z.ZodOptional<z.ZodObject<{
                    algorithm: z.ZodLiteral<"bip44-secp256k1-v1">;
                    rootCapabilityId: z.ZodString;
                    fullPath: z.ZodString;
                    expectedAddress: z.ZodString;
                    networkScope: z.ZodString;
                    migration: z.ZodDiscriminatedUnion<[z.ZodObject<{
                        mode: z.ZodLiteral<"none">;
                    }, z.core.$strict>, z.ZodObject<{
                        mode: z.ZodLiteral<"rotate-from">;
                        predecessorAddress: z.ZodString;
                        authorization: z.ZodLiteral<"application-protocol">;
                    }, z.core.$strict>], "mode">;
                }, z.core.$strict>>;
            }, z.core.$strict>>;
            sideChannelPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                profile: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                unavailableBehavior: z.ZodLiteral<"continue-without-channel">;
                channelCapabilityId: z.ZodString;
                detachedSigningCapabilityId: z.ZodString;
                transport: z.ZodEnum<{
                    "in-memory": "in-memory";
                    "post-message": "post-message";
                    http: "http";
                    websocket: "websocket";
                    webrtc: "webrtc";
                    chatter: "chatter";
                }>;
                maximumMessageBytes: z.ZodNumber;
                replayRetentionSeconds: z.ZodNumber;
                acceptedClockSkewMilliseconds: z.ZodNumber;
                profile: z.ZodLiteral<"optional-optimization">;
            }, z.core.$strict>, z.ZodObject<{
                unavailableBehavior: z.ZodEnum<{
                    pending: "pending";
                    expire: "expire";
                    "fail-operation": "fail-operation";
                }>;
                channelCapabilityId: z.ZodString;
                detachedSigningCapabilityId: z.ZodString;
                transport: z.ZodEnum<{
                    "in-memory": "in-memory";
                    "post-message": "post-message";
                    http: "http";
                    websocket: "websocket";
                    webrtc: "webrtc";
                    chatter: "chatter";
                }>;
                maximumMessageBytes: z.ZodNumber;
                replayRetentionSeconds: z.ZodNumber;
                acceptedClockSkewMilliseconds: z.ZodNumber;
                profile: z.ZodLiteral<"required-for-liveness">;
            }, z.core.$strict>], "profile">;
            externalInteractionPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                mode: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"observe">;
                sources: z.ZodArray<z.ZodObject<{
                    sourceId: z.ZodString;
                    sourceKind: z.ZodEnum<{
                        api: "api";
                        "evm-chain": "evm-chain";
                        sensor: "sensor";
                        clock: "clock";
                        other: "other";
                    }>;
                    observerCapabilityId: z.ZodString;
                    config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
                }, z.core.$strict>>;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"attest-import">;
                sources: z.ZodArray<z.ZodObject<{
                    sourceId: z.ZodString;
                    sourceKind: z.ZodEnum<{
                        api: "api";
                        "evm-chain": "evm-chain";
                        sensor: "sensor";
                        clock: "clock";
                        other: "other";
                    }>;
                    observerCapabilityId: z.ZodString;
                    config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
                }, z.core.$strict>>;
                commitBeforeReduction: z.ZodLiteral<true>;
            }, z.core.$strict>], "mode">;
            datalakePolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                mode: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"optional">;
                readAccess: z.ZodEnum<{
                    "public-read": "public-read";
                    "capability-read": "capability-read";
                    "private-network": "private-network";
                }>;
                contentProtection: z.ZodEnum<{
                    plaintext: "plaintext";
                    encrypted: "encrypted";
                    "selectively-disclosed": "selectively-disclosed";
                }>;
                writeBeforeBroadcast: z.ZodBoolean;
                requiredCopies: z.ZodNumber;
                retentionSeconds: z.ZodNumber;
                unavailableBehavior: z.ZodEnum<{
                    "fail-closed": "fail-closed";
                    "degrade-read-only": "degrade-read-only";
                    "ignore-missing": "ignore-missing";
                }>;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"required">;
                readAccess: z.ZodEnum<{
                    "public-read": "public-read";
                    "capability-read": "capability-read";
                    "private-network": "private-network";
                }>;
                contentProtection: z.ZodEnum<{
                    plaintext: "plaintext";
                    encrypted: "encrypted";
                    "selectively-disclosed": "selectively-disclosed";
                }>;
                writeBeforeBroadcast: z.ZodLiteral<true>;
                requiredCopies: z.ZodNumber;
                retentionSeconds: z.ZodNumber;
                unavailableBehavior: z.ZodEnum<{
                    "fail-closed": "fail-closed";
                    "degrade-read-only": "degrade-read-only";
                    "ignore-missing": "ignore-missing";
                }>;
            }, z.core.$strict>], "mode">;
            auxiliaryStores: z.ZodArray<z.ZodObject<{
                class: z.ZodEnum<{
                    secret: "secret";
                    "private-draft": "private-draft";
                    "effect-journal": "effect-journal";
                    "replay-checkpoint": "replay-checkpoint";
                    projection: "projection";
                    "disposable-cache": "disposable-cache";
                }>;
                capabilityId: z.ZodString;
                durability: z.ZodEnum<{
                    "host-ephemeral": "host-ephemeral";
                    "crash-durable": "crash-durable";
                }>;
            }, z.core.$strict>>;
            projectionPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                profile: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                projectionCapabilityId: z.ZodString;
                floor: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    mode: z.ZodLiteral<"bounded">;
                    block: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    mode: z.ZodLiteral<"genesis">;
                    block: z.ZodLiteral<0>;
                }, z.core.$strict>], "mode">;
                maximumLagBlocks: z.ZodNumber;
                progressWatermark: z.ZodBoolean;
                profile: z.ZodLiteral<"ephemeral">;
            }, z.core.$strict>, z.ZodObject<{
                checkpointCapabilityId: z.ZodString;
                projectionCapabilityId: z.ZodString;
                floor: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    mode: z.ZodLiteral<"bounded">;
                    block: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    mode: z.ZodLiteral<"genesis">;
                    block: z.ZodLiteral<0>;
                }, z.core.$strict>], "mode">;
                maximumLagBlocks: z.ZodNumber;
                progressWatermark: z.ZodBoolean;
                profile: z.ZodEnum<{
                    "private-durable": "private-durable";
                    "public-served": "public-served";
                    "signed-publication": "signed-publication";
                }>;
            }, z.core.$strict>], "profile">;
            consistency: z.ZodObject<{
                read: z.ZodLiteral<"finalized">;
                readinessMaxLag: z.ZodNumber;
            }, z.core.$strict>;
        }, z.core.$strict>;
        actorDescriptors: z.ZodArray<z.ZodObject<{
            descriptor: z.ZodObject<{
                id: z.ZodString;
                version: z.ZodNumber;
            }, z.core.$strict>;
            configSchemaHash: z.ZodString;
            implementationHash: z.ZodString;
        }, z.core.$strict>>;
        resolvedProviders: z.ZodArray<z.ZodObject<{
            instanceId: z.ZodString;
            descriptor: z.ZodObject<{
                descriptor: z.ZodObject<{
                    id: z.ZodString;
                    version: z.ZodNumber;
                }, z.core.$strict>;
                configSchemaHash: z.ZodString;
                implementationHash: z.ZodString;
            }, z.core.$strict>;
            config: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
            providedCapabilities: z.ZodArray<z.ZodObject<{
                moniker: z.ZodString;
                version: z.ZodNumber;
            }, z.core.$strict>>;
            dependencies: z.ZodArray<z.ZodString>;
        }, z.core.$strict>>;
        portBindings: z.ZodArray<z.ZodObject<{
            portId: z.ZodString;
            host: z.ZodString;
        }, z.core.$strict>>;
        hostPartitions: z.ZodArray<z.ZodObject<{
            host: z.ZodString;
            actorInstanceIds: z.ZodArray<z.ZodString>;
            portIds: z.ZodArray<z.ZodString>;
        }, z.core.$strict>>;
        planId: z.ZodString;
    }, z.core.$strict>;
    source: z.ZodPipe<z.ZodObject<{
        remote: z.ZodOptional<z.ZodString>;
        commit: z.ZodString;
        worktree: z.ZodEnum<{
            clean: "clean";
            dirty: "dirty";
        }>;
        buildInputHash: z.ZodString;
    }, z.core.$strict>, z.ZodTransform<{
        commit: string;
        worktree: "clean" | "dirty";
        buildInputHash: string;
    } | {
        remote: string;
        commit: string;
        worktree: "clean" | "dirty";
        buildInputHash: string;
    }, {
        commit: string;
        worktree: "clean" | "dirty";
        buildInputHash: string;
        remote?: string | undefined;
    }>>;
    packageManager: z.ZodObject<{
        name: z.ZodEnum<{
            pnpm: "pnpm";
            npm: "npm";
            yarn: "yarn";
        }>;
        version: z.ZodString;
        lockfileHash: z.ZodString;
    }, z.core.$strict>;
    environment: z.ZodObject<{
        catalogId: z.ZodString;
        catalogVersion: z.ZodString;
    }, z.core.$strict>;
    resources: z.ZodArray<z.ZodObject<{
        resourceId: z.ZodString;
        resourceClass: z.ZodEnum<{
            secret: "secret";
            "effect-journal": "effect-journal";
            datalake: "datalake";
            "xl1-network": "xl1-network";
            "projection-store": "projection-store";
            "checkpoint-store": "checkpoint-store";
            identity: "identity";
            "side-channel": "side-channel";
            "external-source": "external-source";
            "event-stream": "event-stream";
            "event-subscription": "event-subscription";
        }>;
        provision: z.ZodEnum<{
            external: "external";
            "managed-local": "managed-local";
            managed: "managed";
        }>;
        persistence: z.ZodEnum<{
            ephemeral: "ephemeral";
            external: "external";
            retained: "retained";
        }>;
        adapterId: z.ZodString;
        adapterVersion: z.ZodString;
        dependencies: z.ZodArray<z.ZodString>;
        providerInstanceId: z.ZodOptional<z.ZodString>;
        providerDescriptor: z.ZodObject<{
            descriptor: z.ZodObject<{
                id: z.ZodString;
                version: z.ZodNumber;
            }, z.core.$strict>;
            configSchemaHash: z.ZodString;
            implementationHash: z.ZodString;
        }, z.core.$strict>;
        providerConfig: z.ZodType<import("./jsonValue.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./jsonValue.ts").JsonObject, unknown>>;
    }, z.core.$strict>>;
    artifacts: z.ZodArray<z.ZodObject<{
        artifactId: z.ZodString;
        artifactManifestHash: z.ZodString;
        contentRoot: z.ZodString;
    }, z.core.$strict>>;
    promotable: z.ZodBoolean;
    lockId: z.ZodString;
}, z.core.$strict>;
export type DappDeploymentLockV3 = z.infer<typeof DappDeploymentLockV3Zod>;
export interface CreateDappDeploymentLockV3Input extends CreateDappDeploymentLockV2Input {
    /** The host's public-safe projection of every registered entry, keyed by manifest alias. */
    infrastructure: Readonly<Record<string, unknown>>;
}
export interface DappDeploymentLockV3Success {
    intent: DappDeploymentIntentV1;
    success: true;
    value: DappDeploymentLockV3;
}
export type DappDeploymentLockV3Result = DappDeploymentLockV3Success | {
    issues: DappDeploymentLockIssue[];
    success: false;
};
/** D-002 kind `deployment-lock` version 3: `xyo-dapp-kit:deployment-lock:v3\n`. */
export declare function hashDappDeploymentLockV3(preimage: unknown): string;
/**
 * Builds a Lock V3 from a project manifest, a Deployment Manifest V2, and the
 * selected safe infrastructure projections. Resolution goes through the
 * V2-only resolver, so an embedded V1 request can never substitute for the
 * V2 deployment; the manifest and intent identities are recomputed here and
 * never accepted as inputs.
 */
export declare function createDappDeploymentLockV3(input: CreateDappDeploymentLockV3Input): DappDeploymentLockV3Result;
export declare function verifyDappDeploymentLockV3(value: unknown): DappDeploymentLockV3Result | {
    success: true;
    value: DappDeploymentLockV3;
};
//# sourceMappingURL=deploymentLockV3.d.ts.map