@wtfalch/foundry 0.78.1 → 0.79.0

package/dist/mcp-resources/schema.d.ts

@@ -0,0 +1,1707 @@
+import { z } from 'zod';
+export declare const MCP_RESOURCE_CONTRACT_VERSION: 1;
+export declare const McpResourceNamespaceSchema: z.ZodObject<{
+    providerTenantId: z.ZodString;
+    appId: z.ZodString;
+    copyId: z.ZodString;
+}, z.core.$strict>;
+export type McpResourceNamespace = z.infer<typeof McpResourceNamespaceSchema>;
+export declare const McpResourceKeySchema: z.ZodObject<{
+    providerTenantId: z.ZodString;
+    appId: z.ZodString;
+    copyId: z.ZodString;
+    resourceId: z.ZodString;
+}, z.core.$strict>;
+export type McpResourceKey = z.infer<typeof McpResourceKeySchema>;
+export declare const McpResourceScopeSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+}, z.core.$strict>;
+export type McpResourceScope = z.infer<typeof McpResourceScopeSchema>;
+export declare const McpResourceBrandingSchema: z.ZodObject<{
+    displayName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type McpResourceBranding = z.infer<typeof McpResourceBrandingSchema>;
+export declare const McpResourceAdmissionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"unrestricted">;
+}, z.core.$strict>, z.ZodObject<{
+    mode: z.ZodLiteral<"application-approval">;
+    policyId: z.ZodString;
+    requiredEvidence: z.ZodArray<z.ZodEnum<{
+        provider: "provider";
+        "authentication-method": "authentication-method";
+        "authentication-time": "authentication-time";
+        groups: "groups";
+    }>>;
+    returnPath: z.ZodString;
+}, z.core.$strict>], "mode">;
+export type McpResourceAdmission = z.infer<typeof McpResourceAdmissionSchema>;
+export declare const McpResourceDesiredSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        active: "active";
+        suspended: "suspended";
+        retired: "retired";
+    }>;
+    configurationRevision: z.ZodNumber;
+    policyRevision: z.ZodNumber;
+    denyEpoch: z.ZodNumber;
+    scopes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strict>>;
+    admission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"unrestricted">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"application-approval">;
+        policyId: z.ZodString;
+        requiredEvidence: z.ZodArray<z.ZodEnum<{
+            provider: "provider";
+            "authentication-method": "authentication-method";
+            "authentication-time": "authentication-time";
+            groups: "groups";
+        }>>;
+        returnPath: z.ZodString;
+    }, z.core.$strict>], "mode">;
+    branding: z.ZodOptional<z.ZodObject<{
+        displayName: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        locale: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type McpResourceDesired = z.infer<typeof McpResourceDesiredSchema>;
+export declare const McpResourceIdentitySchema: z.ZodObject<{
+    registrationId: z.ZodString;
+    resourceUri: z.ZodString;
+    audience: z.ZodString;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodString]>;
+}, z.core.$strict>;
+export type McpResourceIdentity = z.infer<typeof McpResourceIdentitySchema>;
+export declare const McpResourcePhaseSchema: z.ZodEnum<{
+    registry: "registry";
+    registration: "registration";
+    discovery: "discovery";
+    runtime: "runtime";
+    revocation: "revocation";
+    cleanup: "cleanup";
+    complete: "complete";
+}>;
+export type McpResourcePhase = z.infer<typeof McpResourcePhaseSchema>;
+export declare const McpResourceObservedSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        active: "active";
+        suspended: "suspended";
+        retired: "retired";
+        absent: "absent";
+        applying: "applying";
+        retiring: "retiring";
+    }>;
+    configurationRevision: z.ZodNullable<z.ZodNumber>;
+    policyRevision: z.ZodNullable<z.ZodNumber>;
+    denyEpoch: z.ZodNumber;
+    phase: z.ZodEnum<{
+        registry: "registry";
+        registration: "registration";
+        discovery: "discovery";
+        runtime: "runtime";
+        revocation: "revocation";
+        cleanup: "cleanup";
+        complete: "complete";
+    }>;
+    revocation: z.ZodEnum<{
+        complete: "complete";
+        "not-required": "not-required";
+        pending: "pending";
+    }>;
+    cleanup: z.ZodEnum<{
+        complete: "complete";
+        "not-required": "not-required";
+        pending: "pending";
+    }>;
+}, z.core.$strict>;
+export type McpResourceObserved = z.infer<typeof McpResourceObservedSchema>;
+export declare const McpResourceSnapshotSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    key: z.ZodObject<{
+        providerTenantId: z.ZodString;
+        appId: z.ZodString;
+        copyId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strict>;
+    generation: z.ZodNumber;
+    identity: z.ZodNullable<z.ZodObject<{
+        registrationId: z.ZodString;
+        resourceUri: z.ZodString;
+        audience: z.ZodString;
+        issuer: z.ZodUnion<[z.ZodString, z.ZodString]>;
+    }, z.core.$strict>>;
+    desired: z.ZodObject<{
+        state: z.ZodEnum<{
+            active: "active";
+            suspended: "suspended";
+            retired: "retired";
+        }>;
+        configurationRevision: z.ZodNumber;
+        policyRevision: z.ZodNumber;
+        denyEpoch: z.ZodNumber;
+        scopes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>;
+        admission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"unrestricted">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"application-approval">;
+            policyId: z.ZodString;
+            requiredEvidence: z.ZodArray<z.ZodEnum<{
+                provider: "provider";
+                "authentication-method": "authentication-method";
+                "authentication-time": "authentication-time";
+                groups: "groups";
+            }>>;
+            returnPath: z.ZodString;
+        }, z.core.$strict>], "mode">;
+        branding: z.ZodOptional<z.ZodObject<{
+            displayName: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            locale: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    observed: z.ZodObject<{
+        state: z.ZodEnum<{
+            active: "active";
+            suspended: "suspended";
+            retired: "retired";
+            absent: "absent";
+            applying: "applying";
+            retiring: "retiring";
+        }>;
+        configurationRevision: z.ZodNullable<z.ZodNumber>;
+        policyRevision: z.ZodNullable<z.ZodNumber>;
+        denyEpoch: z.ZodNumber;
+        phase: z.ZodEnum<{
+            registry: "registry";
+            registration: "registration";
+            discovery: "discovery";
+            runtime: "runtime";
+            revocation: "revocation";
+            cleanup: "cleanup";
+            complete: "complete";
+        }>;
+        revocation: z.ZodEnum<{
+            complete: "complete";
+            "not-required": "not-required";
+            pending: "pending";
+        }>;
+        cleanup: z.ZodEnum<{
+            complete: "complete";
+            "not-required": "not-required";
+            pending: "pending";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type McpResourceSnapshot = z.infer<typeof McpResourceSnapshotSchema>;
+export declare const McpResourceApplyRequestSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    key: z.ZodObject<{
+        providerTenantId: z.ZodString;
+        appId: z.ZodString;
+        copyId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strict>;
+    operationId: z.ZodString;
+    expectedGeneration: z.ZodNullable<z.ZodNumber>;
+    desired: z.ZodObject<{
+        state: z.ZodEnum<{
+            active: "active";
+            suspended: "suspended";
+            retired: "retired";
+        }>;
+        configurationRevision: z.ZodNumber;
+        policyRevision: z.ZodNumber;
+        denyEpoch: z.ZodNumber;
+        scopes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+        }, z.core.$strict>>;
+        admission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"unrestricted">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"application-approval">;
+            policyId: z.ZodString;
+            requiredEvidence: z.ZodArray<z.ZodEnum<{
+                provider: "provider";
+                "authentication-method": "authentication-method";
+                "authentication-time": "authentication-time";
+                groups: "groups";
+            }>>;
+            returnPath: z.ZodString;
+        }, z.core.$strict>], "mode">;
+        branding: z.ZodOptional<z.ZodObject<{
+            displayName: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            locale: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type McpResourceApplyRequest = z.infer<typeof McpResourceApplyRequestSchema>;
+export declare const McpResourceReadRequestSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    key: z.ZodObject<{
+        providerTenantId: z.ZodString;
+        appId: z.ZodString;
+        copyId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type McpResourceReadRequest = z.infer<typeof McpResourceReadRequestSchema>;
+export declare const McpResourceListRequestSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    namespace: z.ZodObject<{
+        providerTenantId: z.ZodString;
+        appId: z.ZodString;
+        copyId: z.ZodString;
+    }, z.core.$strict>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type McpResourceListRequest = z.infer<typeof McpResourceListRequestSchema>;
+export declare const McpResourceOperationRequestSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    key: z.ZodObject<{
+        providerTenantId: z.ZodString;
+        appId: z.ZodString;
+        copyId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strict>;
+    operationId: z.ZodString;
+}, z.core.$strict>;
+export type McpResourceOperationRequest = z.infer<typeof McpResourceOperationRequestSchema>;
+export declare const McpResourceFailureSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        retired: "retired";
+        forbidden: "forbidden";
+        "invalid-request": "invalid-request";
+        "generation-mismatch": "generation-mismatch";
+        "idempotency-mismatch": "idempotency-mismatch";
+        "revision-regression": "revision-regression";
+        "backend-unsupported": "backend-unsupported";
+        "backend-unavailable": "backend-unavailable";
+        "provider-failure": "provider-failure";
+        "invalid-response": "invalid-response";
+        "transport-failure": "transport-failure";
+    }>;
+    phase: z.ZodEnum<{
+        registry: "registry";
+        registration: "registration";
+        discovery: "discovery";
+        runtime: "runtime";
+        revocation: "revocation";
+        cleanup: "cleanup";
+        complete: "complete";
+    }>;
+}, z.core.$strict>;
+export type McpResourceFailure = z.infer<typeof McpResourceFailureSchema>;
+export declare const McpResourceRecoverySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"poll-operation">;
+    afterMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"retry-same-operation">;
+    afterMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"read-resource">;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"operator-intervention">;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"none">;
+}, z.core.$strict>], "action">;
+export type McpResourceRecovery = z.infer<typeof McpResourceRecoverySchema>;
+export declare const McpResourceApplyResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    outcome: z.ZodLiteral<"applied">;
+    snapshot: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        key: z.ZodObject<{
+            providerTenantId: z.ZodString;
+            appId: z.ZodString;
+            copyId: z.ZodString;
+            resourceId: z.ZodString;
+        }, z.core.$strict>;
+        generation: z.ZodNumber;
+        identity: z.ZodNullable<z.ZodObject<{
+            registrationId: z.ZodString;
+            resourceUri: z.ZodString;
+            audience: z.ZodString;
+            issuer: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        }, z.core.$strict>>;
+        desired: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+            }>;
+            configurationRevision: z.ZodNumber;
+            policyRevision: z.ZodNumber;
+            denyEpoch: z.ZodNumber;
+            scopes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+            admission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"unrestricted">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"application-approval">;
+                policyId: z.ZodString;
+                requiredEvidence: z.ZodArray<z.ZodEnum<{
+                    provider: "provider";
+                    "authentication-method": "authentication-method";
+                    "authentication-time": "authentication-time";
+                    groups: "groups";
+                }>>;
+                returnPath: z.ZodString;
+            }, z.core.$strict>], "mode">;
+            branding: z.ZodOptional<z.ZodObject<{
+                displayName: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                locale: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        observed: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+                absent: "absent";
+                applying: "applying";
+                retiring: "retiring";
+            }>;
+            configurationRevision: z.ZodNullable<z.ZodNumber>;
+            policyRevision: z.ZodNullable<z.ZodNumber>;
+            denyEpoch: z.ZodNumber;
+            phase: z.ZodEnum<{
+                registry: "registry";
+                registration: "registration";
+                discovery: "discovery";
+                runtime: "runtime";
+                revocation: "revocation";
+                cleanup: "cleanup";
+                complete: "complete";
+            }>;
+            revocation: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+            cleanup: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    operationId: z.ZodString;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    outcome: z.ZodLiteral<"pending">;
+    snapshot: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        key: z.ZodObject<{
+            providerTenantId: z.ZodString;
+            appId: z.ZodString;
+            copyId: z.ZodString;
+            resourceId: z.ZodString;
+        }, z.core.$strict>;
+        generation: z.ZodNumber;
+        identity: z.ZodNullable<z.ZodObject<{
+            registrationId: z.ZodString;
+            resourceUri: z.ZodString;
+            audience: z.ZodString;
+            issuer: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        }, z.core.$strict>>;
+        desired: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+            }>;
+            configurationRevision: z.ZodNumber;
+            policyRevision: z.ZodNumber;
+            denyEpoch: z.ZodNumber;
+            scopes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+            admission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"unrestricted">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"application-approval">;
+                policyId: z.ZodString;
+                requiredEvidence: z.ZodArray<z.ZodEnum<{
+                    provider: "provider";
+                    "authentication-method": "authentication-method";
+                    "authentication-time": "authentication-time";
+                    groups: "groups";
+                }>>;
+                returnPath: z.ZodString;
+            }, z.core.$strict>], "mode">;
+            branding: z.ZodOptional<z.ZodObject<{
+                displayName: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                locale: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        observed: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+                absent: "absent";
+                applying: "applying";
+                retiring: "retiring";
+            }>;
+            configurationRevision: z.ZodNullable<z.ZodNumber>;
+            policyRevision: z.ZodNullable<z.ZodNumber>;
+            denyEpoch: z.ZodNumber;
+            phase: z.ZodEnum<{
+                registry: "registry";
+                registration: "registration";
+                discovery: "discovery";
+                runtime: "runtime";
+                revocation: "revocation";
+                cleanup: "cleanup";
+                complete: "complete";
+            }>;
+            revocation: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+            cleanup: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    operationId: z.ZodString;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    failure: z.ZodObject<{
+        code: z.ZodEnum<{
+            retired: "retired";
+            forbidden: "forbidden";
+            "invalid-request": "invalid-request";
+            "generation-mismatch": "generation-mismatch";
+            "idempotency-mismatch": "idempotency-mismatch";
+            "revision-regression": "revision-regression";
+            "backend-unsupported": "backend-unsupported";
+            "backend-unavailable": "backend-unavailable";
+            "provider-failure": "provider-failure";
+            "invalid-response": "invalid-response";
+            "transport-failure": "transport-failure";
+        }>;
+        phase: z.ZodEnum<{
+            registry: "registry";
+            registration: "registration";
+            discovery: "discovery";
+            runtime: "runtime";
+            revocation: "revocation";
+            cleanup: "cleanup";
+            complete: "complete";
+        }>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    outcome: z.ZodLiteral<"partial">;
+    snapshot: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        key: z.ZodObject<{
+            providerTenantId: z.ZodString;
+            appId: z.ZodString;
+            copyId: z.ZodString;
+            resourceId: z.ZodString;
+        }, z.core.$strict>;
+        generation: z.ZodNumber;
+        identity: z.ZodNullable<z.ZodObject<{
+            registrationId: z.ZodString;
+            resourceUri: z.ZodString;
+            audience: z.ZodString;
+            issuer: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        }, z.core.$strict>>;
+        desired: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+            }>;
+            configurationRevision: z.ZodNumber;
+            policyRevision: z.ZodNumber;
+            denyEpoch: z.ZodNumber;
+            scopes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+            admission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"unrestricted">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"application-approval">;
+                policyId: z.ZodString;
+                requiredEvidence: z.ZodArray<z.ZodEnum<{
+                    provider: "provider";
+                    "authentication-method": "authentication-method";
+                    "authentication-time": "authentication-time";
+                    groups: "groups";
+                }>>;
+                returnPath: z.ZodString;
+            }, z.core.$strict>], "mode">;
+            branding: z.ZodOptional<z.ZodObject<{
+                displayName: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                locale: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        observed: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+                absent: "absent";
+                applying: "applying";
+                retiring: "retiring";
+            }>;
+            configurationRevision: z.ZodNullable<z.ZodNumber>;
+            policyRevision: z.ZodNullable<z.ZodNumber>;
+            denyEpoch: z.ZodNumber;
+            phase: z.ZodEnum<{
+                registry: "registry";
+                registration: "registration";
+                discovery: "discovery";
+                runtime: "runtime";
+                revocation: "revocation";
+                cleanup: "cleanup";
+                complete: "complete";
+            }>;
+            revocation: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+            cleanup: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    operationId: z.ZodString;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    failure: z.ZodObject<{
+        code: z.ZodEnum<{
+            retired: "retired";
+            forbidden: "forbidden";
+            "invalid-request": "invalid-request";
+            "generation-mismatch": "generation-mismatch";
+            "idempotency-mismatch": "idempotency-mismatch";
+            "revision-regression": "revision-regression";
+            "backend-unsupported": "backend-unsupported";
+            "backend-unavailable": "backend-unavailable";
+            "provider-failure": "provider-failure";
+            "invalid-response": "invalid-response";
+            "transport-failure": "transport-failure";
+        }>;
+        phase: z.ZodEnum<{
+            registry: "registry";
+            registration: "registration";
+            discovery: "discovery";
+            runtime: "runtime";
+            revocation: "revocation";
+            cleanup: "cleanup";
+            complete: "complete";
+        }>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    outcome: z.ZodLiteral<"conflict">;
+    snapshot: z.ZodNullable<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        key: z.ZodObject<{
+            providerTenantId: z.ZodString;
+            appId: z.ZodString;
+            copyId: z.ZodString;
+            resourceId: z.ZodString;
+        }, z.core.$strict>;
+        generation: z.ZodNumber;
+        identity: z.ZodNullable<z.ZodObject<{
+            registrationId: z.ZodString;
+            resourceUri: z.ZodString;
+            audience: z.ZodString;
+            issuer: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        }, z.core.$strict>>;
+        desired: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+            }>;
+            configurationRevision: z.ZodNumber;
+            policyRevision: z.ZodNumber;
+            denyEpoch: z.ZodNumber;
+            scopes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+            admission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"unrestricted">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"application-approval">;
+                policyId: z.ZodString;
+                requiredEvidence: z.ZodArray<z.ZodEnum<{
+                    provider: "provider";
+                    "authentication-method": "authentication-method";
+                    "authentication-time": "authentication-time";
+                    groups: "groups";
+                }>>;
+                returnPath: z.ZodString;
+            }, z.core.$strict>], "mode">;
+            branding: z.ZodOptional<z.ZodObject<{
+                displayName: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                locale: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        observed: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+                absent: "absent";
+                applying: "applying";
+                retiring: "retiring";
+            }>;
+            configurationRevision: z.ZodNullable<z.ZodNumber>;
+            policyRevision: z.ZodNullable<z.ZodNumber>;
+            denyEpoch: z.ZodNumber;
+            phase: z.ZodEnum<{
+                registry: "registry";
+                registration: "registration";
+                discovery: "discovery";
+                runtime: "runtime";
+                revocation: "revocation";
+                cleanup: "cleanup";
+                complete: "complete";
+            }>;
+            revocation: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+            cleanup: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    operationId: z.ZodString;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    failure: z.ZodObject<{
+        code: z.ZodEnum<{
+            retired: "retired";
+            forbidden: "forbidden";
+            "invalid-request": "invalid-request";
+            "generation-mismatch": "generation-mismatch";
+            "idempotency-mismatch": "idempotency-mismatch";
+            "revision-regression": "revision-regression";
+            "backend-unsupported": "backend-unsupported";
+            "backend-unavailable": "backend-unavailable";
+            "provider-failure": "provider-failure";
+            "invalid-response": "invalid-response";
+            "transport-failure": "transport-failure";
+        }>;
+        phase: z.ZodEnum<{
+            registry: "registry";
+            registration: "registration";
+            discovery: "discovery";
+            runtime: "runtime";
+            revocation: "revocation";
+            cleanup: "cleanup";
+            complete: "complete";
+        }>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    outcome: z.ZodLiteral<"refused">;
+    operationId: z.ZodString;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    failure: z.ZodObject<{
+        code: z.ZodEnum<{
+            retired: "retired";
+            forbidden: "forbidden";
+            "invalid-request": "invalid-request";
+            "generation-mismatch": "generation-mismatch";
+            "idempotency-mismatch": "idempotency-mismatch";
+            "revision-regression": "revision-regression";
+            "backend-unsupported": "backend-unsupported";
+            "backend-unavailable": "backend-unavailable";
+            "provider-failure": "provider-failure";
+            "invalid-response": "invalid-response";
+            "transport-failure": "transport-failure";
+        }>;
+        phase: z.ZodEnum<{
+            registry: "registry";
+            registration: "registration";
+            discovery: "discovery";
+            runtime: "runtime";
+            revocation: "revocation";
+            cleanup: "cleanup";
+            complete: "complete";
+        }>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    outcome: z.ZodLiteral<"unavailable">;
+    operationId: z.ZodString;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>], "outcome">;
+export type McpResourceApplyResult = z.infer<typeof McpResourceApplyResultSchema>;
+export declare const McpResourceReadResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    outcome: z.ZodLiteral<"found">;
+    snapshot: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        key: z.ZodObject<{
+            providerTenantId: z.ZodString;
+            appId: z.ZodString;
+            copyId: z.ZodString;
+            resourceId: z.ZodString;
+        }, z.core.$strict>;
+        generation: z.ZodNumber;
+        identity: z.ZodNullable<z.ZodObject<{
+            registrationId: z.ZodString;
+            resourceUri: z.ZodString;
+            audience: z.ZodString;
+            issuer: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        }, z.core.$strict>>;
+        desired: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+            }>;
+            configurationRevision: z.ZodNumber;
+            policyRevision: z.ZodNumber;
+            denyEpoch: z.ZodNumber;
+            scopes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+            admission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"unrestricted">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"application-approval">;
+                policyId: z.ZodString;
+                requiredEvidence: z.ZodArray<z.ZodEnum<{
+                    provider: "provider";
+                    "authentication-method": "authentication-method";
+                    "authentication-time": "authentication-time";
+                    groups: "groups";
+                }>>;
+                returnPath: z.ZodString;
+            }, z.core.$strict>], "mode">;
+            branding: z.ZodOptional<z.ZodObject<{
+                displayName: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                locale: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        observed: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+                absent: "absent";
+                applying: "applying";
+                retiring: "retiring";
+            }>;
+            configurationRevision: z.ZodNullable<z.ZodNumber>;
+            policyRevision: z.ZodNullable<z.ZodNumber>;
+            denyEpoch: z.ZodNumber;
+            phase: z.ZodEnum<{
+                registry: "registry";
+                registration: "registration";
+                discovery: "discovery";
+                runtime: "runtime";
+                revocation: "revocation";
+                cleanup: "cleanup";
+                complete: "complete";
+            }>;
+            revocation: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+            cleanup: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    outcome: z.ZodLiteral<"not-found">;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    failure: z.ZodObject<{
+        code: z.ZodEnum<{
+            retired: "retired";
+            forbidden: "forbidden";
+            "invalid-request": "invalid-request";
+            "generation-mismatch": "generation-mismatch";
+            "idempotency-mismatch": "idempotency-mismatch";
+            "revision-regression": "revision-regression";
+            "backend-unsupported": "backend-unsupported";
+            "backend-unavailable": "backend-unavailable";
+            "provider-failure": "provider-failure";
+            "invalid-response": "invalid-response";
+            "transport-failure": "transport-failure";
+        }>;
+        phase: z.ZodEnum<{
+            registry: "registry";
+            registration: "registration";
+            discovery: "discovery";
+            runtime: "runtime";
+            revocation: "revocation";
+            cleanup: "cleanup";
+            complete: "complete";
+        }>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    outcome: z.ZodLiteral<"refused">;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    failure: z.ZodObject<{
+        code: z.ZodEnum<{
+            retired: "retired";
+            forbidden: "forbidden";
+            "invalid-request": "invalid-request";
+            "generation-mismatch": "generation-mismatch";
+            "idempotency-mismatch": "idempotency-mismatch";
+            "revision-regression": "revision-regression";
+            "backend-unsupported": "backend-unsupported";
+            "backend-unavailable": "backend-unavailable";
+            "provider-failure": "provider-failure";
+            "invalid-response": "invalid-response";
+            "transport-failure": "transport-failure";
+        }>;
+        phase: z.ZodEnum<{
+            registry: "registry";
+            registration: "registration";
+            discovery: "discovery";
+            runtime: "runtime";
+            revocation: "revocation";
+            cleanup: "cleanup";
+            complete: "complete";
+        }>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    outcome: z.ZodLiteral<"unavailable">;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>], "outcome">;
+export type McpResourceReadResult = z.infer<typeof McpResourceReadResultSchema>;
+export declare const McpResourceListResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    outcome: z.ZodLiteral<"listed">;
+    resources: z.ZodArray<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        key: z.ZodObject<{
+            providerTenantId: z.ZodString;
+            appId: z.ZodString;
+            copyId: z.ZodString;
+            resourceId: z.ZodString;
+        }, z.core.$strict>;
+        generation: z.ZodNumber;
+        identity: z.ZodNullable<z.ZodObject<{
+            registrationId: z.ZodString;
+            resourceUri: z.ZodString;
+            audience: z.ZodString;
+            issuer: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        }, z.core.$strict>>;
+        desired: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+            }>;
+            configurationRevision: z.ZodNumber;
+            policyRevision: z.ZodNumber;
+            denyEpoch: z.ZodNumber;
+            scopes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+            admission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"unrestricted">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"application-approval">;
+                policyId: z.ZodString;
+                requiredEvidence: z.ZodArray<z.ZodEnum<{
+                    provider: "provider";
+                    "authentication-method": "authentication-method";
+                    "authentication-time": "authentication-time";
+                    groups: "groups";
+                }>>;
+                returnPath: z.ZodString;
+            }, z.core.$strict>], "mode">;
+            branding: z.ZodOptional<z.ZodObject<{
+                displayName: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                locale: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        observed: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+                absent: "absent";
+                applying: "applying";
+                retiring: "retiring";
+            }>;
+            configurationRevision: z.ZodNullable<z.ZodNumber>;
+            policyRevision: z.ZodNullable<z.ZodNumber>;
+            denyEpoch: z.ZodNumber;
+            phase: z.ZodEnum<{
+                registry: "registry";
+                registration: "registration";
+                discovery: "discovery";
+                runtime: "runtime";
+                revocation: "revocation";
+                cleanup: "cleanup";
+                complete: "complete";
+            }>;
+            revocation: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+            cleanup: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    failure: z.ZodObject<{
+        code: z.ZodEnum<{
+            retired: "retired";
+            forbidden: "forbidden";
+            "invalid-request": "invalid-request";
+            "generation-mismatch": "generation-mismatch";
+            "idempotency-mismatch": "idempotency-mismatch";
+            "revision-regression": "revision-regression";
+            "backend-unsupported": "backend-unsupported";
+            "backend-unavailable": "backend-unavailable";
+            "provider-failure": "provider-failure";
+            "invalid-response": "invalid-response";
+            "transport-failure": "transport-failure";
+        }>;
+        phase: z.ZodEnum<{
+            registry: "registry";
+            registration: "registration";
+            discovery: "discovery";
+            runtime: "runtime";
+            revocation: "revocation";
+            cleanup: "cleanup";
+            complete: "complete";
+        }>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    outcome: z.ZodLiteral<"refused">;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    failure: z.ZodObject<{
+        code: z.ZodEnum<{
+            retired: "retired";
+            forbidden: "forbidden";
+            "invalid-request": "invalid-request";
+            "generation-mismatch": "generation-mismatch";
+            "idempotency-mismatch": "idempotency-mismatch";
+            "revision-regression": "revision-regression";
+            "backend-unsupported": "backend-unsupported";
+            "backend-unavailable": "backend-unavailable";
+            "provider-failure": "provider-failure";
+            "invalid-response": "invalid-response";
+            "transport-failure": "transport-failure";
+        }>;
+        phase: z.ZodEnum<{
+            registry: "registry";
+            registration: "registration";
+            discovery: "discovery";
+            runtime: "runtime";
+            revocation: "revocation";
+            cleanup: "cleanup";
+            complete: "complete";
+        }>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    outcome: z.ZodLiteral<"unavailable">;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>], "outcome">;
+export type McpResourceListResult = z.infer<typeof McpResourceListResultSchema>;
+export declare const McpResourceOperationResultSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    outcome: z.ZodLiteral<"applied">;
+    snapshot: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        key: z.ZodObject<{
+            providerTenantId: z.ZodString;
+            appId: z.ZodString;
+            copyId: z.ZodString;
+            resourceId: z.ZodString;
+        }, z.core.$strict>;
+        generation: z.ZodNumber;
+        identity: z.ZodNullable<z.ZodObject<{
+            registrationId: z.ZodString;
+            resourceUri: z.ZodString;
+            audience: z.ZodString;
+            issuer: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        }, z.core.$strict>>;
+        desired: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+            }>;
+            configurationRevision: z.ZodNumber;
+            policyRevision: z.ZodNumber;
+            denyEpoch: z.ZodNumber;
+            scopes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+            admission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"unrestricted">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"application-approval">;
+                policyId: z.ZodString;
+                requiredEvidence: z.ZodArray<z.ZodEnum<{
+                    provider: "provider";
+                    "authentication-method": "authentication-method";
+                    "authentication-time": "authentication-time";
+                    groups: "groups";
+                }>>;
+                returnPath: z.ZodString;
+            }, z.core.$strict>], "mode">;
+            branding: z.ZodOptional<z.ZodObject<{
+                displayName: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                locale: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        observed: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+                absent: "absent";
+                applying: "applying";
+                retiring: "retiring";
+            }>;
+            configurationRevision: z.ZodNullable<z.ZodNumber>;
+            policyRevision: z.ZodNullable<z.ZodNumber>;
+            denyEpoch: z.ZodNumber;
+            phase: z.ZodEnum<{
+                registry: "registry";
+                registration: "registration";
+                discovery: "discovery";
+                runtime: "runtime";
+                revocation: "revocation";
+                cleanup: "cleanup";
+                complete: "complete";
+            }>;
+            revocation: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+            cleanup: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    operationId: z.ZodString;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    outcome: z.ZodLiteral<"pending">;
+    snapshot: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        key: z.ZodObject<{
+            providerTenantId: z.ZodString;
+            appId: z.ZodString;
+            copyId: z.ZodString;
+            resourceId: z.ZodString;
+        }, z.core.$strict>;
+        generation: z.ZodNumber;
+        identity: z.ZodNullable<z.ZodObject<{
+            registrationId: z.ZodString;
+            resourceUri: z.ZodString;
+            audience: z.ZodString;
+            issuer: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        }, z.core.$strict>>;
+        desired: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+            }>;
+            configurationRevision: z.ZodNumber;
+            policyRevision: z.ZodNumber;
+            denyEpoch: z.ZodNumber;
+            scopes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+            admission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"unrestricted">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"application-approval">;
+                policyId: z.ZodString;
+                requiredEvidence: z.ZodArray<z.ZodEnum<{
+                    provider: "provider";
+                    "authentication-method": "authentication-method";
+                    "authentication-time": "authentication-time";
+                    groups: "groups";
+                }>>;
+                returnPath: z.ZodString;
+            }, z.core.$strict>], "mode">;
+            branding: z.ZodOptional<z.ZodObject<{
+                displayName: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                locale: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        observed: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+                absent: "absent";
+                applying: "applying";
+                retiring: "retiring";
+            }>;
+            configurationRevision: z.ZodNullable<z.ZodNumber>;
+            policyRevision: z.ZodNullable<z.ZodNumber>;
+            denyEpoch: z.ZodNumber;
+            phase: z.ZodEnum<{
+                registry: "registry";
+                registration: "registration";
+                discovery: "discovery";
+                runtime: "runtime";
+                revocation: "revocation";
+                cleanup: "cleanup";
+                complete: "complete";
+            }>;
+            revocation: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+            cleanup: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    operationId: z.ZodString;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    failure: z.ZodObject<{
+        code: z.ZodEnum<{
+            retired: "retired";
+            forbidden: "forbidden";
+            "invalid-request": "invalid-request";
+            "generation-mismatch": "generation-mismatch";
+            "idempotency-mismatch": "idempotency-mismatch";
+            "revision-regression": "revision-regression";
+            "backend-unsupported": "backend-unsupported";
+            "backend-unavailable": "backend-unavailable";
+            "provider-failure": "provider-failure";
+            "invalid-response": "invalid-response";
+            "transport-failure": "transport-failure";
+        }>;
+        phase: z.ZodEnum<{
+            registry: "registry";
+            registration: "registration";
+            discovery: "discovery";
+            runtime: "runtime";
+            revocation: "revocation";
+            cleanup: "cleanup";
+            complete: "complete";
+        }>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    outcome: z.ZodLiteral<"partial">;
+    snapshot: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        key: z.ZodObject<{
+            providerTenantId: z.ZodString;
+            appId: z.ZodString;
+            copyId: z.ZodString;
+            resourceId: z.ZodString;
+        }, z.core.$strict>;
+        generation: z.ZodNumber;
+        identity: z.ZodNullable<z.ZodObject<{
+            registrationId: z.ZodString;
+            resourceUri: z.ZodString;
+            audience: z.ZodString;
+            issuer: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        }, z.core.$strict>>;
+        desired: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+            }>;
+            configurationRevision: z.ZodNumber;
+            policyRevision: z.ZodNumber;
+            denyEpoch: z.ZodNumber;
+            scopes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+            admission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"unrestricted">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"application-approval">;
+                policyId: z.ZodString;
+                requiredEvidence: z.ZodArray<z.ZodEnum<{
+                    provider: "provider";
+                    "authentication-method": "authentication-method";
+                    "authentication-time": "authentication-time";
+                    groups: "groups";
+                }>>;
+                returnPath: z.ZodString;
+            }, z.core.$strict>], "mode">;
+            branding: z.ZodOptional<z.ZodObject<{
+                displayName: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                locale: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        observed: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+                absent: "absent";
+                applying: "applying";
+                retiring: "retiring";
+            }>;
+            configurationRevision: z.ZodNullable<z.ZodNumber>;
+            policyRevision: z.ZodNullable<z.ZodNumber>;
+            denyEpoch: z.ZodNumber;
+            phase: z.ZodEnum<{
+                registry: "registry";
+                registration: "registration";
+                discovery: "discovery";
+                runtime: "runtime";
+                revocation: "revocation";
+                cleanup: "cleanup";
+                complete: "complete";
+            }>;
+            revocation: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+            cleanup: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    operationId: z.ZodString;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    failure: z.ZodObject<{
+        code: z.ZodEnum<{
+            retired: "retired";
+            forbidden: "forbidden";
+            "invalid-request": "invalid-request";
+            "generation-mismatch": "generation-mismatch";
+            "idempotency-mismatch": "idempotency-mismatch";
+            "revision-regression": "revision-regression";
+            "backend-unsupported": "backend-unsupported";
+            "backend-unavailable": "backend-unavailable";
+            "provider-failure": "provider-failure";
+            "invalid-response": "invalid-response";
+            "transport-failure": "transport-failure";
+        }>;
+        phase: z.ZodEnum<{
+            registry: "registry";
+            registration: "registration";
+            discovery: "discovery";
+            runtime: "runtime";
+            revocation: "revocation";
+            cleanup: "cleanup";
+            complete: "complete";
+        }>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    outcome: z.ZodLiteral<"conflict">;
+    snapshot: z.ZodNullable<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        key: z.ZodObject<{
+            providerTenantId: z.ZodString;
+            appId: z.ZodString;
+            copyId: z.ZodString;
+            resourceId: z.ZodString;
+        }, z.core.$strict>;
+        generation: z.ZodNumber;
+        identity: z.ZodNullable<z.ZodObject<{
+            registrationId: z.ZodString;
+            resourceUri: z.ZodString;
+            audience: z.ZodString;
+            issuer: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        }, z.core.$strict>>;
+        desired: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+            }>;
+            configurationRevision: z.ZodNumber;
+            policyRevision: z.ZodNumber;
+            denyEpoch: z.ZodNumber;
+            scopes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+            admission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"unrestricted">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"application-approval">;
+                policyId: z.ZodString;
+                requiredEvidence: z.ZodArray<z.ZodEnum<{
+                    provider: "provider";
+                    "authentication-method": "authentication-method";
+                    "authentication-time": "authentication-time";
+                    groups: "groups";
+                }>>;
+                returnPath: z.ZodString;
+            }, z.core.$strict>], "mode">;
+            branding: z.ZodOptional<z.ZodObject<{
+                displayName: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                locale: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        observed: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                suspended: "suspended";
+                retired: "retired";
+                absent: "absent";
+                applying: "applying";
+                retiring: "retiring";
+            }>;
+            configurationRevision: z.ZodNullable<z.ZodNumber>;
+            policyRevision: z.ZodNullable<z.ZodNumber>;
+            denyEpoch: z.ZodNumber;
+            phase: z.ZodEnum<{
+                registry: "registry";
+                registration: "registration";
+                discovery: "discovery";
+                runtime: "runtime";
+                revocation: "revocation";
+                cleanup: "cleanup";
+                complete: "complete";
+            }>;
+            revocation: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+            cleanup: z.ZodEnum<{
+                complete: "complete";
+                "not-required": "not-required";
+                pending: "pending";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    operationId: z.ZodString;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    failure: z.ZodObject<{
+        code: z.ZodEnum<{
+            retired: "retired";
+            forbidden: "forbidden";
+            "invalid-request": "invalid-request";
+            "generation-mismatch": "generation-mismatch";
+            "idempotency-mismatch": "idempotency-mismatch";
+            "revision-regression": "revision-regression";
+            "backend-unsupported": "backend-unsupported";
+            "backend-unavailable": "backend-unavailable";
+            "provider-failure": "provider-failure";
+            "invalid-response": "invalid-response";
+            "transport-failure": "transport-failure";
+        }>;
+        phase: z.ZodEnum<{
+            registry: "registry";
+            registration: "registration";
+            discovery: "discovery";
+            runtime: "runtime";
+            revocation: "revocation";
+            cleanup: "cleanup";
+            complete: "complete";
+        }>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    outcome: z.ZodLiteral<"refused">;
+    operationId: z.ZodString;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    failure: z.ZodObject<{
+        code: z.ZodEnum<{
+            retired: "retired";
+            forbidden: "forbidden";
+            "invalid-request": "invalid-request";
+            "generation-mismatch": "generation-mismatch";
+            "idempotency-mismatch": "idempotency-mismatch";
+            "revision-regression": "revision-regression";
+            "backend-unsupported": "backend-unsupported";
+            "backend-unavailable": "backend-unavailable";
+            "provider-failure": "provider-failure";
+            "invalid-response": "invalid-response";
+            "transport-failure": "transport-failure";
+        }>;
+        phase: z.ZodEnum<{
+            registry: "registry";
+            registration: "registration";
+            discovery: "discovery";
+            runtime: "runtime";
+            revocation: "revocation";
+            cleanup: "cleanup";
+            complete: "complete";
+        }>;
+    }, z.core.$strict>;
+    recovery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"poll-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"retry-same-operation">;
+        afterMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read-resource">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"operator-intervention">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"none">;
+    }, z.core.$strict>], "action">;
+    outcome: z.ZodLiteral<"unavailable">;
+    operationId: z.ZodString;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>], "outcome">, z.ZodObject<{
+    outcome: z.ZodLiteral<"not-found">;
+    operationId: z.ZodString;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>]>;
+export type McpResourceOperationResult = z.infer<typeof McpResourceOperationResultSchema>;
+export declare const McpResourceIntegrationSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    pathPrefix: z.ZodString;
+}, z.core.$strict>;
+export type McpResourceIntegration = z.infer<typeof McpResourceIntegrationSchema>;
+export declare const MCP_RESOURCE_ENV: {
+    readonly managementUrl: "MCP_MANAGEMENT_URL";
+    readonly managementCredential: "MCP_MANAGEMENT_CREDENTIAL";
+    readonly namespace: "MCP_RESOURCE_NAMESPACE";
+    readonly pathPrefix: "MCP_RESOURCE_PATH_PREFIX";
+};
+/** Non-secret bootstrap. The management credential is delivered separately as a server secret. */
+export declare const McpResourceBootstrapSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    managementUrl: z.ZodString;
+    namespace: z.ZodObject<{
+        providerTenantId: z.ZodString;
+        appId: z.ZodString;
+        copyId: z.ZodString;
+    }, z.core.$strict>;
+    pathPrefix: z.ZodString;
+}, z.core.$strict>;
+export type McpResourceBootstrap = z.infer<typeof McpResourceBootstrapSchema>;