import { createReceizNodeOfflineSealer } from "@receiz/sdk/offline/node";
/** Host-owned custody coordinates. Never accepted from MCP tool arguments. */
export type ReceizMcpLocalCustody = Readonly<{
    directory: string;
    workspace: string;
    identity: Readonly<{
        artifactPath: string;
        passphrase?: string;
    }> | null;
    /** Host-only fact established after same-runtime canonical identity admission. */
    identityAdmitted?: true;
}>;
export declare const RECEIZ_OFFLINE_SEAL_TOOLS: ({
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            previousCoordinate: {
                type: string;
            };
            confirmEnrollment?: undefined;
            inputPath?: undefined;
            outputPath?: undefined;
            mimeType?: undefined;
            file?: undefined;
            text?: undefined;
            filename?: undefined;
            contentKind?: undefined;
            transferToken?: undefined;
            artifactReference?: undefined;
            artifactSha256?: undefined;
            offset?: undefined;
            prepareDownload?: undefined;
            attemptIds?: undefined;
            byteLength?: undefined;
        };
        additionalProperties: boolean;
        required?: undefined;
    };
    outputSchema?: undefined;
    _meta?: undefined;
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            previousCoordinate?: undefined;
            confirmEnrollment?: undefined;
            inputPath?: undefined;
            outputPath?: undefined;
            mimeType?: undefined;
            file?: undefined;
            text?: undefined;
            filename?: undefined;
            contentKind?: undefined;
            transferToken?: undefined;
            artifactReference?: undefined;
            artifactSha256?: undefined;
            offset?: undefined;
            prepareDownload?: undefined;
            attemptIds?: undefined;
            byteLength?: undefined;
        };
        additionalProperties: boolean;
        required?: undefined;
    };
    outputSchema?: undefined;
    _meta?: undefined;
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            confirmEnrollment: {
                type: string;
                const: boolean;
            };
            previousCoordinate?: undefined;
            inputPath?: undefined;
            outputPath?: undefined;
            mimeType?: undefined;
            file?: undefined;
            text?: undefined;
            filename?: undefined;
            contentKind?: undefined;
            transferToken?: undefined;
            artifactReference?: undefined;
            artifactSha256?: undefined;
            offset?: undefined;
            prepareDownload?: undefined;
            attemptIds?: undefined;
            byteLength?: undefined;
        };
        required: string[];
        additionalProperties: boolean;
    };
    outputSchema?: undefined;
    _meta?: undefined;
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            inputPath: {
                type: string;
            };
            outputPath: {
                type: string;
            };
            mimeType: {
                type: string;
            };
            file: {
                type: string;
                properties: {
                    download_url: {
                        type: string;
                    };
                    file_id: {
                        type: string;
                    };
                    mime_type: {
                        type: string;
                    };
                    file_name: {
                        type: string;
                    };
                };
                required: string[];
                additionalProperties: boolean;
            };
            text: {
                type: string;
            };
            filename: {
                type: string;
            };
            contentKind: {
                type: string;
                enum: string[];
            };
            previousCoordinate?: undefined;
            confirmEnrollment?: undefined;
            transferToken?: undefined;
            artifactReference?: undefined;
            artifactSha256?: undefined;
            offset?: undefined;
            prepareDownload?: undefined;
            attemptIds?: undefined;
            byteLength?: undefined;
        };
        additionalProperties: boolean;
        required?: undefined;
    };
    outputSchema: {
        type: string;
        properties: {
            artifactReference: {
                type: string;
            };
            artifactSha256: {
                type: string;
            };
            suggestedFilename: {
                type: string;
            };
            mimeType: {
                type: string;
            };
            byteLength: {
                type: string;
            };
            offset?: undefined;
            nextOffset?: undefined;
            filename?: undefined;
            mcpAuthority?: undefined;
            bytesBase64?: undefined;
            receizTransportAttemptId?: undefined;
            downloadUrl?: undefined;
        };
        required: string[];
    };
    _meta: {
        "openai/fileParams": string[];
        ui: {
            resourceUri: string;
            visibility?: undefined;
        };
        "openai/outputTemplate": string;
        "openai/visibility"?: undefined;
        "openai/widgetAccessible"?: undefined;
    };
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            transferToken: {
                type: string;
            };
            artifactReference: {
                type: string;
            };
            artifactSha256: {
                type: string;
            };
            offset: {
                type: string;
                minimum: number;
            };
            prepareDownload: {
                type: string;
            };
            attemptIds: {
                type: string;
                items: {
                    type: string;
                };
            };
            byteLength: {
                type: string;
                minimum: number;
            };
            previousCoordinate?: undefined;
            confirmEnrollment?: undefined;
            inputPath?: undefined;
            outputPath?: undefined;
            mimeType?: undefined;
            file?: undefined;
            text?: undefined;
            filename?: undefined;
            contentKind?: undefined;
        };
        additionalProperties: boolean;
        required?: undefined;
    };
    outputSchema: {
        type: string;
        properties: {
            offset: {
                type: string;
            };
            nextOffset: {
                type: string;
            };
            byteLength: {
                type: string;
            };
            artifactSha256: {
                type: string;
            };
            filename: {
                type: string;
            };
            mimeType: {
                type: string;
            };
            mcpAuthority: {
                type: string;
            };
            bytesBase64: {
                type: string;
            };
            receizTransportAttemptId: {
                type: string;
            };
            downloadUrl: {
                type: string;
            };
            artifactReference?: undefined;
            suggestedFilename?: undefined;
        };
        required: string[];
    };
    _meta: {
        ui: {
            visibility: string[];
            resourceUri?: undefined;
        };
        "openai/visibility": string;
        "openai/widgetAccessible": boolean;
        "openai/fileParams"?: undefined;
        "openai/outputTemplate"?: undefined;
    };
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            inputPath: {
                type: string;
            };
            previousCoordinate?: undefined;
            confirmEnrollment?: undefined;
            outputPath?: undefined;
            mimeType?: undefined;
            file?: undefined;
            text?: undefined;
            filename?: undefined;
            contentKind?: undefined;
            transferToken?: undefined;
            artifactReference?: undefined;
            artifactSha256?: undefined;
            offset?: undefined;
            prepareDownload?: undefined;
            attemptIds?: undefined;
            byteLength?: undefined;
        };
        required: string[];
        additionalProperties: boolean;
    };
    outputSchema?: undefined;
    _meta?: undefined;
})[];
/** A reusable application boundary: only exact source bytes enter the SDK sealer.
 * The sealed file is authoritative; this result is a locator and projection. */
export declare function sealReceizSourceBytes(input: Readonly<{
    bytes: Uint8Array;
    filename: string;
    mimeType?: string;
}>, options?: {
    directory?: string;
    workspace?: string;
    fetch?: typeof globalThis.fetch;
    identity?: ReceizMcpLocalCustody["identity"];
    identityAdmitted?: true;
    sealer?: Pick<Awaited<ReturnType<typeof createReceizNodeOfflineSealer>>, "ready" | "enroll" | "seal">;
}): Promise<{
    outputPath: string;
    artifactReference: string;
    artifactSha256: string;
    suggestedFilename: string;
    mimeType: string;
    byteLength: number;
    verification: Readonly<{
        ok: boolean;
        integrity: Readonly<{
            ok: boolean;
            errors: string[];
        }>;
        kind: "png" | "pdf" | "heic-box" | "trailer" | "bundle" | "folder_package" | "unknown";
        errors: string[];
        warnings: string[];
        bundle: Readonly<Record<string, unknown>> | null;
        anchor: Readonly<Record<string, unknown>> | null;
        package: Readonly<Record<string, unknown>> | null;
        assetContinuity?: import("@/packages/receiz-sdk/dist/verifier/types.js").ReceizLocalAssetContinuity;
        denial?: Readonly<{
            status: "operational-denial";
            code: import("@receiz/sdk").ReceizProtocolLimitCode;
            artifactValidity: "not-evaluated";
        }>;
    }>;
    mcpAuthority: boolean;
    strongerTruth: "sealed-receiz-proof-object";
}>;
export declare function sealUploadedArtifact(raw: unknown, options?: Parameters<typeof sealReceizSourceBytes>[1] & {
    allowedOrigins?: readonly string[];
}): Promise<{
    sourceTransport: {
        byteLength: number;
        sha256: string;
        authority: boolean;
    };
    sourceKind: "authorized-upload";
    outputPath: string;
    artifactReference: string;
    artifactSha256: string;
    suggestedFilename: string;
    mimeType: string;
    byteLength: number;
    verification: Readonly<{
        ok: boolean;
        integrity: Readonly<{
            ok: boolean;
            errors: string[];
        }>;
        kind: "png" | "pdf" | "heic-box" | "trailer" | "bundle" | "folder_package" | "unknown";
        errors: string[];
        warnings: string[];
        bundle: Readonly<Record<string, unknown>> | null;
        anchor: Readonly<Record<string, unknown>> | null;
        package: Readonly<Record<string, unknown>> | null;
        assetContinuity?: import("@/packages/receiz-sdk/dist/verifier/types.js").ReceizLocalAssetContinuity;
        denial?: Readonly<{
            status: "operational-denial";
            code: import("@receiz/sdk").ReceizProtocolLimitCode;
            artifactValidity: "not-evaluated";
        }>;
    }>;
    mcpAuthority: boolean;
    strongerTruth: "sealed-receiz-proof-object";
}>;
export declare function sealSuppliedText(raw: unknown, options?: Parameters<typeof sealReceizSourceBytes>[1]): Promise<{
    sourceKind: "caller-supplied-text";
    contentKind: unknown;
    sourceTransport: {
        byteLength: number;
        sha256: string;
        authority: boolean;
    };
    authorshipVerified: boolean;
    conversationCompletenessVerified: boolean;
    outputPath: string;
    artifactReference: string;
    artifactSha256: string;
    suggestedFilename: string;
    mimeType: string;
    byteLength: number;
    verification: Readonly<{
        ok: boolean;
        integrity: Readonly<{
            ok: boolean;
            errors: string[];
        }>;
        kind: "png" | "pdf" | "heic-box" | "trailer" | "bundle" | "folder_package" | "unknown";
        errors: string[];
        warnings: string[];
        bundle: Readonly<Record<string, unknown>> | null;
        anchor: Readonly<Record<string, unknown>> | null;
        package: Readonly<Record<string, unknown>> | null;
        assetContinuity?: import("@/packages/receiz-sdk/dist/verifier/types.js").ReceizLocalAssetContinuity;
        denial?: Readonly<{
            status: "operational-denial";
            code: import("@receiz/sdk").ReceizProtocolLimitCode;
            artifactValidity: "not-evaluated";
        }>;
    }>;
    mcpAuthority: boolean;
    strongerTruth: "sealed-receiz-proof-object";
}>;
export declare function callReceizOfflineSealTool(name: string, raw: unknown, options?: {
    directory?: string;
    workspace?: string;
    fetch?: typeof globalThis.fetch;
    allowedOrigins?: readonly string[];
    identity?: ReceizMcpLocalCustody["identity"];
    sealer?: Pick<Awaited<ReturnType<typeof createReceizNodeOfflineSealer>>, "ready" | "enroll" | "seal">;
}): Promise<{
    sourceTransport: {
        byteLength: number;
        sha256: string;
        authority: boolean;
    };
    sourceKind: "authorized-upload";
    outputPath: string;
    artifactReference: string;
    artifactSha256: string;
    suggestedFilename: string;
    mimeType: string;
    byteLength: number;
    verification: Readonly<{
        ok: boolean;
        integrity: Readonly<{
            ok: boolean;
            errors: string[];
        }>;
        kind: "png" | "pdf" | "heic-box" | "trailer" | "bundle" | "folder_package" | "unknown";
        errors: string[];
        warnings: string[];
        bundle: Readonly<Record<string, unknown>> | null;
        anchor: Readonly<Record<string, unknown>> | null;
        package: Readonly<Record<string, unknown>> | null;
        assetContinuity?: import("@/packages/receiz-sdk/dist/verifier/types.js").ReceizLocalAssetContinuity;
        denial?: Readonly<{
            status: "operational-denial";
            code: import("@receiz/sdk").ReceizProtocolLimitCode;
            artifactValidity: "not-evaluated";
        }>;
    }>;
    mcpAuthority: boolean;
    strongerTruth: "sealed-receiz-proof-object";
} | {
    sourceKind: "caller-supplied-text";
    contentKind: unknown;
    sourceTransport: {
        byteLength: number;
        sha256: string;
        authority: boolean;
    };
    authorshipVerified: boolean;
    conversationCompletenessVerified: boolean;
    outputPath: string;
    artifactReference: string;
    artifactSha256: string;
    suggestedFilename: string;
    mimeType: string;
    byteLength: number;
    verification: Readonly<{
        ok: boolean;
        integrity: Readonly<{
            ok: boolean;
            errors: string[];
        }>;
        kind: "png" | "pdf" | "heic-box" | "trailer" | "bundle" | "folder_package" | "unknown";
        errors: string[];
        warnings: string[];
        bundle: Readonly<Record<string, unknown>> | null;
        anchor: Readonly<Record<string, unknown>> | null;
        package: Readonly<Record<string, unknown>> | null;
        assetContinuity?: import("@/packages/receiz-sdk/dist/verifier/types.js").ReceizLocalAssetContinuity;
        denial?: Readonly<{
            status: "operational-denial";
            code: import("@receiz/sdk").ReceizProtocolLimitCode;
            artifactValidity: "not-evaluated";
        }>;
    }>;
    mcpAuthority: boolean;
    strongerTruth: "sealed-receiz-proof-object";
} | {
    coordinate: Readonly<{
        schema: typeof import("@receiz/sdk").RECEIZ_KKS_V1_PROOF_COORDINATE_SCHEMA;
        kksVersion: typeof import("@receiz/sdk").RECEIZ_KKS_V1_VERSION;
        kaiPulse: string;
        kaiUpulse: string;
        source: import("@/packages/receiz-sdk/dist/v125KaiAuthority.js").ReceizKksV1CoordinateSource;
        kaiSigil: import("@receiz/sdk").ReceizKaiSigilTemporalProofV1;
        authority: Readonly<{
            temporalAuthority: "kai-pulse-monotonic-frequency-from-genesis";
            intrinsicProof: "kaisigil-blake3-poseidon-groth16";
            causalOrder: "verified-previous-head-then-strictly-greater-kai-upulse";
            chronosRole: "descriptive-projection-only";
            createdAtAuthority: false;
            networkRequired: false;
        }>;
    }>;
    mcpAuthority: boolean;
    networkRequired: boolean;
    verification?: undefined;
    ready?: undefined;
    networkRequiredForSealing?: undefined;
    privateKeyExposed?: undefined;
    outputPath?: undefined;
    artifactSha256?: undefined;
    artifactReference?: undefined;
    suggestedFilename?: undefined;
    mimeType?: undefined;
    byteLength?: undefined;
    strongerTruth?: undefined;
} | {
    verification: Readonly<{
        ok: boolean;
        integrity: Readonly<{
            ok: boolean;
            errors: string[];
        }>;
        kind: "png" | "pdf" | "heic-box" | "trailer" | "bundle" | "folder_package" | "unknown";
        errors: string[];
        warnings: string[];
        bundle: Readonly<Record<string, unknown>> | null;
        anchor: Readonly<Record<string, unknown>> | null;
        package: Readonly<Record<string, unknown>> | null;
        assetContinuity?: import("@/packages/receiz-sdk/dist/verifier/types.js").ReceizLocalAssetContinuity;
        denial?: Readonly<{
            status: "operational-denial";
            code: import("@receiz/sdk").ReceizProtocolLimitCode;
            artifactValidity: "not-evaluated";
        }>;
    }>;
    mcpAuthority: boolean;
    coordinate?: undefined;
    networkRequired?: undefined;
    ready?: undefined;
    networkRequiredForSealing?: undefined;
    privateKeyExposed?: undefined;
    outputPath?: undefined;
    artifactSha256?: undefined;
    artifactReference?: undefined;
    suggestedFilename?: undefined;
    mimeType?: undefined;
    byteLength?: undefined;
    strongerTruth?: undefined;
} | {
    ready: boolean;
    networkRequiredForSealing: boolean;
    mcpAuthority: boolean;
    coordinate?: undefined;
    networkRequired?: undefined;
    verification?: undefined;
    privateKeyExposed?: undefined;
    outputPath?: undefined;
    artifactSha256?: undefined;
    artifactReference?: undefined;
    suggestedFilename?: undefined;
    mimeType?: undefined;
    byteLength?: undefined;
    strongerTruth?: undefined;
} | {
    ready: boolean;
    privateKeyExposed: boolean;
    mcpAuthority: boolean;
    coordinate?: undefined;
    networkRequired?: undefined;
    verification?: undefined;
    networkRequiredForSealing?: undefined;
    outputPath?: undefined;
    artifactSha256?: undefined;
    artifactReference?: undefined;
    suggestedFilename?: undefined;
    mimeType?: undefined;
    byteLength?: undefined;
    strongerTruth?: undefined;
} | {
    outputPath: string;
    artifactSha256: string;
    artifactReference: string;
    suggestedFilename: string;
    mimeType: string;
    byteLength: number;
    verification: Readonly<{
        ok: boolean;
        integrity: Readonly<{
            ok: boolean;
            errors: string[];
        }>;
        kind: "png" | "pdf" | "heic-box" | "trailer" | "bundle" | "folder_package" | "unknown";
        errors: string[];
        warnings: string[];
        bundle: Readonly<Record<string, unknown>> | null;
        anchor: Readonly<Record<string, unknown>> | null;
        package: Readonly<Record<string, unknown>> | null;
        assetContinuity?: import("@/packages/receiz-sdk/dist/verifier/types.js").ReceizLocalAssetContinuity;
        denial?: Readonly<{
            status: "operational-denial";
            code: import("@receiz/sdk").ReceizProtocolLimitCode;
            artifactValidity: "not-evaluated";
        }>;
    }>;
    mcpAuthority: boolean;
    strongerTruth: string;
    coordinate?: undefined;
    networkRequired?: undefined;
    ready?: undefined;
    networkRequiredForSealing?: undefined;
    privateKeyExposed?: undefined;
}>;
//# sourceMappingURL=offlineSealing.d.ts.map