@peasant-labs/schema 0.1.0-rc10

package/dist/internal/generated/enums.gen.js

@@ -0,0 +1,445 @@
+// Code generated from the canonical Go/OpenAPI contract. DO NOT EDIT.
+import { zAnnotationAxis } from "./contract/zod.gen.js";
+import { zAnnotationDatatype } from "./contract/zod.gen.js";
+import { zAnnotationPushStatus } from "./contract/zod.gen.js";
+import { zAnnotationStatus } from "./contract/zod.gen.js";
+import { zAnnotatorKind } from "./contract/zod.gen.js";
+import { zAssociationConclusion } from "./contract/zod.gen.js";
+import { zAssociationEvidenceKind } from "./contract/zod.gen.js";
+import { zBuiltinCommand } from "./contract/zod.gen.js";
+import { zChangeBinding } from "./contract/zod.gen.js";
+import { zChannelTopic } from "./contract/zod.gen.js";
+import { zConfidence } from "./contract/zod.gen.js";
+import { zContentKind } from "./contract/zod.gen.js";
+import { zDecayLevel } from "./contract/zod.gen.js";
+import { zDiffLineKind } from "./contract/zod.gen.js";
+import { zEdgeViolationKind } from "./contract/zod.gen.js";
+import { zEntryType } from "./contract/zod.gen.js";
+import { zFileChangeStatus } from "./contract/zod.gen.js";
+import { zHarness } from "./contract/zod.gen.js";
+import { zInsightKind } from "./contract/zod.gen.js";
+import { zInsightProvenance } from "./contract/zod.gen.js";
+import { zInteractionType } from "./contract/zod.gen.js";
+import { zLicense } from "./contract/zod.gen.js";
+import { zMapNodeKind } from "./contract/zod.gen.js";
+import { zMessageType } from "./contract/zod.gen.js";
+import { zReadAttributionState } from "./contract/zod.gen.js";
+import { zReadStateGrade } from "./contract/zod.gen.js";
+import { zRewriteMethod } from "./contract/zod.gen.js";
+import { zRewriteResolution } from "./contract/zod.gen.js";
+import { zRole } from "./contract/zod.gen.js";
+import { zScaleKind } from "./contract/zod.gen.js";
+import { zSessionOutcome } from "./contract/zod.gen.js";
+import { zSourceFormat } from "./contract/zod.gen.js";
+import { zStopReason } from "./contract/zod.gen.js";
+import { zTargetKind } from "./contract/zod.gen.js";
+import { zToolCallKind } from "./contract/zod.gen.js";
+import { zTypeOrigin } from "./contract/zod.gen.js";
+import { zValueDomainKind } from "./contract/zod.gen.js";
+import { zVisibility } from "./contract/zod.gen.js";
+export const AnnotationAxis = Object.freeze({
+    Type: zAnnotationAxis.parse("type"),
+    Session: zAnnotationAxis.parse("session"),
+    Project: zAnnotationAxis.parse("project"),
+});
+export const AllAnnotationAxes = Object.freeze([AnnotationAxis.Type, AnnotationAxis.Session, AnnotationAxis.Project]);
+export function isAnnotationAxis(value) {
+    return zAnnotationAxis.safeParse(value).success;
+}
+export const AnnotationDatatype = Object.freeze({
+    Text: zAnnotationDatatype.parse("text"),
+    Integer: zAnnotationDatatype.parse("integer"),
+    Real: zAnnotationDatatype.parse("real"),
+    Boolean: zAnnotationDatatype.parse("boolean"),
+});
+export const AllAnnotationDatatypes = Object.freeze([AnnotationDatatype.Text, AnnotationDatatype.Integer, AnnotationDatatype.Real, AnnotationDatatype.Boolean]);
+export function isAnnotationDatatype(value) {
+    return zAnnotationDatatype.safeParse(value).success;
+}
+export const AnnotationPushStatus = Object.freeze({
+    Created: zAnnotationPushStatus.parse("created"),
+    Updated: zAnnotationPushStatus.parse("updated"),
+    Skipped: zAnnotationPushStatus.parse("skipped"),
+    Error: zAnnotationPushStatus.parse("error"),
+});
+export const AllAnnotationPushStatuses = Object.freeze([AnnotationPushStatus.Created, AnnotationPushStatus.Updated, AnnotationPushStatus.Skipped, AnnotationPushStatus.Error]);
+export function isAnnotationPushStatus(value) {
+    return zAnnotationPushStatus.safeParse(value).success;
+}
+export const AnnotationStatus = Object.freeze({
+    Proposed: zAnnotationStatus.parse("proposed"),
+    Active: zAnnotationStatus.parse("active"),
+    Deprecated: zAnnotationStatus.parse("deprecated"),
+    Retired: zAnnotationStatus.parse("retired"),
+});
+export const AllAnnotationStatuses = Object.freeze([AnnotationStatus.Proposed, AnnotationStatus.Active, AnnotationStatus.Deprecated, AnnotationStatus.Retired]);
+export function isAnnotationStatus(value) {
+    return zAnnotationStatus.safeParse(value).success;
+}
+export const AnnotatorKind = Object.freeze({
+    Human: zAnnotatorKind.parse("human"),
+    Agent: zAnnotatorKind.parse("agent"),
+    Rule: zAnnotatorKind.parse("rule"),
+});
+export const AllAnnotatorKinds = Object.freeze([AnnotatorKind.Human, AnnotatorKind.Agent, AnnotatorKind.Rule]);
+export function isAnnotatorKind(value) {
+    return zAnnotatorKind.safeParse(value).success;
+}
+export const AssociationConclusion = Object.freeze({
+    Confirmed: zAssociationConclusion.parse("confirmed"),
+    Candidate: zAssociationConclusion.parse("candidate"),
+});
+export const AllAssociationConclusions = Object.freeze([AssociationConclusion.Confirmed, AssociationConclusion.Candidate]);
+export function isAssociationConclusion(value) {
+    return zAssociationConclusion.safeParse(value).success;
+}
+export const AssociationEvidenceKind = Object.freeze({
+    RecordedCommit: zAssociationEvidenceKind.parse("recorded_commit"),
+    TouchedFile: zAssociationEvidenceKind.parse("touched_file"),
+    BranchMembership: zAssociationEvidenceKind.parse("branch_membership"),
+    TimeWindow: zAssociationEvidenceKind.parse("time_window"),
+});
+export const AllAssociationEvidenceKinds = Object.freeze([AssociationEvidenceKind.RecordedCommit, AssociationEvidenceKind.TouchedFile, AssociationEvidenceKind.BranchMembership, AssociationEvidenceKind.TimeWindow]);
+export function isAssociationEvidenceKind(value) {
+    return zAssociationEvidenceKind.safeParse(value).success;
+}
+export const BuiltinCommand = Object.freeze({
+    Exit: zBuiltinCommand.parse("exit"),
+    Compact: zBuiltinCommand.parse("compact"),
+    Clear: zBuiltinCommand.parse("clear"),
+    New: zBuiltinCommand.parse("new"),
+    Model: zBuiltinCommand.parse("model"),
+    Usage: zBuiltinCommand.parse("usage"),
+    Cost: zBuiltinCommand.parse("cost"),
+    Context: zBuiltinCommand.parse("context"),
+    Plugin: zBuiltinCommand.parse("plugin"),
+    Permissions: zBuiltinCommand.parse("permissions"),
+    Login: zBuiltinCommand.parse("login"),
+    Resume: zBuiltinCommand.parse("resume"),
+    Plan: zBuiltinCommand.parse("plan"),
+    Fast: zBuiltinCommand.parse("fast"),
+    Voice: zBuiltinCommand.parse("voice"),
+    Todos: zBuiltinCommand.parse("todos"),
+    ReloadPlugins: zBuiltinCommand.parse("reload-plugins"),
+    Sandbox: zBuiltinCommand.parse("sandbox"),
+    Config: zBuiltinCommand.parse("config"),
+    Statusline: zBuiltinCommand.parse("statusline"),
+    Upgrade: zBuiltinCommand.parse("upgrade"),
+    ExtraUsage: zBuiltinCommand.parse("extra-usage"),
+    RateLimitOptions: zBuiltinCommand.parse("rate-limit-options"),
+    PrivacySettings: zBuiltinCommand.parse("privacy-settings"),
+    Help: zBuiltinCommand.parse("help"),
+    Commands: zBuiltinCommand.parse("commands"),
+});
+export const AllClaudeBuiltinCmds = Object.freeze([BuiltinCommand.Exit, BuiltinCommand.Compact, BuiltinCommand.Clear, BuiltinCommand.New, BuiltinCommand.Model, BuiltinCommand.Usage, BuiltinCommand.Cost, BuiltinCommand.Context, BuiltinCommand.Plugin, BuiltinCommand.Permissions, BuiltinCommand.Login, BuiltinCommand.Resume, BuiltinCommand.Plan, BuiltinCommand.Fast, BuiltinCommand.Voice, BuiltinCommand.Todos, BuiltinCommand.ReloadPlugins, BuiltinCommand.Sandbox, BuiltinCommand.Config, BuiltinCommand.Statusline, BuiltinCommand.Upgrade, BuiltinCommand.ExtraUsage, BuiltinCommand.RateLimitOptions, BuiltinCommand.PrivacySettings, BuiltinCommand.Help, BuiltinCommand.Commands]);
+export function isBuiltinCommand(value) {
+    return zBuiltinCommand.safeParse(value).success;
+}
+export const ChangeBinding = Object.freeze({
+    Bound: zChangeBinding.parse("bound"),
+    Candidate: zChangeBinding.parse("candidate"),
+});
+export const AllChangeBindings = Object.freeze([ChangeBinding.Bound, ChangeBinding.Candidate]);
+export function isChangeBinding(value) {
+    return zChangeBinding.safeParse(value).success;
+}
+export const ChannelTopic = Object.freeze({
+    Dashboard: zChannelTopic.parse("dashboard"),
+    Sessions: zChannelTopic.parse("sessions"),
+    SessionDetail: zChannelTopic.parse("session_detail"),
+    Trends: zChannelTopic.parse("trends"),
+    Quality: zChannelTopic.parse("quality"),
+    Annotations: zChannelTopic.parse("annotations"),
+    ProjectFamiliarity: zChannelTopic.parse("project_familiarity"),
+});
+export const AllChannelTopics = Object.freeze([ChannelTopic.Dashboard, ChannelTopic.Sessions, ChannelTopic.SessionDetail, ChannelTopic.Trends, ChannelTopic.Quality, ChannelTopic.Annotations, ChannelTopic.ProjectFamiliarity]);
+export function isChannelTopic(value) {
+    return zChannelTopic.safeParse(value).success;
+}
+export const Confidence = Object.freeze({
+    High: zConfidence.parse("high"),
+    Medium: zConfidence.parse("medium"),
+    Low: zConfidence.parse("low"),
+});
+export const AllConfidences = Object.freeze([Confidence.High, Confidence.Medium, Confidence.Low]);
+export function isConfidence(value) {
+    return zConfidence.safeParse(value).success;
+}
+export const ContentKind = Object.freeze({
+    SessionDetail: zContentKind.parse("session_detail"),
+});
+export const AllContentKinds = Object.freeze([ContentKind.SessionDetail]);
+export function isContentKind(value) {
+    return zContentKind.safeParse(value).success;
+}
+export const DecayLevel = Object.freeze({
+    Fresh: zDecayLevel.parse("fresh"),
+    Fading: zDecayLevel.parse("fading"),
+    Stale: zDecayLevel.parse("stale"),
+    Unexplored: zDecayLevel.parse("unexplored"),
+});
+export const AllDecayLevels = Object.freeze([DecayLevel.Fresh, DecayLevel.Fading, DecayLevel.Stale, DecayLevel.Unexplored]);
+export function isDecayLevel(value) {
+    return zDecayLevel.safeParse(value).success;
+}
+export const DiffLineKind = Object.freeze({
+    Context: zDiffLineKind.parse("context"),
+    Add: zDiffLineKind.parse("add"),
+    Delete: zDiffLineKind.parse("del"),
+});
+export const AllDiffLineKinds = Object.freeze([DiffLineKind.Context, DiffLineKind.Add, DiffLineKind.Delete]);
+export function isDiffLineKind(value) {
+    return zDiffLineKind.safeParse(value).success;
+}
+export const EdgeViolationKind = Object.freeze({
+    Cycle: zEdgeViolationKind.parse("cycle"),
+    WrongWay: zEdgeViolationKind.parse("wrong_way"),
+});
+export const AllEdgeViolationKinds = Object.freeze([EdgeViolationKind.Cycle, EdgeViolationKind.WrongWay]);
+export function isEdgeViolationKind(value) {
+    return zEdgeViolationKind.safeParse(value).success;
+}
+export const EntryType = Object.freeze({
+    Text: zEntryType.parse("text"),
+    ToolUse: zEntryType.parse("tool_use"),
+    ToolResult: zEntryType.parse("tool_result"),
+    Thinking: zEntryType.parse("thinking"),
+    System: zEntryType.parse("system"),
+    Error: zEntryType.parse("error"),
+    Result: zEntryType.parse("result"),
+});
+export const AllEntryTypes = Object.freeze([EntryType.Text, EntryType.ToolUse, EntryType.ToolResult, EntryType.Thinking, EntryType.System, EntryType.Error, EntryType.Result]);
+export function isEntryType(value) {
+    return zEntryType.safeParse(value).success;
+}
+export const FileChangeStatus = Object.freeze({
+    Modified: zFileChangeStatus.parse("M"),
+    Added: zFileChangeStatus.parse("A"),
+    Deleted: zFileChangeStatus.parse("D"),
+    Renamed: zFileChangeStatus.parse("R"),
+});
+export const AllFileChangeStatuses = Object.freeze([FileChangeStatus.Modified, FileChangeStatus.Added, FileChangeStatus.Deleted, FileChangeStatus.Renamed]);
+export function isFileChangeStatus(value) {
+    return zFileChangeStatus.safeParse(value).success;
+}
+export const Harness = Object.freeze({
+    ClaudeCode: zHarness.parse("claude-code"),
+    GeminiCLI: zHarness.parse("gemini-cli"),
+    Codex: zHarness.parse("codex"),
+    OpenCode: zHarness.parse("opencode"),
+    Cursor: zHarness.parse("cursor"),
+    Antigravity: zHarness.parse("antigravity"),
+    Strike: zHarness.parse("strike"),
+});
+/**
+ * AllHarnesses is the ingestion-supported subset of Harness, not the full
+ * canonical set (mirrors types.go's AllHarnesses doc comment). Every Harness
+ * member remains individually valid and accepted by isHarness.
+ */
+export const AllHarnesses = Object.freeze([Harness.ClaudeCode, Harness.GeminiCLI, Harness.Codex, Harness.OpenCode, Harness.Cursor, Harness.Strike]);
+export function isHarness(value) {
+    return zHarness.safeParse(value).success;
+}
+export const InsightKind = Object.freeze({
+    Decision: zInsightKind.parse("decision"),
+    Friction: zInsightKind.parse("friction"),
+    Unusual: zInsightKind.parse("unusual"),
+    RetryLoop: zInsightKind.parse("retry_loop"),
+});
+export const AllInsightKinds = Object.freeze([InsightKind.Decision, InsightKind.Friction, InsightKind.Unusual, InsightKind.RetryLoop]);
+export function isInsightKind(value) {
+    return zInsightKind.safeParse(value).success;
+}
+export const InsightProvenance = Object.freeze({
+    Mechanical: zInsightProvenance.parse("mechanical"),
+    Mined: zInsightProvenance.parse("mined"),
+});
+export const AllInsightProvenances = Object.freeze([InsightProvenance.Mechanical, InsightProvenance.Mined]);
+export function isInsightProvenance(value) {
+    return zInsightProvenance.safeParse(value).success;
+}
+export const InteractionType = Object.freeze({
+    Mentioned: zInteractionType.parse("mentioned"),
+    Read: zInteractionType.parse("read"),
+    Discussed: zInteractionType.parse("discussed"),
+    Questioned: zInteractionType.parse("questioned"),
+});
+export const AllInteractionTypes = Object.freeze([InteractionType.Mentioned, InteractionType.Read, InteractionType.Discussed, InteractionType.Questioned]);
+export function isInteractionType(value) {
+    return zInteractionType.safeParse(value).success;
+}
+export const License = Object.freeze({
+    CC0: zLicense.parse("CC0-1.0"),
+    CCBY: zLicense.parse("CC-BY-4.0"),
+    CCBYSA: zLicense.parse("CC-BY-SA-4.0"),
+});
+export const AllLicenses = Object.freeze([License.CC0, License.CCBY, License.CCBYSA]);
+export function isLicense(value) {
+    return zLicense.safeParse(value).success;
+}
+export const MapNodeKind = Object.freeze({
+    Module: zMapNodeKind.parse("module"),
+    Package: zMapNodeKind.parse("package"),
+    File: zMapNodeKind.parse("file"),
+});
+export const AllMapNodeKinds = Object.freeze([MapNodeKind.Module, MapNodeKind.Package, MapNodeKind.File]);
+export function isMapNodeKind(value) {
+    return zMapNodeKind.safeParse(value).success;
+}
+export const MessageType = Object.freeze({
+    Subscribe: zMessageType.parse("subscribe"),
+    Unsubscribe: zMessageType.parse("unsubscribe"),
+    Dashboard: zMessageType.parse("dashboard"),
+    Sessions: zMessageType.parse("sessions"),
+    SessionDetail: zMessageType.parse("session_detail"),
+    Trends: zMessageType.parse("trends"),
+    Quality: zMessageType.parse("quality"),
+    Annotations: zMessageType.parse("annotations"),
+    ProjectFamiliarity: zMessageType.parse("project_familiarity"),
+    Connected: zMessageType.parse("connected"),
+    Error: zMessageType.parse("error"),
+});
+export const AllMessageTypes = Object.freeze([MessageType.Subscribe, MessageType.Unsubscribe, MessageType.Dashboard, MessageType.Sessions, MessageType.SessionDetail, MessageType.Trends, MessageType.Quality, MessageType.Annotations, MessageType.ProjectFamiliarity, MessageType.Connected, MessageType.Error]);
+export function isMessageType(value) {
+    return zMessageType.safeParse(value).success;
+}
+export const ReadAttributionState = Object.freeze({
+    Complete: zReadAttributionState.parse("complete"),
+    Partial: zReadAttributionState.parse("partial"),
+    Unavailable: zReadAttributionState.parse("unavailable"),
+});
+export const AllReadAttributionStates = Object.freeze([ReadAttributionState.Complete, ReadAttributionState.Partial, ReadAttributionState.Unavailable]);
+export function isReadAttributionState(value) {
+    return zReadAttributionState.safeParse(value).success;
+}
+export const ReadStateGrade = Object.freeze({
+    None: zReadStateGrade.parse("none"),
+    Viewed: zReadStateGrade.parse("viewed"),
+    Reviewed: zReadStateGrade.parse("reviewed"),
+    ReviewedInDetail: zReadStateGrade.parse("reviewed_in_detail"),
+});
+export const AllReadStateGrades = Object.freeze([ReadStateGrade.None, ReadStateGrade.Viewed, ReadStateGrade.Reviewed, ReadStateGrade.ReviewedInDetail]);
+export function isReadStateGrade(value) {
+    return zReadStateGrade.safeParse(value).success;
+}
+export const RewriteMethod = Object.freeze({
+    Hash: zRewriteMethod.parse("hash"),
+    PatchID: zRewriteMethod.parse("patch_id"),
+    AuthorIdentity: zRewriteMethod.parse("author_identity"),
+    MessageEmbedded: zRewriteMethod.parse("message_embedded"),
+    Temporal: zRewriteMethod.parse("temporal"),
+    None: zRewriteMethod.parse("none"),
+});
+export const AllRewriteMethods = Object.freeze([RewriteMethod.Hash, RewriteMethod.PatchID, RewriteMethod.AuthorIdentity, RewriteMethod.MessageEmbedded, RewriteMethod.Temporal, RewriteMethod.None]);
+export function isRewriteMethod(value) {
+    return zRewriteMethod.safeParse(value).success;
+}
+export const RewriteResolution = Object.freeze({
+    Live: zRewriteResolution.parse("live"),
+    Rewritten: zRewriteResolution.parse("rewritten"),
+    Unresolved: zRewriteResolution.parse("unresolved"),
+});
+export const AllRewriteResolutions = Object.freeze([RewriteResolution.Live, RewriteResolution.Rewritten, RewriteResolution.Unresolved]);
+export function isRewriteResolution(value) {
+    return zRewriteResolution.safeParse(value).success;
+}
+export const Role = Object.freeze({
+    User: zRole.parse("user"),
+    Assistant: zRole.parse("assistant"),
+    Tool: zRole.parse("tool"),
+    System: zRole.parse("system"),
+});
+export const AllRoles = Object.freeze([Role.User, Role.Assistant, Role.Tool, Role.System]);
+export function isRole(value) {
+    return zRole.safeParse(value).success;
+}
+export const ScaleKind = Object.freeze({
+    Nominal: zScaleKind.parse("nominal"),
+    Ordinal: zScaleKind.parse("ordinal"),
+    Continuous: zScaleKind.parse("continuous"),
+});
+export const AllScaleKinds = Object.freeze([ScaleKind.Nominal, ScaleKind.Ordinal, ScaleKind.Continuous]);
+export function isScaleKind(value) {
+    return zScaleKind.safeParse(value).success;
+}
+export const SessionOutcome = Object.freeze({
+    Resolved: zSessionOutcome.parse("resolved"),
+    Partial: zSessionOutcome.parse("partial"),
+    Failed: zSessionOutcome.parse("failed"),
+});
+export const AllOutcomes = Object.freeze([SessionOutcome.Resolved, SessionOutcome.Partial, SessionOutcome.Failed]);
+export function isSessionOutcome(value) {
+    return zSessionOutcome.safeParse(value).success;
+}
+export const SourceFormat = Object.freeze({
+    JSONL: zSourceFormat.parse("jsonl"),
+    JSON: zSourceFormat.parse("json"),
+});
+export const AllSourceFormats = Object.freeze([SourceFormat.JSONL, SourceFormat.JSON]);
+export function isSourceFormat(value) {
+    return zSourceFormat.safeParse(value).success;
+}
+export const StopReason = Object.freeze({
+    EndTurn: zStopReason.parse("end_turn"),
+    Cancelled: zStopReason.parse("cancelled"),
+    MaxTokens: zStopReason.parse("max_tokens"),
+    MaxTurnRequests: zStopReason.parse("max_turn_requests"),
+    Refusal: zStopReason.parse("refusal"),
+});
+export const AllStopReasons = Object.freeze([StopReason.EndTurn, StopReason.Cancelled, StopReason.MaxTokens, StopReason.MaxTurnRequests, StopReason.Refusal]);
+export function isStopReason(value) {
+    return zStopReason.safeParse(value).success;
+}
+export const TargetKind = Object.freeze({
+    Session: zTargetKind.parse("session"),
+    Entry: zTargetKind.parse("entry"),
+    Annotation: zTargetKind.parse("annotation"),
+    Project: zTargetKind.parse("project"),
+    FileVersion: zTargetKind.parse("file_version"),
+    Association: zTargetKind.parse("association"),
+});
+export const AllTargetKinds = Object.freeze([TargetKind.Session, TargetKind.Entry, TargetKind.Annotation, TargetKind.Project, TargetKind.FileVersion, TargetKind.Association]);
+export function isTargetKind(value) {
+    return zTargetKind.safeParse(value).success;
+}
+export const ToolCallKind = Object.freeze({
+    Read: zToolCallKind.parse("read"),
+    Edit: zToolCallKind.parse("edit"),
+    Delete: zToolCallKind.parse("delete"),
+    Move: zToolCallKind.parse("move"),
+    Search: zToolCallKind.parse("search"),
+    Execute: zToolCallKind.parse("execute"),
+    Think: zToolCallKind.parse("think"),
+    Fetch: zToolCallKind.parse("fetch"),
+    Other: zToolCallKind.parse("other"),
+});
+export const AllToolCallKinds = Object.freeze([ToolCallKind.Read, ToolCallKind.Edit, ToolCallKind.Delete, ToolCallKind.Move, ToolCallKind.Search, ToolCallKind.Execute, ToolCallKind.Think, ToolCallKind.Fetch, ToolCallKind.Other]);
+export function isToolCallKind(value) {
+    return zToolCallKind.safeParse(value).success;
+}
+export const TypeOrigin = Object.freeze({
+    System: zTypeOrigin.parse("system"),
+    User: zTypeOrigin.parse("user"),
+    Group: zTypeOrigin.parse("group"),
+});
+export const AllTypeOrigins = Object.freeze([TypeOrigin.System, TypeOrigin.User, TypeOrigin.Group]);
+export function isTypeOrigin(value) {
+    return zTypeOrigin.safeParse(value).success;
+}
+export const ValueDomainKind = Object.freeze({
+    Enumerated: zValueDomainKind.parse("enumerated"),
+    Described: zValueDomainKind.parse("described"),
+});
+export const AllValueDomainKinds = Object.freeze([ValueDomainKind.Enumerated, ValueDomainKind.Described]);
+export function isValueDomainKind(value) {
+    return zValueDomainKind.safeParse(value).success;
+}
+export const Visibility = Object.freeze({
+    Private: zVisibility.parse("private"),
+    Group: zVisibility.parse("group"),
+    Public: zVisibility.parse("public"),
+});
+export const AllVisibilities = Object.freeze([Visibility.Private, Visibility.Group, Visibility.Public]);
+export function isVisibility(value) {
+    return zVisibility.safeParse(value).success;
+}