kennel 0.2.0 → 0.2.2

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

@@ -0,0 +1,1035 @@
+// 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