kennel 0.2.12 → 0.2.15

package/node_modules/@agentclientprotocol/sdk/dist/v2/schema/guards.gen.js

@@ -1,1035 +0,0 @@
-// This file is auto-generated by scripts/generate.js
-import * as z from "zod/v4";
-import * as validate from "./zod.gen.js";
-function tagOf(value, key) {
-    return typeof value === "object" && value !== null
-        ? value[key]
-        : undefined;
-}
-const zGuardRequestPermissionSubjectToolCall = validate.zToolCallPermissionSubject.and(z.object({ type: z.literal("tool_call") }));
-const zGuardRequestPermissionSubjectCommand = validate.zCommandPermissionSubject.and(z.object({ type: z.literal("command") }));
-const zGuardToolCallContentContent = validate.zContent.and(z.object({ type: z.literal("content") }));
-const zGuardToolCallContentDiff = validate.zDiff.and(z.object({ type: z.literal("diff") }));
-const zGuardToolCallContentTerminal = validate.zTerminal.and(z.object({ type: z.literal("terminal") }));
-const zGuardContentBlockText = validate.zTextContent.and(z.object({ type: z.literal("text") }));
-const zGuardContentBlockImage = validate.zImageContent.and(z.object({ type: z.literal("image") }));
-const zGuardContentBlockAudio = validate.zAudioContent.and(z.object({ type: z.literal("audio") }));
-const zGuardContentBlockResourceLink = validate.zResourceLink.and(z.object({ type: z.literal("resource_link") }));
-const zGuardContentBlockResource = validate.zEmbeddedResource.and(z.object({ type: z.literal("resource") }));
-const zGuardDiffChangeAdd = validate.zDiffPathChange.and(z.object({ operation: z.literal("add") }));
-const zGuardDiffChangeDelete = validate.zDiffPathChange.and(z.object({ operation: z.literal("delete") }));
-const zGuardDiffChangeModify = validate.zDiffPathChange.and(z.object({ operation: z.literal("modify") }));
-const zGuardDiffChangeMove = validate.zDiffPathPairChange.and(z.object({ operation: z.literal("move") }));
-const zGuardDiffChangeCopy = validate.zDiffPathPairChange.and(z.object({ operation: z.literal("copy") }));
-const zGuardCreateElicitationRequestForm = validate.zElicitationFormMode
-    .and(z.object({ mode: z.literal("form") }))
-    .and(z.object({ message: z.string() }));
-const zGuardCreateElicitationRequestUrl = validate.zElicitationUrlMode
-    .and(z.object({ mode: z.literal("url") }))
-    .and(z.object({ message: z.string() }));
-const zGuardCreateElicitationRequestCustom = z
-    .union([validate.zElicitationSessionScope, validate.zElicitationRequestScope])
-    .and(z.object({ message: z.string() }));
-const zGuardElicitationPropertySchemaString = validate.zStringPropertySchema.and(z.object({ type: z.literal("string") }));
-const zGuardElicitationPropertySchemaNumber = validate.zNumberPropertySchema.and(z.object({ type: z.literal("number") }));
-const zGuardElicitationPropertySchemaInteger = validate.zIntegerPropertySchema.and(z.object({ type: z.literal("integer") }));
-const zGuardElicitationPropertySchemaBoolean = validate.zBooleanPropertySchema.and(z.object({ type: z.literal("boolean") }));
-const zGuardElicitationPropertySchemaArray = validate.zMultiSelectPropertySchema.and(z.object({ type: z.literal("array") }));
-const zGuardMultiSelectItemsString = validate.zStringMultiSelectItems.and(z.object({ type: z.literal("string") }));
-const zGuardMultiSelectItemsTitled = validate.zTitledMultiSelectItems;
-const zGuardAuthMethodEnvVar = validate.zAuthMethodEnvVar.and(z.object({ type: z.literal("env_var") }));
-const zGuardAuthMethodTerminal = validate.zAuthMethodTerminal.and(z.object({ type: z.literal("terminal") }));
-const zGuardAuthMethodAgent = validate.zAuthMethodAgent.and(z.object({ type: z.literal("agent") }));
-const zGuardAuthMethodCustom = z.object({
-    methodId: validate.zAuthMethodId,
-    name: z.string(),
-});
-const zGuardSessionConfigOptionSelect = validate.zSessionConfigSelect
-    .and(z.object({ type: z.literal("select") }))
-    .and(z.object({ configId: validate.zSessionConfigId, name: z.string() }));
-const zGuardSessionConfigOptionBoolean = validate.zSessionConfigBoolean
-    .and(z.object({ type: z.literal("boolean") }))
-    .and(z.object({ configId: validate.zSessionConfigId, name: z.string() }));
-const zGuardSessionConfigOptionCustom = z.object({
-    configId: validate.zSessionConfigId,
-    name: z.string(),
-});
-const zGuardNesSuggestionEdit = validate.zNesEditSuggestion.and(z.object({ kind: z.literal("edit") }));
-const zGuardNesSuggestionJump = validate.zNesJumpSuggestion.and(z.object({ kind: z.literal("jump") }));
-const zGuardNesSuggestionRename = validate.zNesRenameSuggestion.and(z.object({ kind: z.literal("rename") }));
-const zGuardNesSuggestionSearchAndReplace = validate.zNesSearchAndReplaceSuggestion.and(z.object({ kind: z.literal("searchAndReplace") }));
-const zGuardNesSuggestionCustom = z.object({
-    suggestionId: validate.zNesSuggestionId,
-});
-const zGuardSessionUpdateUserMessageChunk = validate.zContentChunk.and(z.object({ sessionUpdate: z.literal("user_message_chunk") }));
-const zGuardSessionUpdateUserMessage = validate.zUserMessage.and(z.object({ sessionUpdate: z.literal("user_message") }));
-const zGuardSessionUpdateAgentMessageChunk = validate.zContentChunk.and(z.object({ sessionUpdate: z.literal("agent_message_chunk") }));
-const zGuardSessionUpdateAgentMessage = validate.zAgentMessage.and(z.object({ sessionUpdate: z.literal("agent_message") }));
-const zGuardSessionUpdateAgentThoughtChunk = validate.zContentChunk.and(z.object({ sessionUpdate: z.literal("agent_thought_chunk") }));
-const zGuardSessionUpdateAgentThought = validate.zAgentThought.and(z.object({ sessionUpdate: z.literal("agent_thought") }));
-const zGuardSessionUpdateStateUpdate = validate.zStateUpdate.and(z.object({ sessionUpdate: z.literal("state_update") }));
-const zGuardSessionUpdateToolCallContentChunk = validate.zToolCallContentChunk.and(z.object({ sessionUpdate: z.literal("tool_call_content_chunk") }));
-const zGuardSessionUpdateToolCallUpdate = validate.zToolCallUpdate.and(z.object({ sessionUpdate: z.literal("tool_call_update") }));
-const zGuardSessionUpdateTerminalUpdate = validate.zTerminalUpdate.and(z.object({ sessionUpdate: z.literal("terminal_update") }));
-const zGuardSessionUpdateTerminalOutputChunk = validate.zTerminalOutputChunk.and(z.object({ sessionUpdate: z.literal("terminal_output_chunk") }));
-const zGuardSessionUpdatePlanUpdate = validate.zPlanUpdate.and(z.object({ sessionUpdate: z.literal("plan_update") }));
-const zGuardSessionUpdatePlanRemoved = validate.zPlanRemoved.and(z.object({ sessionUpdate: z.literal("plan_removed") }));
-const zGuardSessionUpdateAvailableCommandsUpdate = validate.zAvailableCommandsUpdate.and(z.object({ sessionUpdate: z.literal("available_commands_update") }));
-const zGuardSessionUpdateConfigOptionUpdate = validate.zConfigOptionUpdate.and(z.object({ sessionUpdate: z.literal("config_option_update") }));
-const zGuardSessionUpdateSessionInfoUpdate = validate.zSessionInfoUpdate.and(z.object({ sessionUpdate: z.literal("session_info_update") }));
-const zGuardSessionUpdateUsageUpdate = validate.zUsageUpdate.and(z.object({ sessionUpdate: z.literal("usage_update") }));
-const zGuardStateUpdateRunning = validate.zRunningStateUpdate.and(z.object({ state: z.literal("running") }));
-const zGuardStateUpdateIdle = validate.zIdleStateUpdate.and(z.object({ state: z.literal("idle") }));
-const zGuardStateUpdateRequiresAction = validate.zRequiresActionStateUpdate.and(z.object({ state: z.literal("requires_action") }));
-const zGuardPlanUpdateContentItems = validate.zPlanItems.and(z.object({ type: z.literal("items") }));
-const zGuardPlanUpdateContentFile = validate.zPlanFile.and(z.object({ type: z.literal("file") }));
-const zGuardPlanUpdateContentMarkdown = validate.zPlanMarkdown.and(z.object({ type: z.literal("markdown") }));
-const zGuardPlanUpdateContentCustom = z.object({ planId: validate.zPlanId });
-const zGuardAvailableCommandInputText = validate.zTextCommandInput.and(z.object({ type: z.literal("text") }));
-const zGuardMcpServerHttp = validate.zMcpServerHttp.and(z.object({ type: z.literal("http") }));
-const zGuardMcpServerAcp = validate.zMcpServerAcp.and(z.object({ type: z.literal("acp") }));
-const zGuardMcpServerStdio = validate.zMcpServerStdio.and(z.object({ type: z.literal("stdio") }));
-const zGuardReplayFromStart = validate.zReplayFromStart.and(z.object({ type: z.literal("start") }));
-const zGuardSetSessionConfigOptionRequestId = z
-    .object({ type: z.literal("id") })
-    .and(z.object({ value: validate.zSessionConfigValueId }))
-    .and(z.object({
-    sessionId: validate.zSessionId,
-    configId: validate.zSessionConfigId,
-}));
-const zGuardSetSessionConfigOptionRequestBoolean = z
-    .object({ type: z.literal("boolean") })
-    .and(z.object({ value: z.boolean() }))
-    .and(z.object({
-    sessionId: validate.zSessionId,
-    configId: validate.zSessionConfigId,
-}));
-const zGuardSetSessionConfigOptionRequestCustom = z
-    .object({ value: z.unknown() })
-    .and(z.object({
-    sessionId: validate.zSessionId,
-    configId: validate.zSessionConfigId,
-}));
-const zGuardRequestPermissionOutcomeCancelled = z.object({
-    outcome: z.literal("cancelled"),
-});
-const zGuardRequestPermissionOutcomeSelected = validate.zSelectedPermissionOutcome.and(z.object({ outcome: z.literal("selected") }));
-const zGuardCreateElicitationResponseAccept = validate.zElicitationAcceptAction.and(z.object({ action: z.literal("accept") }));
-const zGuardCreateElicitationResponseDecline = z.object({
-    action: z.literal("decline"),
-});
-const zGuardCreateElicitationResponseCancel = z.object({
-    action: z.literal("cancel"),
-});
-/**
- * Validated type guards for `RequestPermissionSubject`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const RequestPermissionSubject = {
-    /** Narrow to the `tool_call` variant, validating its payload. */
-    isToolCall(value) {
-        return (tagOf(value, "type") === "tool_call" &&
-            zGuardRequestPermissionSubjectToolCall.safeParse(value).success);
-    },
-    /** Narrow to the `command` variant, validating its payload. */
-    isCommand(value) {
-        return (tagOf(value, "type") === "command" &&
-            zGuardRequestPermissionSubjectCommand.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `type` tag matches no known variant.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "type");
-        return typeof tag === "string" && !["command", "tool_call"].includes(tag);
-    },
-};
-/**
- * Validated type guards for `ToolCallContent`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const ToolCallContent = {
-    /** Narrow to the `content` variant, validating its payload. */
-    isContent(value) {
-        return (tagOf(value, "type") === "content" &&
-            zGuardToolCallContentContent.safeParse(value).success);
-    },
-    /** Narrow to the `diff` variant, validating its payload. */
-    isDiff(value) {
-        return (tagOf(value, "type") === "diff" &&
-            zGuardToolCallContentDiff.safeParse(value).success);
-    },
-    /** Narrow to the `terminal` variant, validating its payload. */
-    isTerminal(value) {
-        return (tagOf(value, "type") === "terminal" &&
-            zGuardToolCallContentTerminal.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `type` tag matches no known variant.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "type");
-        return (typeof tag === "string" && !["content", "diff", "terminal"].includes(tag));
-    },
-};
-/**
- * Validated type guards for `ContentBlock`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const ContentBlock = {
-    /** Narrow to the `text` variant, validating its payload. */
-    isText(value) {
-        return (tagOf(value, "type") === "text" &&
-            zGuardContentBlockText.safeParse(value).success);
-    },
-    /** Narrow to the `image` variant, validating its payload. */
-    isImage(value) {
-        return (tagOf(value, "type") === "image" &&
-            zGuardContentBlockImage.safeParse(value).success);
-    },
-    /** Narrow to the `audio` variant, validating its payload. */
-    isAudio(value) {
-        return (tagOf(value, "type") === "audio" &&
-            zGuardContentBlockAudio.safeParse(value).success);
-    },
-    /** Narrow to the `resource_link` variant, validating its payload. */
-    isResourceLink(value) {
-        return (tagOf(value, "type") === "resource_link" &&
-            zGuardContentBlockResourceLink.safeParse(value).success);
-    },
-    /** Narrow to the `resource` variant, validating its payload. */
-    isResource(value) {
-        return (tagOf(value, "type") === "resource" &&
-            zGuardContentBlockResource.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `type` tag matches no known variant.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "type");
-        return (typeof tag === "string" &&
-            !["audio", "image", "resource", "resource_link", "text"].includes(tag));
-    },
-};
-/**
- * Validated type guards for `DiffChange`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const DiffChange = {
-    /** Narrow to the `add` variant, validating its payload. */
-    isAdd(value) {
-        return (tagOf(value, "operation") === "add" &&
-            zGuardDiffChangeAdd.safeParse(value).success);
-    },
-    /** Narrow to the `delete` variant, validating its payload. */
-    isDelete(value) {
-        return (tagOf(value, "operation") === "delete" &&
-            zGuardDiffChangeDelete.safeParse(value).success);
-    },
-    /** Narrow to the `modify` variant, validating its payload. */
-    isModify(value) {
-        return (tagOf(value, "operation") === "modify" &&
-            zGuardDiffChangeModify.safeParse(value).success);
-    },
-    /** Narrow to the `move` variant, validating its payload. */
-    isMove(value) {
-        return (tagOf(value, "operation") === "move" &&
-            zGuardDiffChangeMove.safeParse(value).success);
-    },
-    /** Narrow to the `copy` variant, validating its payload. */
-    isCopy(value) {
-        return (tagOf(value, "operation") === "copy" &&
-            zGuardDiffChangeCopy.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `operation` tag matches no known variant.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "operation");
-        return (typeof tag === "string" &&
-            !["add", "copy", "delete", "modify", "move"].includes(tag));
-    },
-};
-/**
- * Validated type guards for `CreateElicitationRequest`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- *
- * @experimental
- */
-export const CreateElicitationRequest = {
-    /** Narrow to the `form` variant, validating its payload. */
-    isForm(value) {
-        return (tagOf(value, "mode") === "form" &&
-            zGuardCreateElicitationRequestForm.safeParse(value).success);
-    },
-    /** Narrow to the `url` variant, validating its payload. */
-    isUrl(value) {
-        return (tagOf(value, "mode") === "url" &&
-            zGuardCreateElicitationRequestUrl.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `mode` tag matches no known variant, with a valid payload.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "mode");
-        return (typeof tag === "string" &&
-            !["form", "url"].includes(tag) &&
-            zGuardCreateElicitationRequestCustom.safeParse(value).success);
-    },
-};
-/**
- * Validated type guards for `ElicitationPropertySchema`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const ElicitationPropertySchema = {
-    /** Narrow to the `string` variant, validating its payload. */
-    isString(value) {
-        return (tagOf(value, "type") === "string" &&
-            zGuardElicitationPropertySchemaString.safeParse(value).success);
-    },
-    /** Narrow to the `number` variant, validating its payload. */
-    isNumber(value) {
-        return (tagOf(value, "type") === "number" &&
-            zGuardElicitationPropertySchemaNumber.safeParse(value).success);
-    },
-    /** Narrow to the `integer` variant, validating its payload. */
-    isInteger(value) {
-        return (tagOf(value, "type") === "integer" &&
-            zGuardElicitationPropertySchemaInteger.safeParse(value).success);
-    },
-    /** Narrow to the `boolean` variant, validating its payload. */
-    isBoolean(value) {
-        return (tagOf(value, "type") === "boolean" &&
-            zGuardElicitationPropertySchemaBoolean.safeParse(value).success);
-    },
-    /** Narrow to the `array` variant, validating its payload. */
-    isArray(value) {
-        return (tagOf(value, "type") === "array" &&
-            zGuardElicitationPropertySchemaArray.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `type` tag matches no known variant.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "type");
-        return (typeof tag === "string" &&
-            !["array", "boolean", "integer", "number", "string"].includes(tag));
-    },
-};
-/**
- * Validated type guards for `MultiSelectItems`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const MultiSelectItems = {
-    /** Narrow to the `string` variant, validating its payload. */
-    isString(value) {
-        return (tagOf(value, "type") === "string" &&
-            zGuardMultiSelectItemsString.safeParse(value).success);
-    },
-    /** Narrow to the `titled` variant, validating its payload. */
-    isTitled(value) {
-        return (tagOf(value, "type") === undefined &&
-            zGuardMultiSelectItemsTitled.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `type` tag matches no known variant.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "type");
-        return typeof tag === "string" && !["string"].includes(tag);
-    },
-};
-/**
- * Validated type guards for `AuthMethod`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const AuthMethod = {
-    /** Narrow to the `env_var` variant, validating its payload. */
-    isEnvVar(value) {
-        return (tagOf(value, "type") === "env_var" &&
-            zGuardAuthMethodEnvVar.safeParse(value).success);
-    },
-    /** Narrow to the `terminal` variant, validating its payload. */
-    isTerminal(value) {
-        return (tagOf(value, "type") === "terminal" &&
-            zGuardAuthMethodTerminal.safeParse(value).success);
-    },
-    /** Narrow to the `agent` variant, validating its payload. */
-    isAgent(value) {
-        return (tagOf(value, "type") === "agent" &&
-            zGuardAuthMethodAgent.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `type` tag matches no known variant, with a valid payload.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "type");
-        return (typeof tag === "string" &&
-            !["agent", "env_var", "terminal"].includes(tag) &&
-            zGuardAuthMethodCustom.safeParse(value).success);
-    },
-};
-/**
- * Validated type guards for `SessionConfigOption`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const SessionConfigOption = {
-    /** Narrow to the `select` variant, validating its payload. */
-    isSelect(value) {
-        return (tagOf(value, "type") === "select" &&
-            zGuardSessionConfigOptionSelect.safeParse(value).success);
-    },
-    /** Narrow to the `boolean` variant, validating its payload. */
-    isBoolean(value) {
-        return (tagOf(value, "type") === "boolean" &&
-            zGuardSessionConfigOptionBoolean.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `type` tag matches no known variant, with a valid payload.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "type");
-        return (typeof tag === "string" &&
-            !["boolean", "select"].includes(tag) &&
-            zGuardSessionConfigOptionCustom.safeParse(value).success);
-    },
-};
-/**
- * Validated type guards for `NesSuggestion`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const NesSuggestion = {
-    /** Narrow to the `edit` variant, validating its payload. */
-    isEdit(value) {
-        return (tagOf(value, "kind") === "edit" &&
-            zGuardNesSuggestionEdit.safeParse(value).success);
-    },
-    /** Narrow to the `jump` variant, validating its payload. */
-    isJump(value) {
-        return (tagOf(value, "kind") === "jump" &&
-            zGuardNesSuggestionJump.safeParse(value).success);
-    },
-    /** Narrow to the `rename` variant, validating its payload. */
-    isRename(value) {
-        return (tagOf(value, "kind") === "rename" &&
-            zGuardNesSuggestionRename.safeParse(value).success);
-    },
-    /** Narrow to the `searchAndReplace` variant, validating its payload. */
-    isSearchAndReplace(value) {
-        return (tagOf(value, "kind") === "searchAndReplace" &&
-            zGuardNesSuggestionSearchAndReplace.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `kind` tag matches no known variant, with a valid payload.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "kind");
-        return (typeof tag === "string" &&
-            !["edit", "jump", "rename", "searchAndReplace"].includes(tag) &&
-            zGuardNesSuggestionCustom.safeParse(value).success);
-    },
-};
-/**
- * Validated type guards for `SessionUpdate`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const SessionUpdate = {
-    /** Narrow to the `user_message_chunk` variant, validating its payload. */
-    isUserMessageChunk(value) {
-        return (tagOf(value, "sessionUpdate") === "user_message_chunk" &&
-            zGuardSessionUpdateUserMessageChunk.safeParse(value).success);
-    },
-    /** Narrow to the `user_message` variant, validating its payload. */
-    isUserMessage(value) {
-        return (tagOf(value, "sessionUpdate") === "user_message" &&
-            zGuardSessionUpdateUserMessage.safeParse(value).success);
-    },
-    /** Narrow to the `agent_message_chunk` variant, validating its payload. */
-    isAgentMessageChunk(value) {
-        return (tagOf(value, "sessionUpdate") === "agent_message_chunk" &&
-            zGuardSessionUpdateAgentMessageChunk.safeParse(value).success);
-    },
-    /** Narrow to the `agent_message` variant, validating its payload. */
-    isAgentMessage(value) {
-        return (tagOf(value, "sessionUpdate") === "agent_message" &&
-            zGuardSessionUpdateAgentMessage.safeParse(value).success);
-    },
-    /** Narrow to the `agent_thought_chunk` variant, validating its payload. */
-    isAgentThoughtChunk(value) {
-        return (tagOf(value, "sessionUpdate") === "agent_thought_chunk" &&
-            zGuardSessionUpdateAgentThoughtChunk.safeParse(value).success);
-    },
-    /** Narrow to the `agent_thought` variant, validating its payload. */
-    isAgentThought(value) {
-        return (tagOf(value, "sessionUpdate") === "agent_thought" &&
-            zGuardSessionUpdateAgentThought.safeParse(value).success);
-    },
-    /** Narrow to the `state_update` variant, validating its payload. */
-    isStateUpdate(value) {
-        return (tagOf(value, "sessionUpdate") === "state_update" &&
-            zGuardSessionUpdateStateUpdate.safeParse(value).success);
-    },
-    /** Narrow to the `tool_call_content_chunk` variant, validating its payload. */
-    isToolCallContentChunk(value) {
-        return (tagOf(value, "sessionUpdate") === "tool_call_content_chunk" &&
-            zGuardSessionUpdateToolCallContentChunk.safeParse(value).success);
-    },
-    /** Narrow to the `tool_call_update` variant, validating its payload. */
-    isToolCallUpdate(value) {
-        return (tagOf(value, "sessionUpdate") === "tool_call_update" &&
-            zGuardSessionUpdateToolCallUpdate.safeParse(value).success);
-    },
-    /** Narrow to the `terminal_update` variant, validating its payload. */
-    isTerminalUpdate(value) {
-        return (tagOf(value, "sessionUpdate") === "terminal_update" &&
-            zGuardSessionUpdateTerminalUpdate.safeParse(value).success);
-    },
-    /** Narrow to the `terminal_output_chunk` variant, validating its payload. */
-    isTerminalOutputChunk(value) {
-        return (tagOf(value, "sessionUpdate") === "terminal_output_chunk" &&
-            zGuardSessionUpdateTerminalOutputChunk.safeParse(value).success);
-    },
-    /** Narrow to the `plan_update` variant, validating its payload. */
-    isPlanUpdate(value) {
-        return (tagOf(value, "sessionUpdate") === "plan_update" &&
-            zGuardSessionUpdatePlanUpdate.safeParse(value).success);
-    },
-    /** Narrow to the `plan_removed` variant, validating its payload. */
-    isPlanRemoved(value) {
-        return (tagOf(value, "sessionUpdate") === "plan_removed" &&
-            zGuardSessionUpdatePlanRemoved.safeParse(value).success);
-    },
-    /** Narrow to the `available_commands_update` variant, validating its payload. */
-    isAvailableCommandsUpdate(value) {
-        return (tagOf(value, "sessionUpdate") === "available_commands_update" &&
-            zGuardSessionUpdateAvailableCommandsUpdate.safeParse(value).success);
-    },
-    /** Narrow to the `config_option_update` variant, validating its payload. */
-    isConfigOptionUpdate(value) {
-        return (tagOf(value, "sessionUpdate") === "config_option_update" &&
-            zGuardSessionUpdateConfigOptionUpdate.safeParse(value).success);
-    },
-    /** Narrow to the `session_info_update` variant, validating its payload. */
-    isSessionInfoUpdate(value) {
-        return (tagOf(value, "sessionUpdate") === "session_info_update" &&
-            zGuardSessionUpdateSessionInfoUpdate.safeParse(value).success);
-    },
-    /** Narrow to the `usage_update` variant, validating its payload. */
-    isUsageUpdate(value) {
-        return (tagOf(value, "sessionUpdate") === "usage_update" &&
-            zGuardSessionUpdateUsageUpdate.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `sessionUpdate` tag matches no known variant.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "sessionUpdate");
-        return (typeof tag === "string" &&
-            ![
-                "agent_message",
-                "agent_message_chunk",
-                "agent_thought",
-                "agent_thought_chunk",
-                "available_commands_update",
-                "config_option_update",
-                "plan_removed",
-                "plan_update",
-                "session_info_update",
-                "state_update",
-                "terminal_output_chunk",
-                "terminal_update",
-                "tool_call_content_chunk",
-                "tool_call_update",
-                "usage_update",
-                "user_message",
-                "user_message_chunk",
-            ].includes(tag));
-    },
-};
-/**
- * Validated type guards for `StateUpdate`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const StateUpdate = {
-    /** Narrow to the `running` variant, validating its payload. */
-    isRunning(value) {
-        return (tagOf(value, "state") === "running" &&
-            zGuardStateUpdateRunning.safeParse(value).success);
-    },
-    /** Narrow to the `idle` variant, validating its payload. */
-    isIdle(value) {
-        return (tagOf(value, "state") === "idle" &&
-            zGuardStateUpdateIdle.safeParse(value).success);
-    },
-    /** Narrow to the `requires_action` variant, validating its payload. */
-    isRequiresAction(value) {
-        return (tagOf(value, "state") === "requires_action" &&
-            zGuardStateUpdateRequiresAction.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `state` tag matches no known variant.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "state");
-        return (typeof tag === "string" &&
-            !["idle", "requires_action", "running"].includes(tag));
-    },
-};
-/**
- * Validated type guards for `PlanUpdateContent`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const PlanUpdateContent = {
-    /** Narrow to the `items` variant, validating its payload. */
-    isItems(value) {
-        return (tagOf(value, "type") === "items" &&
-            zGuardPlanUpdateContentItems.safeParse(value).success);
-    },
-    /** Narrow to the `file` variant, validating its payload. */
-    isFile(value) {
-        return (tagOf(value, "type") === "file" &&
-            zGuardPlanUpdateContentFile.safeParse(value).success);
-    },
-    /** Narrow to the `markdown` variant, validating its payload. */
-    isMarkdown(value) {
-        return (tagOf(value, "type") === "markdown" &&
-            zGuardPlanUpdateContentMarkdown.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `type` tag matches no known variant, with a valid payload.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "type");
-        return (typeof tag === "string" &&
-            !["file", "items", "markdown"].includes(tag) &&
-            zGuardPlanUpdateContentCustom.safeParse(value).success);
-    },
-};
-/**
- * Validated type guards for `AvailableCommandInput`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const AvailableCommandInput = {
-    /** Narrow to the `text` variant, validating its payload. */
-    isText(value) {
-        return (tagOf(value, "type") === "text" &&
-            zGuardAvailableCommandInputText.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `type` tag matches no known variant.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "type");
-        return typeof tag === "string" && !["text"].includes(tag);
-    },
-};
-/**
- * Validated type guards for `McpServer`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const McpServer = {
-    /** Narrow to the `http` variant, validating its payload. */
-    isHttp(value) {
-        return (tagOf(value, "type") === "http" &&
-            zGuardMcpServerHttp.safeParse(value).success);
-    },
-    /** Narrow to the `acp` variant, validating its payload. */
-    isAcp(value) {
-        return (tagOf(value, "type") === "acp" &&
-            zGuardMcpServerAcp.safeParse(value).success);
-    },
-    /** Narrow to the `stdio` variant, validating its payload. */
-    isStdio(value) {
-        return (tagOf(value, "type") === "stdio" &&
-            zGuardMcpServerStdio.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `type` tag matches no known variant.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "type");
-        return typeof tag === "string" && !["acp", "http", "stdio"].includes(tag);
-    },
-};
-/**
- * Validated type guards for `ReplayFrom`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const ReplayFrom = {
-    /** Narrow to the `start` variant, validating its payload. */
-    isStart(value) {
-        return (tagOf(value, "type") === "start" &&
-            zGuardReplayFromStart.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `type` tag matches no known variant.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "type");
-        return typeof tag === "string" && !["start"].includes(tag);
-    },
-};
-/**
- * Validated type guards for `SetSessionConfigOptionRequest`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const SetSessionConfigOptionRequest = {
-    /** Narrow to the `id` variant, validating its payload. */
-    isId(value) {
-        return (tagOf(value, "type") === "id" &&
-            zGuardSetSessionConfigOptionRequestId.safeParse(value).success);
-    },
-    /** Narrow to the `boolean` variant, validating its payload. */
-    isBoolean(value) {
-        return (tagOf(value, "type") === "boolean" &&
-            zGuardSetSessionConfigOptionRequestBoolean.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `type` tag matches no known variant, with a valid payload.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "type");
-        return (typeof tag === "string" &&
-            !["boolean", "id"].includes(tag) &&
-            zGuardSetSessionConfigOptionRequestCustom.safeParse(value).success);
-    },
-};
-/**
- * Validated type guards for `RequestPermissionOutcome`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- */
-export const RequestPermissionOutcome = {
-    /** Narrow to the `cancelled` variant, validating its payload. */
-    isCancelled(value) {
-        return (tagOf(value, "outcome") === "cancelled" &&
-            zGuardRequestPermissionOutcomeCancelled.safeParse(value).success);
-    },
-    /** Narrow to the `selected` variant, validating its payload. */
-    isSelected(value) {
-        return (tagOf(value, "outcome") === "selected" &&
-            zGuardRequestPermissionOutcomeSelected.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `outcome` tag matches no known variant.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "outcome");
-        return typeof tag === "string" && !["cancelled", "selected"].includes(tag);
-    },
-};
-/**
- * Validated type guards for `CreateElicitationResponse`'s known variants.
- *
- * Each guard validates the variant's payload, not just its discriminant
- * tag: a malformed known variant (right tag, wrong payload) matches no
- * guard — mirroring wire validation, which rejects such values instead
- * of classifying them as custom.
- *
- * Guards check the value as given: fields that wire deserialization
- * salvages to a default (e.g. a malformed `_meta`) are only normalized
- * by parsing, and for ambiguous raw shapes (a known tag combined with
- * another variant's payload) guards are conservative where wire parsing
- * may still accept the value — narrow wire-parsed values when exact
- * parity matters.
- *
- * @experimental
- */
-export const CreateElicitationResponse = {
-    /** Narrow to the `accept` variant, validating its payload. */
-    isAccept(value) {
-        return (tagOf(value, "action") === "accept" &&
-            zGuardCreateElicitationResponseAccept.safeParse(value).success);
-    },
-    /** Narrow to the `decline` variant, validating its payload. */
-    isDecline(value) {
-        return (tagOf(value, "action") === "decline" &&
-            zGuardCreateElicitationResponseDecline.safeParse(value).success);
-    },
-    /** Narrow to the `cancel` variant, validating its payload. */
-    isCancel(value) {
-        return (tagOf(value, "action") === "cancel" &&
-            zGuardCreateElicitationResponseCancel.safeParse(value).success);
-    },
-    /**
-     * Narrow to a custom or future variant: the `action` tag matches no known variant.
-     *
-     * TypeScript keeps the known variants in the narrowed union (they are
-     * structural subtypes of the catch-all), so read vendor payload keys
-     * via a widening cast: `(value as Record<string, unknown>).someKey`.
-     */
-    isCustom(value) {
-        const tag = tagOf(value, "action");
-        return (typeof tag === "string" && !["accept", "cancel", "decline"].includes(tag));
-    },
-};
-//# sourceMappingURL=guards.gen.js.map