@dsh-enhanced/owner-console 0.0.0-stage → 0.1.67

package/lib/typert.d.ts

@@ -0,0 +1,1307 @@
+import { z } from 'zod';
+/** `absent`: no larkChannel service; `unknown`: it exists but gave no valid health. */
+export declare const LARK_CONNECTIONS: readonly ["absent", "unknown", "connected", "connected-with-gap", "connecting", "disabled", "disconnected", "reconnecting"];
+export declare const LARK_ERROR_CODES: readonly ["format_error", "not_connected", "permission_denied", "rate_limited", "send_timeout", "ssrf_blocked", "target_revoked", "unknown", "upload_failed"];
+/**
+ * Scope-free availability of the intake agreement read. `absent`: no Evaluation service;
+ * `unknown`: it exists but the read or its switch cannot be determined; `disabled`:
+ * `intakeAttentionAgreementEnabled` is off; `available`: the switch is on. No scope or count.
+ */
+export declare const INTAKE_AGREEMENT_AVAILABILITY: readonly ["absent", "unknown", "disabled", "available"];
+export type IntakeAgreementAvailability = typeof INTAKE_AGREEMENT_AVAILABILITY[number];
+export declare const OwnerConsoleStatusSchema: z.ZodReadonly<z.ZodObject<{
+    feishu: z.ZodReadonly<z.ZodObject<{
+        entry: z.ZodOptional<z.ZodString>;
+        mode: z.ZodEnum<{
+            env: "env";
+            handle: "handle";
+        }>;
+        installed: z.ZodBoolean;
+        enabled: z.ZodBoolean;
+        appIdConfigured: z.ZodBoolean;
+        connected: z.ZodBoolean;
+        connection: z.ZodEnum<{
+            absent: "absent";
+            disabled: "disabled";
+            unknown: "unknown";
+            connected: "connected";
+            "connected-with-gap": "connected-with-gap";
+            connecting: "connecting";
+            disconnected: "disconnected";
+            reconnecting: "reconnecting";
+        }>;
+        lastErrorCode: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            format_error: "format_error";
+            not_connected: "not_connected";
+            permission_denied: "permission_denied";
+            rate_limited: "rate_limited";
+            send_timeout: "send_timeout";
+            ssrf_blocked: "ssrf_blocked";
+            target_revoked: "target_revoked";
+            upload_failed: "upload_failed";
+        }>>;
+    }, z.core.$strip>>;
+    traex: z.ZodReadonly<z.ZodObject<{
+        entry: z.ZodOptional<z.ZodString>;
+        installed: z.ZodBoolean;
+        enabled: z.ZodBoolean;
+        command: z.ZodString;
+    }, z.core.$strip>>;
+    host: z.ZodReadonly<z.ZodObject<{
+        settings: z.ZodBoolean;
+        pluginManager: z.ZodBoolean;
+        bundles: z.ZodEnum<{
+            ok: "ok";
+            unavailable: "unavailable";
+            failed: "failed";
+        }>;
+        plugins: z.ZodEnum<{
+            ok: "ok";
+            unavailable: "unavailable";
+            failed: "failed";
+        }>;
+        diagnostic: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    dependencies: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        name: z.ZodString;
+        available: z.ZodBoolean;
+    }, z.core.$strip>>>>;
+    evaluation: z.ZodReadonly<z.ZodObject<{
+        intakeAgreement: z.ZodEnum<{
+            absent: "absent";
+            disabled: "disabled";
+            available: "available";
+            unknown: "unknown";
+        }>;
+    }, z.core.$strip>>;
+    bundles: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodBoolean;
+        installed: z.ZodBoolean;
+        removable: z.ZodBoolean;
+        error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            code: z.ZodString;
+            diagnostic: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        rows: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            rowId: z.ZodString;
+            moduleName: z.ZodString;
+            entryId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>>>;
+    plugins: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        entryId: z.ZodString;
+        moduleName: z.ZodString;
+        enabled: z.ZodBoolean;
+        fiberPhase: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            loading: "loading";
+            active: "active";
+            pending: "pending";
+            unloading: "unloading";
+        }>>;
+        diagnostic: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>>;
+export type OwnerConsoleStatus = Readonly<z.infer<typeof OwnerConsoleStatusSchema>>;
+/** `pendingBuilds` names dependency build scripts the Host recorded and a confirmed retry may approve. */
+export declare const WRITE_RESULT: z.ZodReadonly<z.ZodObject<{
+    applied: z.ZodBoolean;
+    entry: z.ZodString;
+    note: z.ZodString;
+    pendingBuilds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>>;
+export type OwnerConsoleWriteResult = Readonly<z.infer<typeof WRITE_RESULT>>;
+/** Bounds of the read-only trend snapshot page; the control plane enforces the same page limit. */
+export declare const TREND_SNAPSHOT_PAGE_MAX = 100;
+export declare const TREND_FLAGS: readonly ["parallel-trend-suspect", "no-control-cohort", "concurrent-adoptions", "partial-window", "adoption-not-active"];
+/**
+ * `absent`: no control plane service; `unverifiable`: it refused the query or a sealed row failed its digest check.
+ * Observational only: `causal` is always false and nothing here adopts, promotes or revokes.
+ */
+export declare const OwnerConsoleTrendSnapshotsSchema: z.ZodReadonly<z.ZodObject<{
+    state: z.ZodEnum<{
+        ok: "ok";
+        absent: "absent";
+        unverifiable: "unverifiable";
+    }>;
+    causal: z.ZodLiteral<false>;
+    items: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        sequence: z.ZodNumber;
+        sealedAt: z.ZodNumber;
+        planId: z.ZodString;
+        digest: z.ZodString;
+        inputsDigest: z.ZodString;
+        trendDigest: z.ZodString;
+        window: z.ZodReadonly<z.ZodObject<{
+            windowMs: z.ZodNumber;
+            preWindows: z.ZodNumber;
+            postWindows: z.ZodNumber;
+            startExclusive: z.ZodNumber;
+            endInclusive: z.ZodNumber;
+            complete: z.ZodBoolean;
+        }, z.core.$strip>>;
+        cohorts: z.ZodReadonly<z.ZodObject<{
+            treatedSessions: z.ZodNumber;
+            controlSessions: z.ZodNumber;
+        }, z.core.$strip>>;
+        flags: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            "parallel-trend-suspect": "parallel-trend-suspect";
+            "no-control-cohort": "no-control-cohort";
+            "concurrent-adoptions": "concurrent-adoptions";
+            "partial-window": "partial-window";
+            "adoption-not-active": "adoption-not-active";
+        }>>>;
+        strata: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            model: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+                state: z.ZodLiteral<"frozen">;
+                provider: z.ZodString;
+                model: z.ZodString;
+                reasoningEffort: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+                state: z.ZodEnum<{
+                    missing: "missing";
+                    inconsistent: "inconsistent";
+                }>;
+            }, z.core.$strip>>]>;
+            differenceInDifferences: z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"estimated">;
+                estimate: z.ZodNumber;
+                low: z.ZodNumber;
+                high: z.ZodNumber;
+            }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+                status: z.ZodLiteral<"insufficient">;
+            }, z.core.$strip>>]>;
+            parallelTrend: z.ZodEnum<{
+                "parallel-trend-suspect": "parallel-trend-suspect";
+                "not-flagged": "not-flagged";
+                untestable: "untestable";
+            }>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>>>;
+    nextBeforeSequence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+export type OwnerConsoleTrendSnapshots = Readonly<z.infer<typeof OwnerConsoleTrendSnapshotsSchema>>;
+export type OwnerConsoleTrendSnapshotItem = OwnerConsoleTrendSnapshots['items'][number];
+/** Notification outcomes and intake levels as Evaluation's intake attention agreement reports them. */
+export declare const INTAKE_AGREEMENT_OUTCOMES: readonly ["pending", "delivered", "reacted", "accepted", "rejected", "expired-unhandled", "failed"];
+export declare const INTAKE_AGREEMENT_LEVELS: readonly ["ignore", "digest", "notify", "accept"];
+/**
+ * `absent`: no Evaluation service; `disabled`: `intakeAttentionAgreementEnabled` is off;
+ * `unverifiable`: the read was refused, failed or returned an unexpected shape.
+ * Observational only: `causal` is always false and nothing here writes, adopts or sends.
+ */
+export declare const OwnerConsoleIntakeAgreementSchema: z.ZodReadonly<z.ZodObject<{
+    state: z.ZodEnum<{
+        ok: "ok";
+        absent: "absent";
+        disabled: "disabled";
+        unverifiable: "unverifiable";
+    }>;
+    causal: z.ZodLiteral<false>;
+    summary: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        fromNotifiedAt: z.ZodNumber;
+        toNotifiedAt: z.ZodNumber;
+        scanned: z.ZodNumber;
+        truncated: z.ZodBoolean;
+        provenanceAvailable: z.ZodBoolean;
+        notIntake: z.ZodNumber;
+        unresolved: z.ZodNumber;
+        foreign: z.ZodNumber;
+        intake: z.ZodReadonly<z.ZodObject<{
+            notifications: z.ZodNumber;
+            items: z.ZodNumber;
+            outcomes: z.ZodReadonly<z.ZodObject<{
+                failed: z.ZodNumber;
+                pending: z.ZodNumber;
+                delivered: z.ZodNumber;
+                reacted: z.ZodNumber;
+                accepted: z.ZodNumber;
+                rejected: z.ZodNumber;
+                "expired-unhandled": z.ZodNumber;
+            }, z.core.$strip>>;
+            agreed: z.ZodNumber;
+            disagreed: z.ZodNumber;
+            agreementPpm: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+        byLevel: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            level: z.ZodEnum<{
+                digest: "digest";
+                ignore: "ignore";
+                notify: "notify";
+                accept: "accept";
+            }>;
+            cell: z.ZodReadonly<z.ZodObject<{
+                notifications: z.ZodNumber;
+                items: z.ZodNumber;
+                outcomes: z.ZodReadonly<z.ZodObject<{
+                    failed: z.ZodNumber;
+                    pending: z.ZodNumber;
+                    delivered: z.ZodNumber;
+                    reacted: z.ZodNumber;
+                    accepted: z.ZodNumber;
+                    rejected: z.ZodNumber;
+                    "expired-unhandled": z.ZodNumber;
+                }, z.core.$strip>>;
+                agreed: z.ZodNumber;
+                disagreed: z.ZodNumber;
+                agreementPpm: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>>;
+export type OwnerConsoleIntakeAgreement = Readonly<z.infer<typeof OwnerConsoleIntakeAgreementSchema>>;
+/** Strict Host and client descriptors: three reads plus owner-clicked one-step writes. */
+export declare const TYPERT: {
+    package: string;
+    face: "host";
+    schemas: never[];
+    invocations: ({
+        id: string;
+        service: string;
+        namespace: string;
+        method: string;
+        invocation: {
+            kind: "direct";
+        };
+        parameters: never[];
+        result: {
+            mode: "strict";
+            typeSymbol: string;
+            create: () => z.ZodType<Readonly<{
+                feishu: Readonly<{
+                    mode: "env" | "handle";
+                    installed: boolean;
+                    enabled: boolean;
+                    appIdConfigured: boolean;
+                    connected: boolean;
+                    connection: "absent" | "disabled" | "unknown" | "connected" | "connected-with-gap" | "connecting" | "disconnected" | "reconnecting";
+                    entry?: string | undefined;
+                    lastErrorCode?: "unknown" | "format_error" | "not_connected" | "permission_denied" | "rate_limited" | "send_timeout" | "ssrf_blocked" | "target_revoked" | "upload_failed" | undefined;
+                }>;
+                traex: Readonly<{
+                    installed: boolean;
+                    enabled: boolean;
+                    command: string;
+                    entry?: string | undefined;
+                }>;
+                host: Readonly<{
+                    settings: boolean;
+                    pluginManager: boolean;
+                    bundles: "ok" | "unavailable" | "failed";
+                    plugins: "ok" | "unavailable" | "failed";
+                    diagnostic?: string | undefined;
+                }>;
+                dependencies: readonly Readonly<{
+                    name: string;
+                    available: boolean;
+                }>[];
+                evaluation: Readonly<{
+                    intakeAgreement: "absent" | "disabled" | "available" | "unknown";
+                }>;
+                bundles: readonly Readonly<{
+                    name: string;
+                    enabled: boolean;
+                    installed: boolean;
+                    removable: boolean;
+                    rows: readonly Readonly<{
+                        rowId: string;
+                        moduleName: string;
+                        entryId?: string | undefined;
+                    }>[];
+                    version?: string | undefined;
+                    error?: Readonly<{
+                        code: string;
+                        diagnostic?: string | undefined;
+                    }> | undefined;
+                }>[];
+                plugins: readonly Readonly<{
+                    entryId: string;
+                    moduleName: string;
+                    enabled: boolean;
+                    fiberPhase: "failed" | "loading" | "active" | "pending" | "unloading" | null;
+                    diagnostic?: string | undefined;
+                }>[];
+            }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+                feishu: Readonly<{
+                    mode: "env" | "handle";
+                    installed: boolean;
+                    enabled: boolean;
+                    appIdConfigured: boolean;
+                    connected: boolean;
+                    connection: "absent" | "disabled" | "unknown" | "connected" | "connected-with-gap" | "connecting" | "disconnected" | "reconnecting";
+                    entry?: string | undefined;
+                    lastErrorCode?: "unknown" | "format_error" | "not_connected" | "permission_denied" | "rate_limited" | "send_timeout" | "ssrf_blocked" | "target_revoked" | "upload_failed" | undefined;
+                }>;
+                traex: Readonly<{
+                    installed: boolean;
+                    enabled: boolean;
+                    command: string;
+                    entry?: string | undefined;
+                }>;
+                host: Readonly<{
+                    settings: boolean;
+                    pluginManager: boolean;
+                    bundles: "ok" | "unavailable" | "failed";
+                    plugins: "ok" | "unavailable" | "failed";
+                    diagnostic?: string | undefined;
+                }>;
+                dependencies: readonly Readonly<{
+                    name: string;
+                    available: boolean;
+                }>[];
+                evaluation: Readonly<{
+                    intakeAgreement: "absent" | "disabled" | "available" | "unknown";
+                }>;
+                bundles: readonly Readonly<{
+                    name: string;
+                    enabled: boolean;
+                    installed: boolean;
+                    removable: boolean;
+                    rows: readonly Readonly<{
+                        rowId: string;
+                        moduleName: string;
+                        entryId?: string | undefined;
+                    }>[];
+                    version?: string | undefined;
+                    error?: Readonly<{
+                        code: string;
+                        diagnostic?: string | undefined;
+                    }> | undefined;
+                }>[];
+                plugins: readonly Readonly<{
+                    entryId: string;
+                    moduleName: string;
+                    enabled: boolean;
+                    fiberPhase: "failed" | "loading" | "active" | "pending" | "unloading" | null;
+                    diagnostic?: string | undefined;
+                }>[];
+            }>, unknown>>;
+        };
+        sourceLocation: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    } | {
+        id: string;
+        service: string;
+        namespace: string;
+        method: string;
+        invocation: {
+            kind: "direct";
+        };
+        parameters: ({
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+            };
+        } | {
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+            };
+        })[];
+        result: {
+            mode: "strict";
+            typeSymbol: string;
+            create: () => z.ZodType<Readonly<{
+                state: "ok" | "absent" | "unverifiable";
+                causal: false;
+                items: readonly Readonly<{
+                    sequence: number;
+                    sealedAt: number;
+                    planId: string;
+                    digest: string;
+                    inputsDigest: string;
+                    trendDigest: string;
+                    window: Readonly<{
+                        windowMs: number;
+                        preWindows: number;
+                        postWindows: number;
+                        startExclusive: number;
+                        endInclusive: number;
+                        complete: boolean;
+                    }>;
+                    cohorts: Readonly<{
+                        treatedSessions: number;
+                        controlSessions: number;
+                    }>;
+                    flags: readonly ("parallel-trend-suspect" | "no-control-cohort" | "concurrent-adoptions" | "partial-window" | "adoption-not-active")[];
+                    strata: readonly Readonly<{
+                        model: Readonly<{
+                            state: "frozen";
+                            provider: string;
+                            model: string;
+                            reasoningEffort?: string | undefined;
+                        }> | Readonly<{
+                            state: "missing" | "inconsistent";
+                        }>;
+                        differenceInDifferences: Readonly<{
+                            status: "estimated";
+                            estimate: number;
+                            low: number;
+                            high: number;
+                        }> | Readonly<{
+                            status: "insufficient";
+                        }>;
+                        parallelTrend: "parallel-trend-suspect" | "not-flagged" | "untestable";
+                    }>[];
+                }>[];
+                nextBeforeSequence?: number | undefined;
+            }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+                state: "ok" | "absent" | "unverifiable";
+                causal: false;
+                items: readonly Readonly<{
+                    sequence: number;
+                    sealedAt: number;
+                    planId: string;
+                    digest: string;
+                    inputsDigest: string;
+                    trendDigest: string;
+                    window: Readonly<{
+                        windowMs: number;
+                        preWindows: number;
+                        postWindows: number;
+                        startExclusive: number;
+                        endInclusive: number;
+                        complete: boolean;
+                    }>;
+                    cohorts: Readonly<{
+                        treatedSessions: number;
+                        controlSessions: number;
+                    }>;
+                    flags: readonly ("parallel-trend-suspect" | "no-control-cohort" | "concurrent-adoptions" | "partial-window" | "adoption-not-active")[];
+                    strata: readonly Readonly<{
+                        model: Readonly<{
+                            state: "frozen";
+                            provider: string;
+                            model: string;
+                            reasoningEffort?: string | undefined;
+                        }> | Readonly<{
+                            state: "missing" | "inconsistent";
+                        }>;
+                        differenceInDifferences: Readonly<{
+                            status: "estimated";
+                            estimate: number;
+                            low: number;
+                            high: number;
+                        }> | Readonly<{
+                            status: "insufficient";
+                        }>;
+                        parallelTrend: "parallel-trend-suspect" | "not-flagged" | "untestable";
+                    }>[];
+                }>[];
+                nextBeforeSequence?: number | undefined;
+            }>, unknown>>;
+        };
+        sourceLocation: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    } | {
+        id: string;
+        service: string;
+        namespace: string;
+        method: string;
+        invocation: {
+            kind: "direct";
+        };
+        parameters: {
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+            };
+        }[];
+        result: {
+            mode: "strict";
+            typeSymbol: string;
+            create: () => z.ZodType<Readonly<{
+                state: "ok" | "absent" | "disabled" | "unverifiable";
+                causal: false;
+                summary?: Readonly<{
+                    fromNotifiedAt: number;
+                    toNotifiedAt: number;
+                    scanned: number;
+                    truncated: boolean;
+                    provenanceAvailable: boolean;
+                    notIntake: number;
+                    unresolved: number;
+                    foreign: number;
+                    intake: Readonly<{
+                        notifications: number;
+                        items: number;
+                        outcomes: Readonly<{
+                            failed: number;
+                            pending: number;
+                            delivered: number;
+                            reacted: number;
+                            accepted: number;
+                            rejected: number;
+                            "expired-unhandled": number;
+                        }>;
+                        agreed: number;
+                        disagreed: number;
+                        agreementPpm: number | null;
+                    }>;
+                    byLevel: readonly Readonly<{
+                        level: "digest" | "ignore" | "notify" | "accept";
+                        cell: Readonly<{
+                            notifications: number;
+                            items: number;
+                            outcomes: Readonly<{
+                                failed: number;
+                                pending: number;
+                                delivered: number;
+                                reacted: number;
+                                accepted: number;
+                                rejected: number;
+                                "expired-unhandled": number;
+                            }>;
+                            agreed: number;
+                            disagreed: number;
+                            agreementPpm: number | null;
+                        }>;
+                    }>[];
+                }> | undefined;
+            }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+                state: "ok" | "absent" | "disabled" | "unverifiable";
+                causal: false;
+                summary?: Readonly<{
+                    fromNotifiedAt: number;
+                    toNotifiedAt: number;
+                    scanned: number;
+                    truncated: boolean;
+                    provenanceAvailable: boolean;
+                    notIntake: number;
+                    unresolved: number;
+                    foreign: number;
+                    intake: Readonly<{
+                        notifications: number;
+                        items: number;
+                        outcomes: Readonly<{
+                            failed: number;
+                            pending: number;
+                            delivered: number;
+                            reacted: number;
+                            accepted: number;
+                            rejected: number;
+                            "expired-unhandled": number;
+                        }>;
+                        agreed: number;
+                        disagreed: number;
+                        agreementPpm: number | null;
+                    }>;
+                    byLevel: readonly Readonly<{
+                        level: "digest" | "ignore" | "notify" | "accept";
+                        cell: Readonly<{
+                            notifications: number;
+                            items: number;
+                            outcomes: Readonly<{
+                                failed: number;
+                                pending: number;
+                                delivered: number;
+                                reacted: number;
+                                accepted: number;
+                                rejected: number;
+                                "expired-unhandled": number;
+                            }>;
+                            agreed: number;
+                            disagreed: number;
+                            agreementPpm: number | null;
+                        }>;
+                    }>[];
+                }> | undefined;
+            }>, unknown>>;
+        };
+        sourceLocation: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    } | {
+        id: string;
+        service: string;
+        namespace: string;
+        method: string;
+        invocation: {
+            kind: "direct";
+        };
+        parameters: ({
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+            };
+        } | {
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<boolean, unknown, z.core.$ZodTypeInternals<boolean, unknown>>;
+            };
+        })[];
+        result: {
+            mode: "strict";
+            typeSymbol: string;
+            create: () => z.ZodType<Readonly<{
+                applied: boolean;
+                entry: string;
+                note: string;
+                pendingBuilds?: readonly string[] | undefined;
+            }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+                applied: boolean;
+                entry: string;
+                note: string;
+                pendingBuilds?: readonly string[] | undefined;
+            }>, unknown>>;
+        };
+        sourceLocation: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    } | {
+        id: string;
+        service: string;
+        namespace: string;
+        method: string;
+        invocation: {
+            kind: "direct";
+        };
+        parameters: ({
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+            };
+        } | {
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>;
+            };
+        })[];
+        result: {
+            mode: "strict";
+            typeSymbol: string;
+            create: () => z.ZodType<Readonly<{
+                applied: boolean;
+                entry: string;
+                note: string;
+                pendingBuilds?: readonly string[] | undefined;
+            }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+                applied: boolean;
+                entry: string;
+                note: string;
+                pendingBuilds?: readonly string[] | undefined;
+            }>, unknown>>;
+        };
+        sourceLocation: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    } | {
+        id: string;
+        service: string;
+        namespace: string;
+        method: string;
+        invocation: {
+            kind: "direct";
+        };
+        parameters: ({
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+            };
+        } | {
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            };
+        })[];
+        result: {
+            mode: "strict";
+            typeSymbol: string;
+            create: () => z.ZodType<Readonly<{
+                applied: boolean;
+                entry: string;
+                note: string;
+                pendingBuilds?: readonly string[] | undefined;
+            }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+                applied: boolean;
+                entry: string;
+                note: string;
+                pendingBuilds?: readonly string[] | undefined;
+            }>, unknown>>;
+        };
+        sourceLocation: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    })[];
+    model: {
+        services: never[];
+        events: never[];
+        objects: never[];
+    };
+};
+/** The generated client shape is bundled into the Web module by build-client. */
+export declare const TYPERT_REMOTE: {
+    package: string;
+    descriptors: ({
+        id: string;
+        service: string;
+        namespace: string;
+        method: string;
+        invocation: {
+            kind: "direct";
+        };
+        parameters: never[];
+        result: {
+            mode: "strict";
+            typeSymbol: string;
+            create: () => z.ZodType<Readonly<{
+                feishu: Readonly<{
+                    mode: "env" | "handle";
+                    installed: boolean;
+                    enabled: boolean;
+                    appIdConfigured: boolean;
+                    connected: boolean;
+                    connection: "absent" | "disabled" | "unknown" | "connected" | "connected-with-gap" | "connecting" | "disconnected" | "reconnecting";
+                    entry?: string | undefined;
+                    lastErrorCode?: "unknown" | "format_error" | "not_connected" | "permission_denied" | "rate_limited" | "send_timeout" | "ssrf_blocked" | "target_revoked" | "upload_failed" | undefined;
+                }>;
+                traex: Readonly<{
+                    installed: boolean;
+                    enabled: boolean;
+                    command: string;
+                    entry?: string | undefined;
+                }>;
+                host: Readonly<{
+                    settings: boolean;
+                    pluginManager: boolean;
+                    bundles: "ok" | "unavailable" | "failed";
+                    plugins: "ok" | "unavailable" | "failed";
+                    diagnostic?: string | undefined;
+                }>;
+                dependencies: readonly Readonly<{
+                    name: string;
+                    available: boolean;
+                }>[];
+                evaluation: Readonly<{
+                    intakeAgreement: "absent" | "disabled" | "available" | "unknown";
+                }>;
+                bundles: readonly Readonly<{
+                    name: string;
+                    enabled: boolean;
+                    installed: boolean;
+                    removable: boolean;
+                    rows: readonly Readonly<{
+                        rowId: string;
+                        moduleName: string;
+                        entryId?: string | undefined;
+                    }>[];
+                    version?: string | undefined;
+                    error?: Readonly<{
+                        code: string;
+                        diagnostic?: string | undefined;
+                    }> | undefined;
+                }>[];
+                plugins: readonly Readonly<{
+                    entryId: string;
+                    moduleName: string;
+                    enabled: boolean;
+                    fiberPhase: "failed" | "loading" | "active" | "pending" | "unloading" | null;
+                    diagnostic?: string | undefined;
+                }>[];
+            }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+                feishu: Readonly<{
+                    mode: "env" | "handle";
+                    installed: boolean;
+                    enabled: boolean;
+                    appIdConfigured: boolean;
+                    connected: boolean;
+                    connection: "absent" | "disabled" | "unknown" | "connected" | "connected-with-gap" | "connecting" | "disconnected" | "reconnecting";
+                    entry?: string | undefined;
+                    lastErrorCode?: "unknown" | "format_error" | "not_connected" | "permission_denied" | "rate_limited" | "send_timeout" | "ssrf_blocked" | "target_revoked" | "upload_failed" | undefined;
+                }>;
+                traex: Readonly<{
+                    installed: boolean;
+                    enabled: boolean;
+                    command: string;
+                    entry?: string | undefined;
+                }>;
+                host: Readonly<{
+                    settings: boolean;
+                    pluginManager: boolean;
+                    bundles: "ok" | "unavailable" | "failed";
+                    plugins: "ok" | "unavailable" | "failed";
+                    diagnostic?: string | undefined;
+                }>;
+                dependencies: readonly Readonly<{
+                    name: string;
+                    available: boolean;
+                }>[];
+                evaluation: Readonly<{
+                    intakeAgreement: "absent" | "disabled" | "available" | "unknown";
+                }>;
+                bundles: readonly Readonly<{
+                    name: string;
+                    enabled: boolean;
+                    installed: boolean;
+                    removable: boolean;
+                    rows: readonly Readonly<{
+                        rowId: string;
+                        moduleName: string;
+                        entryId?: string | undefined;
+                    }>[];
+                    version?: string | undefined;
+                    error?: Readonly<{
+                        code: string;
+                        diagnostic?: string | undefined;
+                    }> | undefined;
+                }>[];
+                plugins: readonly Readonly<{
+                    entryId: string;
+                    moduleName: string;
+                    enabled: boolean;
+                    fiberPhase: "failed" | "loading" | "active" | "pending" | "unloading" | null;
+                    diagnostic?: string | undefined;
+                }>[];
+            }>, unknown>>;
+        };
+        sourceLocation: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    } | {
+        id: string;
+        service: string;
+        namespace: string;
+        method: string;
+        invocation: {
+            kind: "direct";
+        };
+        parameters: ({
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+            };
+        } | {
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+            };
+        })[];
+        result: {
+            mode: "strict";
+            typeSymbol: string;
+            create: () => z.ZodType<Readonly<{
+                state: "ok" | "absent" | "unverifiable";
+                causal: false;
+                items: readonly Readonly<{
+                    sequence: number;
+                    sealedAt: number;
+                    planId: string;
+                    digest: string;
+                    inputsDigest: string;
+                    trendDigest: string;
+                    window: Readonly<{
+                        windowMs: number;
+                        preWindows: number;
+                        postWindows: number;
+                        startExclusive: number;
+                        endInclusive: number;
+                        complete: boolean;
+                    }>;
+                    cohorts: Readonly<{
+                        treatedSessions: number;
+                        controlSessions: number;
+                    }>;
+                    flags: readonly ("parallel-trend-suspect" | "no-control-cohort" | "concurrent-adoptions" | "partial-window" | "adoption-not-active")[];
+                    strata: readonly Readonly<{
+                        model: Readonly<{
+                            state: "frozen";
+                            provider: string;
+                            model: string;
+                            reasoningEffort?: string | undefined;
+                        }> | Readonly<{
+                            state: "missing" | "inconsistent";
+                        }>;
+                        differenceInDifferences: Readonly<{
+                            status: "estimated";
+                            estimate: number;
+                            low: number;
+                            high: number;
+                        }> | Readonly<{
+                            status: "insufficient";
+                        }>;
+                        parallelTrend: "parallel-trend-suspect" | "not-flagged" | "untestable";
+                    }>[];
+                }>[];
+                nextBeforeSequence?: number | undefined;
+            }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+                state: "ok" | "absent" | "unverifiable";
+                causal: false;
+                items: readonly Readonly<{
+                    sequence: number;
+                    sealedAt: number;
+                    planId: string;
+                    digest: string;
+                    inputsDigest: string;
+                    trendDigest: string;
+                    window: Readonly<{
+                        windowMs: number;
+                        preWindows: number;
+                        postWindows: number;
+                        startExclusive: number;
+                        endInclusive: number;
+                        complete: boolean;
+                    }>;
+                    cohorts: Readonly<{
+                        treatedSessions: number;
+                        controlSessions: number;
+                    }>;
+                    flags: readonly ("parallel-trend-suspect" | "no-control-cohort" | "concurrent-adoptions" | "partial-window" | "adoption-not-active")[];
+                    strata: readonly Readonly<{
+                        model: Readonly<{
+                            state: "frozen";
+                            provider: string;
+                            model: string;
+                            reasoningEffort?: string | undefined;
+                        }> | Readonly<{
+                            state: "missing" | "inconsistent";
+                        }>;
+                        differenceInDifferences: Readonly<{
+                            status: "estimated";
+                            estimate: number;
+                            low: number;
+                            high: number;
+                        }> | Readonly<{
+                            status: "insufficient";
+                        }>;
+                        parallelTrend: "parallel-trend-suspect" | "not-flagged" | "untestable";
+                    }>[];
+                }>[];
+                nextBeforeSequence?: number | undefined;
+            }>, unknown>>;
+        };
+        sourceLocation: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    } | {
+        id: string;
+        service: string;
+        namespace: string;
+        method: string;
+        invocation: {
+            kind: "direct";
+        };
+        parameters: {
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+            };
+        }[];
+        result: {
+            mode: "strict";
+            typeSymbol: string;
+            create: () => z.ZodType<Readonly<{
+                state: "ok" | "absent" | "disabled" | "unverifiable";
+                causal: false;
+                summary?: Readonly<{
+                    fromNotifiedAt: number;
+                    toNotifiedAt: number;
+                    scanned: number;
+                    truncated: boolean;
+                    provenanceAvailable: boolean;
+                    notIntake: number;
+                    unresolved: number;
+                    foreign: number;
+                    intake: Readonly<{
+                        notifications: number;
+                        items: number;
+                        outcomes: Readonly<{
+                            failed: number;
+                            pending: number;
+                            delivered: number;
+                            reacted: number;
+                            accepted: number;
+                            rejected: number;
+                            "expired-unhandled": number;
+                        }>;
+                        agreed: number;
+                        disagreed: number;
+                        agreementPpm: number | null;
+                    }>;
+                    byLevel: readonly Readonly<{
+                        level: "digest" | "ignore" | "notify" | "accept";
+                        cell: Readonly<{
+                            notifications: number;
+                            items: number;
+                            outcomes: Readonly<{
+                                failed: number;
+                                pending: number;
+                                delivered: number;
+                                reacted: number;
+                                accepted: number;
+                                rejected: number;
+                                "expired-unhandled": number;
+                            }>;
+                            agreed: number;
+                            disagreed: number;
+                            agreementPpm: number | null;
+                        }>;
+                    }>[];
+                }> | undefined;
+            }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+                state: "ok" | "absent" | "disabled" | "unverifiable";
+                causal: false;
+                summary?: Readonly<{
+                    fromNotifiedAt: number;
+                    toNotifiedAt: number;
+                    scanned: number;
+                    truncated: boolean;
+                    provenanceAvailable: boolean;
+                    notIntake: number;
+                    unresolved: number;
+                    foreign: number;
+                    intake: Readonly<{
+                        notifications: number;
+                        items: number;
+                        outcomes: Readonly<{
+                            failed: number;
+                            pending: number;
+                            delivered: number;
+                            reacted: number;
+                            accepted: number;
+                            rejected: number;
+                            "expired-unhandled": number;
+                        }>;
+                        agreed: number;
+                        disagreed: number;
+                        agreementPpm: number | null;
+                    }>;
+                    byLevel: readonly Readonly<{
+                        level: "digest" | "ignore" | "notify" | "accept";
+                        cell: Readonly<{
+                            notifications: number;
+                            items: number;
+                            outcomes: Readonly<{
+                                failed: number;
+                                pending: number;
+                                delivered: number;
+                                reacted: number;
+                                accepted: number;
+                                rejected: number;
+                                "expired-unhandled": number;
+                            }>;
+                            agreed: number;
+                            disagreed: number;
+                            agreementPpm: number | null;
+                        }>;
+                    }>[];
+                }> | undefined;
+            }>, unknown>>;
+        };
+        sourceLocation: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    } | {
+        id: string;
+        service: string;
+        namespace: string;
+        method: string;
+        invocation: {
+            kind: "direct";
+        };
+        parameters: ({
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+            };
+        } | {
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<boolean, unknown, z.core.$ZodTypeInternals<boolean, unknown>>;
+            };
+        })[];
+        result: {
+            mode: "strict";
+            typeSymbol: string;
+            create: () => z.ZodType<Readonly<{
+                applied: boolean;
+                entry: string;
+                note: string;
+                pendingBuilds?: readonly string[] | undefined;
+            }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+                applied: boolean;
+                entry: string;
+                note: string;
+                pendingBuilds?: readonly string[] | undefined;
+            }>, unknown>>;
+        };
+        sourceLocation: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    } | {
+        id: string;
+        service: string;
+        namespace: string;
+        method: string;
+        invocation: {
+            kind: "direct";
+        };
+        parameters: ({
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+            };
+        } | {
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>;
+            };
+        })[];
+        result: {
+            mode: "strict";
+            typeSymbol: string;
+            create: () => z.ZodType<Readonly<{
+                applied: boolean;
+                entry: string;
+                note: string;
+                pendingBuilds?: readonly string[] | undefined;
+            }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+                applied: boolean;
+                entry: string;
+                note: string;
+                pendingBuilds?: readonly string[] | undefined;
+            }>, unknown>>;
+        };
+        sourceLocation: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    } | {
+        id: string;
+        service: string;
+        namespace: string;
+        method: string;
+        invocation: {
+            kind: "direct";
+        };
+        parameters: ({
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+            };
+        } | {
+            name: string;
+            wire: string;
+            source: "json";
+            codec: {
+                mode: "strict";
+                typeSymbol: string;
+                create: () => z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            };
+        })[];
+        result: {
+            mode: "strict";
+            typeSymbol: string;
+            create: () => z.ZodType<Readonly<{
+                applied: boolean;
+                entry: string;
+                note: string;
+                pendingBuilds?: readonly string[] | undefined;
+            }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+                applied: boolean;
+                entry: string;
+                note: string;
+                pendingBuilds?: readonly string[] | undefined;
+            }>, unknown>>;
+        };
+        sourceLocation: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    })[];
+};
+//# sourceMappingURL=typert.d.ts.map