@serovaai/ficta-contract 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Serova OÜ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# @serovaai/ficta-contract
+
+Language-neutral HTTP contract for building a frontend or operator integration for the Ficta
+protection engine. The package includes a generated OpenAPI 3.1.1 document; TypeScript users also get
+the source oRPC contract and Zod schemas, a fetch-based client, and shared error decoding.
+
+This package covers the Ficta **control plane** only. OpenAI- and Anthropic-compatible model traffic
+continues to use the providers' native wire formats through the proxy and is intentionally not
+wrapped in oRPC.
+
+## Start here
+
+Choose the smallest integration profile your product needs:
+
+| Profile               | Interface                                                      |
+| --------------------- | -------------------------------------------------------------- |
+| Transparent proxy     | Send native Anthropic or OpenAI HTTP/SSE traffic through Ficta |
+| Status-aware frontend | Discover capabilities, then read values-free protection status |
+| Reviewed send         | Preview exact text, render findings, then make one bound send  |
+| Operator liveness     | Probe control-plane health with `GET` or `HEAD`                |
+
+The [frontend integration contract](https://github.com/SerovaAI/ficta/blob/main/packages/ficta/docs/control-plane.md)
+defines compatibility, deployment and trust boundaries, native provider paths, scope isolation,
+the reviewed-send lifecycle, errors, and conformance requirements. Read it alongside OpenAPI: the
+schema defines control-plane wire shapes, while the guide defines behavior that OpenAPI cannot
+express.
+
+## Install
+
+```sh
+pnpm add @serovaai/ficta-contract
+```
+
+## Typed client
+
+```ts
+import { createFictaControlClient, FICTA_SCOPE_HEADER } from "@serovaai/ficta-contract";
+
+const client = createFictaControlClient({ baseUrl: "http://127.0.0.1:8787" });
+
+const capabilities = await client.capabilities();
+const health = await client.health();
+const status = await client.status();
+
+const scopedClient = createFictaControlClient({
+  baseUrl: "http://127.0.0.1:8787",
+  headers: { [FICTA_SCOPE_HEADER]: "my-workspace:my-user:my-thread" },
+});
+const preview = await scopedClient.protectionPreview({
+  text: "Review Project Juniper",
+  protectedValues: ["Project Juniper"],
+});
+```
+
+The proxy defaults to loopback and protection preview is loopback-only. A browser frontend should
+normally call its own trusted server, which then calls Ficta; do not expose the proxy or manufacture
+trusted scope headers from an untrusted browser.
+
+## Machine-readable OpenAPI
+
+The generated specification is exported as `@serovaai/ficta-contract/openapi.json` and is also
+included at `openapi/ficta-control-plane.openapi.json` in the package. It is generated from the same
+oRPC contract used by the client and proxy implementation. Any OpenAPI 3.1-capable language or HTTP
+client can use it; oRPC is optional.
+
+The versioned capability response is the runtime compatibility handshake:
+
+```json
+{
+  "ok": true,
+  "service": "ficta",
+  "protocolVersion": 1,
+  "capabilities": ["health", "status", "protection-preview"]
+}
+```
+
+Capability names are open for compatible extension. Clients must require the names they use and
+ignore unrecognized names when `protocolVersion` remains compatible.
+
+## License
+
+MIT — see [`LICENSE`](./LICENSE).

package/dist/client.d.ts

@@ -0,0 +1,11 @@
+import type { ContractRouterClient } from "@orpc/contract";
+import type { JsonifiedClient } from "@orpc/openapi-client";
+import { fictaControlContract } from "./contract.js";
+export type FictaControlClient = JsonifiedClient<ContractRouterClient<typeof fictaControlContract>>;
+export interface CreateFictaControlClientOptions {
+    baseUrl: string | URL;
+    headers?: Headers | Record<string, string>;
+    fetch?: typeof globalThis.fetch;
+}
+/** Create a fetch-based client for any conforming Ficta control-plane implementation. */
+export declare function createFictaControlClient(options: CreateFictaControlClientOptions): FictaControlClient;

package/dist/client.js

@@ -0,0 +1,18 @@
+import { createORPCClient } from "@orpc/client";
+import { OpenAPILink } from "@orpc/openapi-client/fetch";
+import { fictaControlContract } from "./contract.js";
+import { decodeFictaControlError } from "./errors.js";
+/** Create a fetch-based client for any conforming Ficta control-plane implementation. */
+export function createFictaControlClient(options) {
+    const link = new OpenAPILink(fictaControlContract, {
+        url: options.baseUrl,
+        headers: options.headers,
+        customErrorResponseBodyDecoder: decodeFictaControlError,
+        ...(options.fetch
+            ? {
+                fetch: (request, init) => options.fetch?.(request, init) ?? globalThis.fetch(request, init),
+            }
+            : {}),
+    });
+    return createORPCClient(link);
+}

package/dist/contract.d.ts

@@ -0,0 +1,139 @@
+export declare const fictaControlContract: {
+    capabilities: import("@orpc/contract").ContractProcedure<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+        service: import("zod").ZodLiteral<"ficta">;
+        protocolVersion: import("zod").ZodLiteral<1>;
+        capabilities: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>, import("@orpc/contract").MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
+    health: import("@orpc/contract").ContractProcedure<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+        service: import("zod").ZodLiteral<"ficta">;
+    }, import("zod/v4/core").$strict>, import("@orpc/contract").MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
+    status: import("@orpc/contract").ContractProcedure<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+        service: import("zod").ZodLiteral<"ficta">;
+        protection: import("zod").ZodObject<{
+            enabled: import("zod").ZodBoolean;
+            protecting: import("zod").ZodBoolean;
+            registeredValues: import("zod").ZodNumber;
+            policyExcluded: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>;
+        registry: import("zod").ZodOptional<import("zod").ZodObject<{
+            required: import("zod").ZodBoolean;
+            status: import("zod").ZodEnum<{
+                empty: "empty";
+                error: "error";
+                ready: "ready";
+            }>;
+            message: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+        secretShapes: import("zod").ZodObject<{
+            enabled: import("zod").ZodBoolean;
+            status: import("zod").ZodEnum<{
+                off: "off";
+                ok: "ok";
+            }>;
+            message: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        pii: import("zod").ZodObject<{
+            enabled: import("zod").ZodBoolean;
+            configuredBackend: import("zod").ZodString;
+            configuredBackends: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            backend: import("zod").ZodString;
+            status: import("zod").ZodEnum<{
+                blocking: "blocking";
+                degraded: "degraded";
+                off: "off";
+                ok: "ok";
+            }>;
+            failureMode: import("zod").ZodEnum<{
+                "fail-closed": "fail-closed";
+                "fail-open": "fail-open";
+            }>;
+            url: import("zod").ZodOptional<import("zod").ZodString>;
+            detail: import("zod").ZodOptional<import("zod").ZodString>;
+            message: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        activity: import("zod").ZodOptional<import("zod").ZodObject<{
+            restoredValues: import("zod").ZodNumber;
+            withheldFromTools: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>, import("@orpc/contract").MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
+    protectionPreview: import("@orpc/contract").ContractProcedure<import("zod").ZodPipe<import("zod").ZodObject<{
+        text: import("zod").ZodString;
+        protectedValues: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
+        text: string;
+        protectedValues: string[];
+    }, {
+        text: string;
+        protectedValues?: string[] | undefined;
+    }>>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+        service: import("zod").ZodLiteral<"ficta">;
+        ticket: import("zod").ZodString;
+        textSha256: import("zod").ZodString;
+        redactedText: import("zod").ZodString;
+        findings: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            source: import("zod").ZodString;
+            plugin: import("zod").ZodOptional<import("zod").ZodString>;
+            kind: import("zod").ZodOptional<import("zod").ZodEnum<{
+                custom: "custom";
+                pii: "pii";
+                secret: "secret";
+            }>>;
+            confidence: import("zod").ZodOptional<import("zod").ZodEnum<{
+                exact: "exact";
+                high: "high";
+                probabilistic: "probabilistic";
+            }>>;
+            start: import("zod").ZodNumber;
+            end: import("zod").ZodNumber;
+            surrogate: import("zod").ZodString;
+            origin: import("zod").ZodEnum<{
+                detected: "detected";
+                registry: "registry";
+                user: "user";
+            }>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>, import("@orpc/contract").MergedErrorMap<Record<never, never>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+        FORBIDDEN: {
+            status: number;
+            data: import("zod").ZodObject<{
+                ok: import("zod").ZodLiteral<false>;
+                service: import("zod").ZodLiteral<"ficta">;
+                message: import("zod").ZodString;
+                status: import("zod").ZodLiteral<"forbidden">;
+            }, import("zod/v4/core").$strict>;
+        };
+        INVALID_REQUEST: {
+            status: number;
+            data: import("zod").ZodObject<{
+                ok: import("zod").ZodLiteral<false>;
+                service: import("zod").ZodLiteral<"ficta">;
+                message: import("zod").ZodString;
+                status: import("zod").ZodLiteral<"invalid_request">;
+            }, import("zod/v4/core").$strict>;
+        };
+        DETECTOR_UNAVAILABLE: {
+            status: number;
+            data: import("zod").ZodObject<{
+                ok: import("zod").ZodLiteral<false>;
+                service: import("zod").ZodLiteral<"ficta">;
+                message: import("zod").ZodString;
+                status: import("zod").ZodLiteral<"detector_unavailable">;
+            }, import("zod/v4/core").$strict>;
+        };
+        INVARIANT: {
+            status: number;
+            data: import("zod").ZodObject<{
+                ok: import("zod").ZodLiteral<false>;
+                service: import("zod").ZodLiteral<"ficta">;
+                message: import("zod").ZodString;
+                status: import("zod").ZodLiteral<"invariant">;
+            }, import("zod/v4/core").$strict>;
+        };
+    }>>, Record<never, never>>;
+};
+export type FictaControlContract = typeof fictaControlContract;

package/dist/contract.js

@@ -0,0 +1,45 @@
+import { FICTA_HEALTH_PATH, FICTA_PROTECTION_PREVIEW_PATH, FICTA_STATUS_PATH } from "@serovaai/ficta-protocol";
+import { oc } from "@orpc/contract";
+import { capabilitiesSchema, FICTA_CAPABILITIES_PATH, healthSchema, protectionPreviewDetectorUnavailableErrorSchema, protectionPreviewForbiddenErrorSchema, protectionPreviewInputSchema, protectionPreviewInvalidRequestErrorSchema, protectionPreviewInvariantErrorSchema, protectionPreviewSchema, protectionStatusSchema, } from "./schemas.js";
+const controlProcedure = oc;
+export const fictaControlContract = oc.tag("Ficta control plane").router({
+    capabilities: controlProcedure
+        .route({
+        method: "GET",
+        path: FICTA_CAPABILITIES_PATH,
+        operationId: "getFictaCapabilities",
+        summary: "Discover the Ficta control-plane version and supported procedures",
+    })
+        .output(capabilitiesSchema),
+    health: controlProcedure
+        .route({
+        method: "GET",
+        path: FICTA_HEALTH_PATH,
+        operationId: "getFictaHealth",
+        summary: "Check whether the Ficta proxy process is serving requests",
+    })
+        .output(healthSchema),
+    status: controlProcedure
+        .route({
+        method: "GET",
+        path: FICTA_STATUS_PATH,
+        operationId: "getFictaProtectionStatus",
+        summary: "Read values-free protection readiness and activity metadata",
+    })
+        .output(protectionStatusSchema),
+    protectionPreview: controlProcedure
+        .route({
+        method: "POST",
+        path: FICTA_PROTECTION_PREVIEW_PATH,
+        operationId: "createFictaProtectionPreview",
+        summary: "Preview protection and issue a short-lived send ticket",
+    })
+        .input(protectionPreviewInputSchema)
+        .output(protectionPreviewSchema)
+        .errors({
+        FORBIDDEN: { status: 403, data: protectionPreviewForbiddenErrorSchema },
+        INVALID_REQUEST: { status: 400, data: protectionPreviewInvalidRequestErrorSchema },
+        DETECTOR_UNAVAILABLE: { status: 503, data: protectionPreviewDetectorUnavailableErrorSchema },
+        INVARIANT: { status: 422, data: protectionPreviewInvariantErrorSchema },
+    }),
+});

package/dist/errors.d.ts

@@ -0,0 +1,10 @@
+import { ORPCError } from "@orpc/client";
+import { type FictaProtectionPreviewError } from "./schemas.js";
+/** Encode defined preview errors with the stable pre-oRPC HTTP response body. */
+export declare function encodeFictaControlError(error: ORPCError<string, unknown>): unknown;
+/** Decode the stable HTTP error body back into the contract's typed oRPC error. */
+export declare function decodeFictaControlError(body: unknown, response: {
+    status: number;
+}): ORPCError<string, unknown> | undefined;
+export declare function fictaControlErrorStatus(error: unknown): number | undefined;
+export declare function fictaControlErrorData(error: unknown): FictaProtectionPreviewError | undefined;

package/dist/errors.js

@@ -0,0 +1,74 @@
+import { ORPCError } from "@orpc/client";
+import { protectionPreviewErrorSchema } from "./schemas.js";
+const previewErrorCodes = {
+    forbidden: "FORBIDDEN",
+    invalid_request: "INVALID_REQUEST",
+    detector_unavailable: "DETECTOR_UNAVAILABLE",
+    invariant: "INVARIANT",
+};
+/** Encode defined preview errors with the stable pre-oRPC HTTP response body. */
+export function encodeFictaControlError(error) {
+    const parsed = protectionPreviewErrorSchema.safeParse(error.data);
+    if (parsed.success)
+        return parsed.data;
+    if (error.code === "BAD_REQUEST") {
+        return {
+            ok: false,
+            service: "ficta",
+            status: "invalid_request",
+            message: protectionPreviewValidationMessage(error.data),
+        };
+    }
+    return undefined;
+}
+function protectionPreviewValidationMessage(data) {
+    if (!data || typeof data !== "object" || !("issues" in data) || !Array.isArray(data.issues)) {
+        return "Invalid protection preview request.";
+    }
+    const issue = data.issues[0];
+    if (!issue || typeof issue !== "object")
+        return "Invalid protection preview request.";
+    const record = issue;
+    const path = Array.isArray(record.path) ? record.path : [];
+    if (path.length === 0)
+        return "Preview body must be an object.";
+    if (path[0] === "text") {
+        return record.code === "too_big" || record.message === "Preview text is too large."
+            ? "Preview text is too large."
+            : "Preview text is required.";
+    }
+    if (path[0] === "protectedValues") {
+        if (path.length === 1) {
+            if (record.code === "too_big")
+                return "Too many protected values for one chat.";
+            if (record.message === "Protected values are too large for one chat.")
+                return record.message;
+            return "Protected values must be a list.";
+        }
+        return record.code === "invalid_type"
+            ? "Every protected value must be text."
+            : "A protected value is empty or too long.";
+    }
+    return "Invalid protection preview request.";
+}
+/** Decode the stable HTTP error body back into the contract's typed oRPC error. */
+export function decodeFictaControlError(body, response) {
+    const parsed = protectionPreviewErrorSchema.safeParse(body);
+    if (!parsed.success)
+        return undefined;
+    return new ORPCError(previewErrorCodes[parsed.data.status], {
+        defined: true,
+        status: response.status,
+        message: parsed.data.message,
+        data: parsed.data,
+    });
+}
+export function fictaControlErrorStatus(error) {
+    return error instanceof ORPCError ? error.status : undefined;
+}
+export function fictaControlErrorData(error) {
+    if (!(error instanceof ORPCError))
+        return undefined;
+    const parsed = protectionPreviewErrorSchema.safeParse(error.data);
+    return parsed.success ? parsed.data : undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { FICTA_HEALTH_PATH, FICTA_PROTECTION_PREVIEW_PATH, FICTA_PROTECTION_TICKET_HEADER, FICTA_SCOPE_HEADER, FICTA_STATUS_PATH, } from "@serovaai/ficta-protocol";
+export { createFictaControlClient, type CreateFictaControlClientOptions, type FictaControlClient } from "./client.js";
+export { fictaControlContract, type FictaControlContract } from "./contract.js";
+export { decodeFictaControlError, encodeFictaControlError, fictaControlErrorData, fictaControlErrorStatus, } from "./errors.js";
+export { capabilitiesSchema, FICTA_CAPABILITIES_PATH, FICTA_CONTROL_CAPABILITIES, FICTA_CONTROL_PROTOCOL_VERSION, FICTA_SCOPE_MAX_LENGTH, healthSchema, PROTECTION_PREVIEW_TEXT_MAX_BYTES, PROTECTION_PREVIEW_VALUE_MAX, PROTECTION_PREVIEW_VALUES_MAX, PROTECTION_PREVIEW_VALUES_MAX_BYTES, protectionPreviewDetectorUnavailableErrorSchema, protectionPreviewErrorSchema, protectionPreviewFindingSchema, protectionPreviewForbiddenErrorSchema, protectionPreviewInputSchema, protectionPreviewInvalidRequestErrorSchema, protectionPreviewInvariantErrorSchema, protectionPreviewSchema, protectionStatusSchema, registryProtectionStatusSchema, type FictaCapabilities, type FictaHealth, type FictaProtectionPreview, type FictaProtectionPreviewError, type FictaProtectionPreviewInput, type FictaProtectionStatus, } from "./schemas.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { FICTA_HEALTH_PATH, FICTA_PROTECTION_PREVIEW_PATH, FICTA_PROTECTION_TICKET_HEADER, FICTA_SCOPE_HEADER, FICTA_STATUS_PATH, } from "@serovaai/ficta-protocol";
+export { createFictaControlClient } from "./client.js";
+export { fictaControlContract } from "./contract.js";
+export { decodeFictaControlError, encodeFictaControlError, fictaControlErrorData, fictaControlErrorStatus, } from "./errors.js";
+export { capabilitiesSchema, FICTA_CAPABILITIES_PATH, FICTA_CONTROL_CAPABILITIES, FICTA_CONTROL_PROTOCOL_VERSION, FICTA_SCOPE_MAX_LENGTH, healthSchema, PROTECTION_PREVIEW_TEXT_MAX_BYTES, PROTECTION_PREVIEW_VALUE_MAX, PROTECTION_PREVIEW_VALUES_MAX, PROTECTION_PREVIEW_VALUES_MAX_BYTES, protectionPreviewDetectorUnavailableErrorSchema, protectionPreviewErrorSchema, protectionPreviewFindingSchema, protectionPreviewForbiddenErrorSchema, protectionPreviewInputSchema, protectionPreviewInvalidRequestErrorSchema, protectionPreviewInvariantErrorSchema, protectionPreviewSchema, protectionStatusSchema, registryProtectionStatusSchema, } from "./schemas.js";

package/dist/schemas.d.ts

@@ -0,0 +1,209 @@
+import { z } from "zod";
+export declare const FICTA_CAPABILITIES_PATH: "/__ficta/capabilities";
+export declare const FICTA_CONTROL_PROTOCOL_VERSION: 1;
+export declare const FICTA_CONTROL_CAPABILITIES: readonly ["health", "status", "protection-preview"];
+export declare const FICTA_SCOPE_MAX_LENGTH = 256;
+export declare const PROTECTION_PREVIEW_TEXT_MAX_BYTES: number;
+export declare const PROTECTION_PREVIEW_VALUES_MAX = 200;
+export declare const PROTECTION_PREVIEW_VALUE_MAX = 2000;
+export declare const PROTECTION_PREVIEW_VALUES_MAX_BYTES: number;
+export declare const healthSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    service: z.ZodLiteral<"ficta">;
+}, z.core.$strict>;
+export declare const capabilitiesSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    service: z.ZodLiteral<"ficta">;
+    protocolVersion: z.ZodLiteral<1>;
+    capabilities: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const registryProtectionStatusSchema: z.ZodObject<{
+    required: z.ZodBoolean;
+    status: z.ZodEnum<{
+        empty: "empty";
+        error: "error";
+        ready: "ready";
+    }>;
+    message: z.ZodString;
+}, z.core.$strict>;
+export declare const protectionStatusSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    service: z.ZodLiteral<"ficta">;
+    protection: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        protecting: z.ZodBoolean;
+        registeredValues: z.ZodNumber;
+        policyExcluded: z.ZodNumber;
+    }, z.core.$strict>;
+    registry: z.ZodOptional<z.ZodObject<{
+        required: z.ZodBoolean;
+        status: z.ZodEnum<{
+            empty: "empty";
+            error: "error";
+            ready: "ready";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+    secretShapes: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        status: z.ZodEnum<{
+            off: "off";
+            ok: "ok";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strict>;
+    pii: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        configuredBackend: z.ZodString;
+        configuredBackends: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        backend: z.ZodString;
+        status: z.ZodEnum<{
+            blocking: "blocking";
+            degraded: "degraded";
+            off: "off";
+            ok: "ok";
+        }>;
+        failureMode: z.ZodEnum<{
+            "fail-closed": "fail-closed";
+            "fail-open": "fail-open";
+        }>;
+        url: z.ZodOptional<z.ZodString>;
+        detail: z.ZodOptional<z.ZodString>;
+        message: z.ZodString;
+    }, z.core.$strict>;
+    activity: z.ZodOptional<z.ZodObject<{
+        restoredValues: z.ZodNumber;
+        withheldFromTools: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const protectionHitSchema: z.ZodObject<{
+    name: z.ZodString;
+    source: z.ZodString;
+    plugin: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        pii: "pii";
+        secret: "secret";
+    }>>;
+    confidence: z.ZodOptional<z.ZodEnum<{
+        exact: "exact";
+        high: "high";
+        probabilistic: "probabilistic";
+    }>>;
+}, z.core.$strict>;
+export declare const protectionPreviewFindingSchema: z.ZodObject<{
+    name: z.ZodString;
+    source: z.ZodString;
+    plugin: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        pii: "pii";
+        secret: "secret";
+    }>>;
+    confidence: z.ZodOptional<z.ZodEnum<{
+        exact: "exact";
+        high: "high";
+        probabilistic: "probabilistic";
+    }>>;
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    surrogate: z.ZodString;
+    origin: z.ZodEnum<{
+        detected: "detected";
+        registry: "registry";
+        user: "user";
+    }>;
+}, z.core.$strict>;
+export declare const protectionPreviewTextSchema: z.ZodString;
+export declare const protectionPreviewProtectedValuesSchema: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+export declare const protectionPreviewInputSchema: z.ZodPipe<z.ZodObject<{
+    text: z.ZodString;
+    protectedValues: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+}, z.core.$strip>, z.ZodTransform<{
+    text: string;
+    protectedValues: string[];
+}, {
+    text: string;
+    protectedValues?: string[] | undefined;
+}>>;
+export declare const protectionPreviewSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    service: z.ZodLiteral<"ficta">;
+    ticket: z.ZodString;
+    textSha256: z.ZodString;
+    redactedText: z.ZodString;
+    findings: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        source: z.ZodString;
+        plugin: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            pii: "pii";
+            secret: "secret";
+        }>>;
+        confidence: z.ZodOptional<z.ZodEnum<{
+            exact: "exact";
+            high: "high";
+            probabilistic: "probabilistic";
+        }>>;
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+        surrogate: z.ZodString;
+        origin: z.ZodEnum<{
+            detected: "detected";
+            registry: "registry";
+            user: "user";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const protectionPreviewForbiddenErrorSchema: z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    service: z.ZodLiteral<"ficta">;
+    message: z.ZodString;
+    status: z.ZodLiteral<"forbidden">;
+}, z.core.$strict>;
+export declare const protectionPreviewInvalidRequestErrorSchema: z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    service: z.ZodLiteral<"ficta">;
+    message: z.ZodString;
+    status: z.ZodLiteral<"invalid_request">;
+}, z.core.$strict>;
+export declare const protectionPreviewDetectorUnavailableErrorSchema: z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    service: z.ZodLiteral<"ficta">;
+    message: z.ZodString;
+    status: z.ZodLiteral<"detector_unavailable">;
+}, z.core.$strict>;
+export declare const protectionPreviewInvariantErrorSchema: z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    service: z.ZodLiteral<"ficta">;
+    message: z.ZodString;
+    status: z.ZodLiteral<"invariant">;
+}, z.core.$strict>;
+export declare const protectionPreviewErrorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    service: z.ZodLiteral<"ficta">;
+    message: z.ZodString;
+    status: z.ZodLiteral<"forbidden">;
+}, z.core.$strict>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    service: z.ZodLiteral<"ficta">;
+    message: z.ZodString;
+    status: z.ZodLiteral<"invalid_request">;
+}, z.core.$strict>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    service: z.ZodLiteral<"ficta">;
+    message: z.ZodString;
+    status: z.ZodLiteral<"detector_unavailable">;
+}, z.core.$strict>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    service: z.ZodLiteral<"ficta">;
+    message: z.ZodString;
+    status: z.ZodLiteral<"invariant">;
+}, z.core.$strict>], "status">;
+export type FictaCapabilities = z.output<typeof capabilitiesSchema>;
+export type FictaHealth = z.output<typeof healthSchema>;
+export type FictaProtectionStatus = z.output<typeof protectionStatusSchema>;
+export type FictaProtectionPreviewInput = z.input<typeof protectionPreviewInputSchema>;
+export type FictaProtectionPreview = z.output<typeof protectionPreviewSchema>;
+export type FictaProtectionPreviewError = z.output<typeof protectionPreviewErrorSchema>;