import { z } from "zod";

//#region src/schemas.d.ts

/**
 * File metadata for a change directory entry.
 */
declare const ChangeFileSchema: z.ZodObject<{
  /** Path relative to the change root (e.g., "proposal.md" or "specs/auth/spec.md") */
  path: z.ZodString;
  /** Entry type */
  type: z.ZodEnum<["file", "directory"]>;
  /** Optional file content for text files */
  content: z.ZodOptional<z.ZodString>;
  /** Optional byte size for files */
  size: z.ZodOptional<z.ZodNumber>;
  /** Optional mime inferred from file path */
  mime: z.ZodOptional<z.ZodString>;
  /** Optional preview kind inferred from file path and mime */
  previewKind: z.ZodOptional<z.ZodEnum<["markdown", "html", "image", "audio", "video", "pdf", "text", "none"]>>;
}, "strip", z.ZodTypeAny, {
  path: string;
  type: "file" | "directory";
  mime?: string | undefined;
  size?: number | undefined;
  content?: string | undefined;
  previewKind?: "html" | "text" | "none" | "markdown" | "image" | "audio" | "video" | "pdf" | undefined;
}, {
  path: string;
  type: "file" | "directory";
  mime?: string | undefined;
  size?: number | undefined;
  content?: string | undefined;
  previewKind?: "html" | "text" | "none" | "markdown" | "image" | "audio" | "video" | "pdf" | undefined;
}>;
type ChangeFile = z.infer<typeof ChangeFileSchema>;
declare const ScenarioStepKeywordSchema: z.ZodEnum<["GIVEN", "WHEN", "THEN", "AND", "BUT"]>;
declare const ScenarioStepSchema: z.ZodObject<{
  /** Scenario step keyword from the list item prefix */
  keyword: z.ZodEnum<["GIVEN", "WHEN", "THEN", "AND", "BUT"]>;
  /** Markdown content after the keyword */
  contentMarkdown: z.ZodString;
  /** Original markdown list item line */
  rawText: z.ZodString;
}, "strip", z.ZodTypeAny, {
  rawText: string;
  keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
  contentMarkdown: string;
}, {
  rawText: string;
  keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
  contentMarkdown: string;
}>;
type ScenarioStep = z.infer<typeof ScenarioStepSchema>;
/**
 * A requirement within a specification.
 * Requirements should use RFC 2119 keywords (SHALL, MUST, etc.)
 */
declare const RequirementSchema: z.ZodObject<{
  /** Unique identifier within the spec (e.g., "req-1") */
  id: z.ZodString;
  /** Requirement heading text from `### Requirement:` */
  title: z.ZodString;
  /** Markdown body between the requirement heading and the first scenario/next requirement */
  bodyMarkdown: z.ZodString;
  /** Full requirement text used for validation and search facts */
  text: z.ZodString;
  /** Test scenarios for this requirement */
  scenarios: z.ZodArray<z.ZodObject<{
    /** Scenario heading text from `#### Scenario:` */
    title: z.ZodString;
    /** Markdown body between this scenario heading and the next scenario/requirement */
    bodyMarkdown: z.ZodString;
    /** Full scenario Markdown facts, including the scenario title */
    rawText: z.ZodString;
    /** Parsed scenario step facts for reading enhancements */
    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
      /** Scenario step keyword from the list item prefix */
      keyword: z.ZodEnum<["GIVEN", "WHEN", "THEN", "AND", "BUT"]>;
      /** Markdown content after the keyword */
      contentMarkdown: z.ZodString;
      /** Original markdown list item line */
      rawText: z.ZodString;
    }, "strip", z.ZodTypeAny, {
      rawText: string;
      keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
      contentMarkdown: string;
    }, {
      rawText: string;
      keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
      contentMarkdown: string;
    }>, "many">>;
  }, "strip", z.ZodTypeAny, {
    title: string;
    rawText: string;
    bodyMarkdown: string;
    steps?: {
      rawText: string;
      keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
      contentMarkdown: string;
    }[] | undefined;
  }, {
    title: string;
    rawText: string;
    bodyMarkdown: string;
    steps?: {
      rawText: string;
      keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
      contentMarkdown: string;
    }[] | undefined;
  }>, "many">;
}, "strip", z.ZodTypeAny, {
  id: string;
  text: string;
  title: string;
  scenarios: {
    title: string;
    rawText: string;
    bodyMarkdown: string;
    steps?: {
      rawText: string;
      keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
      contentMarkdown: string;
    }[] | undefined;
  }[];
  bodyMarkdown: string;
}, {
  id: string;
  text: string;
  title: string;
  scenarios: {
    title: string;
    rawText: string;
    bodyMarkdown: string;
    steps?: {
      rawText: string;
      keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
      contentMarkdown: string;
    }[] | undefined;
  }[];
  bodyMarkdown: string;
}>;
type Requirement = z.infer<typeof RequirementSchema>;
/**
 * A specification document.
 * Located at: openspec/specs/{id}/spec.md
 */
declare const SpecSchema: z.ZodObject<{
  /** Directory name (e.g., "user-auth") */
  id: z.ZodString;
  /** Human-readable name from # heading */
  name: z.ZodString;
  /** Purpose/overview section content */
  overview: z.ZodString;
  /** List of requirements */
  requirements: z.ZodArray<z.ZodObject<{
    /** Unique identifier within the spec (e.g., "req-1") */
    id: z.ZodString;
    /** Requirement heading text from `### Requirement:` */
    title: z.ZodString;
    /** Markdown body between the requirement heading and the first scenario/next requirement */
    bodyMarkdown: z.ZodString;
    /** Full requirement text used for validation and search facts */
    text: z.ZodString;
    /** Test scenarios for this requirement */
    scenarios: z.ZodArray<z.ZodObject<{
      /** Scenario heading text from `#### Scenario:` */
      title: z.ZodString;
      /** Markdown body between this scenario heading and the next scenario/requirement */
      bodyMarkdown: z.ZodString;
      /** Full scenario Markdown facts, including the scenario title */
      rawText: z.ZodString;
      /** Parsed scenario step facts for reading enhancements */
      steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
        /** Scenario step keyword from the list item prefix */
        keyword: z.ZodEnum<["GIVEN", "WHEN", "THEN", "AND", "BUT"]>;
        /** Markdown content after the keyword */
        contentMarkdown: z.ZodString;
        /** Original markdown list item line */
        rawText: z.ZodString;
      }, "strip", z.ZodTypeAny, {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }, {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }>, "many">>;
    }, "strip", z.ZodTypeAny, {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }, {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }>, "many">;
  }, "strip", z.ZodTypeAny, {
    id: string;
    text: string;
    title: string;
    scenarios: {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }[];
    bodyMarkdown: string;
  }, {
    id: string;
    text: string;
    title: string;
    scenarios: {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }[];
    bodyMarkdown: string;
  }>, "many">;
  /** Optional metadata */
  metadata: z.ZodOptional<z.ZodObject<{
    version: z.ZodDefault<z.ZodString>;
    format: z.ZodDefault<z.ZodLiteral<"openspec">>;
    sourcePath: z.ZodOptional<z.ZodString>;
  }, "strip", z.ZodTypeAny, {
    version: string;
    format: "openspec";
    sourcePath?: string | undefined;
  }, {
    version?: string | undefined;
    format?: "openspec" | undefined;
    sourcePath?: string | undefined;
  }>>;
}, "strip", z.ZodTypeAny, {
  id: string;
  name: string;
  requirements: {
    id: string;
    text: string;
    title: string;
    scenarios: {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }[];
    bodyMarkdown: string;
  }[];
  overview: string;
  metadata?: {
    version: string;
    format: "openspec";
    sourcePath?: string | undefined;
  } | undefined;
}, {
  id: string;
  name: string;
  requirements: {
    id: string;
    text: string;
    title: string;
    scenarios: {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }[];
    bodyMarkdown: string;
  }[];
  overview: string;
  metadata?: {
    version?: string | undefined;
    format?: "openspec" | undefined;
    sourcePath?: string | undefined;
  } | undefined;
}>;
type Spec = z.infer<typeof SpecSchema>;
/**
 * A delta describes changes to a spec within a change proposal.
 * Deltas track which specs are affected and how.
 */
declare const DeltaOperationType: z.ZodEnum<["ADDED", "MODIFIED", "REMOVED", "RENAMED"]>;
declare const DeltaSchema: z.ZodObject<{
  /** Target spec ID */
  spec: z.ZodString;
  /** Type of change */
  operation: z.ZodEnum<["ADDED", "MODIFIED", "REMOVED", "RENAMED"]>;
  /** Human-readable description */
  description: z.ZodString;
  /** Single requirement change */
  requirement: z.ZodOptional<z.ZodObject<{
    /** Unique identifier within the spec (e.g., "req-1") */
    id: z.ZodString;
    /** Requirement heading text from `### Requirement:` */
    title: z.ZodString;
    /** Markdown body between the requirement heading and the first scenario/next requirement */
    bodyMarkdown: z.ZodString;
    /** Full requirement text used for validation and search facts */
    text: z.ZodString;
    /** Test scenarios for this requirement */
    scenarios: z.ZodArray<z.ZodObject<{
      /** Scenario heading text from `#### Scenario:` */
      title: z.ZodString;
      /** Markdown body between this scenario heading and the next scenario/requirement */
      bodyMarkdown: z.ZodString;
      /** Full scenario Markdown facts, including the scenario title */
      rawText: z.ZodString;
      /** Parsed scenario step facts for reading enhancements */
      steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
        /** Scenario step keyword from the list item prefix */
        keyword: z.ZodEnum<["GIVEN", "WHEN", "THEN", "AND", "BUT"]>;
        /** Markdown content after the keyword */
        contentMarkdown: z.ZodString;
        /** Original markdown list item line */
        rawText: z.ZodString;
      }, "strip", z.ZodTypeAny, {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }, {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }>, "many">>;
    }, "strip", z.ZodTypeAny, {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }, {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }>, "many">;
  }, "strip", z.ZodTypeAny, {
    id: string;
    text: string;
    title: string;
    scenarios: {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }[];
    bodyMarkdown: string;
  }, {
    id: string;
    text: string;
    title: string;
    scenarios: {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }[];
    bodyMarkdown: string;
  }>>;
  /** Multiple requirement changes */
  requirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
    /** Unique identifier within the spec (e.g., "req-1") */
    id: z.ZodString;
    /** Requirement heading text from `### Requirement:` */
    title: z.ZodString;
    /** Markdown body between the requirement heading and the first scenario/next requirement */
    bodyMarkdown: z.ZodString;
    /** Full requirement text used for validation and search facts */
    text: z.ZodString;
    /** Test scenarios for this requirement */
    scenarios: z.ZodArray<z.ZodObject<{
      /** Scenario heading text from `#### Scenario:` */
      title: z.ZodString;
      /** Markdown body between this scenario heading and the next scenario/requirement */
      bodyMarkdown: z.ZodString;
      /** Full scenario Markdown facts, including the scenario title */
      rawText: z.ZodString;
      /** Parsed scenario step facts for reading enhancements */
      steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
        /** Scenario step keyword from the list item prefix */
        keyword: z.ZodEnum<["GIVEN", "WHEN", "THEN", "AND", "BUT"]>;
        /** Markdown content after the keyword */
        contentMarkdown: z.ZodString;
        /** Original markdown list item line */
        rawText: z.ZodString;
      }, "strip", z.ZodTypeAny, {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }, {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }>, "many">>;
    }, "strip", z.ZodTypeAny, {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }, {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }>, "many">;
  }, "strip", z.ZodTypeAny, {
    id: string;
    text: string;
    title: string;
    scenarios: {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }[];
    bodyMarkdown: string;
  }, {
    id: string;
    text: string;
    title: string;
    scenarios: {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }[];
    bodyMarkdown: string;
  }>, "many">>;
  /** Rename details (for RENAMED operation) */
  rename: z.ZodOptional<z.ZodObject<{
    from: z.ZodString;
    to: z.ZodString;
  }, "strip", z.ZodTypeAny, {
    from: string;
    to: string;
  }, {
    from: string;
    to: string;
  }>>;
}, "strip", z.ZodTypeAny, {
  description: string;
  spec: string;
  operation: "ADDED" | "MODIFIED" | "REMOVED" | "RENAMED";
  requirements?: {
    id: string;
    text: string;
    title: string;
    scenarios: {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }[];
    bodyMarkdown: string;
  }[] | undefined;
  requirement?: {
    id: string;
    text: string;
    title: string;
    scenarios: {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }[];
    bodyMarkdown: string;
  } | undefined;
  rename?: {
    from: string;
    to: string;
  } | undefined;
}, {
  description: string;
  spec: string;
  operation: "ADDED" | "MODIFIED" | "REMOVED" | "RENAMED";
  requirements?: {
    id: string;
    text: string;
    title: string;
    scenarios: {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }[];
    bodyMarkdown: string;
  }[] | undefined;
  requirement?: {
    id: string;
    text: string;
    title: string;
    scenarios: {
      title: string;
      rawText: string;
      bodyMarkdown: string;
      steps?: {
        rawText: string;
        keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
        contentMarkdown: string;
      }[] | undefined;
    }[];
    bodyMarkdown: string;
  } | undefined;
  rename?: {
    from: string;
    to: string;
  } | undefined;
}>;
type Delta = z.infer<typeof DeltaSchema>;
type DeltaOperation = z.infer<typeof DeltaOperationType>;
/**
 * A task within a change proposal.
 * Tasks are parsed from tasks.md using checkbox syntax: - [ ] or - [x]
 */
declare const TaskSchema: z.ZodObject<{
  /** Unique identifier (e.g., "task-1") */
  id: z.ZodString;
  /** Task description text */
  text: z.ZodString;
  /** Whether the task is completed */
  completed: z.ZodBoolean;
  /** Optional section heading the task belongs to */
  section: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
  id: string;
  text: string;
  completed: boolean;
  section?: string | undefined;
}, {
  id: string;
  text: string;
  completed: boolean;
  section?: string | undefined;
}>;
type Task = z.infer<typeof TaskSchema>;
declare const TrackedTaskProgressSchema: z.ZodObject<{
  tasks: z.ZodArray<z.ZodObject<{
    /** Unique identifier (e.g., "task-1") */
    id: z.ZodString;
    /** Task description text */
    text: z.ZodString;
    /** Whether the task is completed */
    completed: z.ZodBoolean;
    /** Optional section heading the task belongs to */
    section: z.ZodOptional<z.ZodString>;
  } & {
    location: z.ZodObject<{
      filePath: z.ZodString;
      taskIndex: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      filePath: string;
      taskIndex: number;
    }, {
      filePath: string;
      taskIndex: number;
    }>;
  }, "strip", z.ZodTypeAny, {
    id: string;
    text: string;
    completed: boolean;
    location: {
      filePath: string;
      taskIndex: number;
    };
    section?: string | undefined;
  }, {
    id: string;
    text: string;
    completed: boolean;
    location: {
      filePath: string;
      taskIndex: number;
    };
    section?: string | undefined;
  }>, "many">;
  total: z.ZodNumber;
  completed: z.ZodNumber;
  remaining: z.ZodNumber;
  phase: z.ZodEnum<["no-tasks", "in-progress", "complete"]>;
  source: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
    kind: z.ZodLiteral<"artifact">;
    artifactId: z.ZodString;
    outputPath: z.ZodString;
    filePaths: z.ZodArray<z.ZodString, "many">;
  }, "strip", z.ZodTypeAny, {
    kind: "artifact";
    outputPath: string;
    artifactId: string;
    filePaths: string[];
  }, {
    kind: "artifact";
    outputPath: string;
    artifactId: string;
    filePaths: string[];
  }>, z.ZodObject<{
    kind: z.ZodLiteral<"top-level-fallback">;
    artifactId: z.ZodNull;
    outputPath: z.ZodLiteral<"tasks.md">;
    filePaths: z.ZodTuple<[z.ZodLiteral<"tasks.md">], null>;
  }, "strip", z.ZodTypeAny, {
    kind: "top-level-fallback";
    outputPath: "tasks.md";
    artifactId: null;
    filePaths: ["tasks.md"];
  }, {
    kind: "top-level-fallback";
    outputPath: "tasks.md";
    artifactId: null;
    filePaths: ["tasks.md"];
  }>, z.ZodObject<{
    kind: z.ZodLiteral<"none">;
    artifactId: z.ZodNull;
    outputPath: z.ZodNull;
    filePaths: z.ZodTuple<[], null>;
  }, "strip", z.ZodTypeAny, {
    kind: "none";
    outputPath: null;
    artifactId: null;
    filePaths: [];
  }, {
    kind: "none";
    outputPath: null;
    artifactId: null;
    filePaths: [];
  }>]>;
}, "strip", z.ZodTypeAny, {
  source: {
    kind: "artifact";
    outputPath: string;
    artifactId: string;
    filePaths: string[];
  } | {
    kind: "top-level-fallback";
    outputPath: "tasks.md";
    artifactId: null;
    filePaths: ["tasks.md"];
  } | {
    kind: "none";
    outputPath: null;
    artifactId: null;
    filePaths: [];
  };
  tasks: {
    id: string;
    text: string;
    completed: boolean;
    location: {
      filePath: string;
      taskIndex: number;
    };
    section?: string | undefined;
  }[];
  total: number;
  remaining: number;
  completed: number;
  phase: "no-tasks" | "complete" | "in-progress";
}, {
  source: {
    kind: "artifact";
    outputPath: string;
    artifactId: string;
    filePaths: string[];
  } | {
    kind: "top-level-fallback";
    outputPath: "tasks.md";
    artifactId: null;
    filePaths: ["tasks.md"];
  } | {
    kind: "none";
    outputPath: null;
    artifactId: null;
    filePaths: [];
  };
  tasks: {
    id: string;
    text: string;
    completed: boolean;
    location: {
      filePath: string;
      taskIndex: number;
    };
    section?: string | undefined;
  }[];
  total: number;
  remaining: number;
  completed: number;
  phase: "no-tasks" | "complete" | "in-progress";
}>;
/**
 * A delta spec file from changes/{id}/specs/{specId}/spec.md
 * Contains the proposed changes to a spec
 */
declare const DeltaSpecSchema: z.ZodObject<{
  /** Spec ID (directory name under changes/{id}/specs/) */
  specId: z.ZodString;
  /** Raw markdown content of the delta spec */
  content: z.ZodString;
}, "strip", z.ZodTypeAny, {
  specId: string;
  content: string;
}, {
  specId: string;
  content: string;
}>;
type DeltaSpec = z.infer<typeof DeltaSpecSchema>;
/**
 * A change proposal document.
 * Located at: openspec/changes/{id}/proposal.md + tasks.md
 *
 * Change proposals describe why a change is needed, what will change,
 * which specs are affected (deltas), and trackable tasks.
 */
declare const ChangeSchema: z.ZodObject<{
  /** Directory name (e.g., "add-oauth") */
  id: z.ZodString;
  /** Human-readable name from # heading */
  name: z.ZodString;
  /** Why section - motivation for the change */
  why: z.ZodString;
  /** What Changes section - description of changes */
  whatChanges: z.ZodString;
  /** Affected specs and their changes */
  deltas: z.ZodArray<z.ZodObject<{
    /** Target spec ID */
    spec: z.ZodString;
    /** Type of change */
    operation: z.ZodEnum<["ADDED", "MODIFIED", "REMOVED", "RENAMED"]>;
    /** Human-readable description */
    description: z.ZodString;
    /** Single requirement change */
    requirement: z.ZodOptional<z.ZodObject<{
      /** Unique identifier within the spec (e.g., "req-1") */
      id: z.ZodString;
      /** Requirement heading text from `### Requirement:` */
      title: z.ZodString;
      /** Markdown body between the requirement heading and the first scenario/next requirement */
      bodyMarkdown: z.ZodString;
      /** Full requirement text used for validation and search facts */
      text: z.ZodString;
      /** Test scenarios for this requirement */
      scenarios: z.ZodArray<z.ZodObject<{
        /** Scenario heading text from `#### Scenario:` */
        title: z.ZodString;
        /** Markdown body between this scenario heading and the next scenario/requirement */
        bodyMarkdown: z.ZodString;
        /** Full scenario Markdown facts, including the scenario title */
        rawText: z.ZodString;
        /** Parsed scenario step facts for reading enhancements */
        steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
          /** Scenario step keyword from the list item prefix */
          keyword: z.ZodEnum<["GIVEN", "WHEN", "THEN", "AND", "BUT"]>;
          /** Markdown content after the keyword */
          contentMarkdown: z.ZodString;
          /** Original markdown list item line */
          rawText: z.ZodString;
        }, "strip", z.ZodTypeAny, {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }, {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }>, "many">>;
      }, "strip", z.ZodTypeAny, {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }, {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }>, "many">;
    }, "strip", z.ZodTypeAny, {
      id: string;
      text: string;
      title: string;
      scenarios: {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }[];
      bodyMarkdown: string;
    }, {
      id: string;
      text: string;
      title: string;
      scenarios: {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }[];
      bodyMarkdown: string;
    }>>;
    /** Multiple requirement changes */
    requirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
      /** Unique identifier within the spec (e.g., "req-1") */
      id: z.ZodString;
      /** Requirement heading text from `### Requirement:` */
      title: z.ZodString;
      /** Markdown body between the requirement heading and the first scenario/next requirement */
      bodyMarkdown: z.ZodString;
      /** Full requirement text used for validation and search facts */
      text: z.ZodString;
      /** Test scenarios for this requirement */
      scenarios: z.ZodArray<z.ZodObject<{
        /** Scenario heading text from `#### Scenario:` */
        title: z.ZodString;
        /** Markdown body between this scenario heading and the next scenario/requirement */
        bodyMarkdown: z.ZodString;
        /** Full scenario Markdown facts, including the scenario title */
        rawText: z.ZodString;
        /** Parsed scenario step facts for reading enhancements */
        steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
          /** Scenario step keyword from the list item prefix */
          keyword: z.ZodEnum<["GIVEN", "WHEN", "THEN", "AND", "BUT"]>;
          /** Markdown content after the keyword */
          contentMarkdown: z.ZodString;
          /** Original markdown list item line */
          rawText: z.ZodString;
        }, "strip", z.ZodTypeAny, {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }, {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }>, "many">>;
      }, "strip", z.ZodTypeAny, {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }, {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }>, "many">;
    }, "strip", z.ZodTypeAny, {
      id: string;
      text: string;
      title: string;
      scenarios: {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }[];
      bodyMarkdown: string;
    }, {
      id: string;
      text: string;
      title: string;
      scenarios: {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }[];
      bodyMarkdown: string;
    }>, "many">>;
    /** Rename details (for RENAMED operation) */
    rename: z.ZodOptional<z.ZodObject<{
      from: z.ZodString;
      to: z.ZodString;
    }, "strip", z.ZodTypeAny, {
      from: string;
      to: string;
    }, {
      from: string;
      to: string;
    }>>;
  }, "strip", z.ZodTypeAny, {
    description: string;
    spec: string;
    operation: "ADDED" | "MODIFIED" | "REMOVED" | "RENAMED";
    requirements?: {
      id: string;
      text: string;
      title: string;
      scenarios: {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }[];
      bodyMarkdown: string;
    }[] | undefined;
    requirement?: {
      id: string;
      text: string;
      title: string;
      scenarios: {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }[];
      bodyMarkdown: string;
    } | undefined;
    rename?: {
      from: string;
      to: string;
    } | undefined;
  }, {
    description: string;
    spec: string;
    operation: "ADDED" | "MODIFIED" | "REMOVED" | "RENAMED";
    requirements?: {
      id: string;
      text: string;
      title: string;
      scenarios: {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }[];
      bodyMarkdown: string;
    }[] | undefined;
    requirement?: {
      id: string;
      text: string;
      title: string;
      scenarios: {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }[];
      bodyMarkdown: string;
    } | undefined;
    rename?: {
      from: string;
      to: string;
    } | undefined;
  }>, "many">;
  /** Formal tasks selected through the OpenSpec tracked artifact contract. */
  trackedTaskProgress: z.ZodObject<{
    tasks: z.ZodArray<z.ZodObject<{
      /** Unique identifier (e.g., "task-1") */
      id: z.ZodString;
      /** Task description text */
      text: z.ZodString;
      /** Whether the task is completed */
      completed: z.ZodBoolean;
      /** Optional section heading the task belongs to */
      section: z.ZodOptional<z.ZodString>;
    } & {
      location: z.ZodObject<{
        filePath: z.ZodString;
        taskIndex: z.ZodNumber;
      }, "strip", z.ZodTypeAny, {
        filePath: string;
        taskIndex: number;
      }, {
        filePath: string;
        taskIndex: number;
      }>;
    }, "strip", z.ZodTypeAny, {
      id: string;
      text: string;
      completed: boolean;
      location: {
        filePath: string;
        taskIndex: number;
      };
      section?: string | undefined;
    }, {
      id: string;
      text: string;
      completed: boolean;
      location: {
        filePath: string;
        taskIndex: number;
      };
      section?: string | undefined;
    }>, "many">;
    total: z.ZodNumber;
    completed: z.ZodNumber;
    remaining: z.ZodNumber;
    phase: z.ZodEnum<["no-tasks", "in-progress", "complete"]>;
    source: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
      kind: z.ZodLiteral<"artifact">;
      artifactId: z.ZodString;
      outputPath: z.ZodString;
      filePaths: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
      kind: "artifact";
      outputPath: string;
      artifactId: string;
      filePaths: string[];
    }, {
      kind: "artifact";
      outputPath: string;
      artifactId: string;
      filePaths: string[];
    }>, z.ZodObject<{
      kind: z.ZodLiteral<"top-level-fallback">;
      artifactId: z.ZodNull;
      outputPath: z.ZodLiteral<"tasks.md">;
      filePaths: z.ZodTuple<[z.ZodLiteral<"tasks.md">], null>;
    }, "strip", z.ZodTypeAny, {
      kind: "top-level-fallback";
      outputPath: "tasks.md";
      artifactId: null;
      filePaths: ["tasks.md"];
    }, {
      kind: "top-level-fallback";
      outputPath: "tasks.md";
      artifactId: null;
      filePaths: ["tasks.md"];
    }>, z.ZodObject<{
      kind: z.ZodLiteral<"none">;
      artifactId: z.ZodNull;
      outputPath: z.ZodNull;
      filePaths: z.ZodTuple<[], null>;
    }, "strip", z.ZodTypeAny, {
      kind: "none";
      outputPath: null;
      artifactId: null;
      filePaths: [];
    }, {
      kind: "none";
      outputPath: null;
      artifactId: null;
      filePaths: [];
    }>]>;
  }, "strip", z.ZodTypeAny, {
    source: {
      kind: "artifact";
      outputPath: string;
      artifactId: string;
      filePaths: string[];
    } | {
      kind: "top-level-fallback";
      outputPath: "tasks.md";
      artifactId: null;
      filePaths: ["tasks.md"];
    } | {
      kind: "none";
      outputPath: null;
      artifactId: null;
      filePaths: [];
    };
    tasks: {
      id: string;
      text: string;
      completed: boolean;
      location: {
        filePath: string;
        taskIndex: number;
      };
      section?: string | undefined;
    }[];
    total: number;
    remaining: number;
    completed: number;
    phase: "no-tasks" | "complete" | "in-progress";
  }, {
    source: {
      kind: "artifact";
      outputPath: string;
      artifactId: string;
      filePaths: string[];
    } | {
      kind: "top-level-fallback";
      outputPath: "tasks.md";
      artifactId: null;
      filePaths: ["tasks.md"];
    } | {
      kind: "none";
      outputPath: null;
      artifactId: null;
      filePaths: [];
    };
    tasks: {
      id: string;
      text: string;
      completed: boolean;
      location: {
        filePath: string;
        taskIndex: number;
      };
      section?: string | undefined;
    }[];
    total: number;
    remaining: number;
    completed: number;
    phase: "no-tasks" | "complete" | "in-progress";
  }>;
  /** Secondary checkbox analytics across schema Markdown documents. */
  documentChecklistSummary: z.ZodObject<{
    groups: z.ZodArray<z.ZodObject<{
      artifactIds: z.ZodArray<z.ZodString, "many">;
      filePath: z.ZodString;
      tasks: z.ZodArray<z.ZodObject<{
        /** Unique identifier (e.g., "task-1") */
        id: z.ZodString;
        /** Task description text */
        text: z.ZodString;
        /** Whether the task is completed */
        completed: z.ZodBoolean;
        /** Optional section heading the task belongs to */
        section: z.ZodOptional<z.ZodString>;
      }, "strip", z.ZodTypeAny, {
        id: string;
        text: string;
        completed: boolean;
        section?: string | undefined;
      }, {
        id: string;
        text: string;
        completed: boolean;
        section?: string | undefined;
      }>, "many">;
      total: z.ZodNumber;
      completed: z.ZodNumber;
      remaining: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      filePath: string;
      artifactIds: string[];
    }, {
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      filePath: string;
      artifactIds: string[];
    }>, "many">;
    total: z.ZodNumber;
    completed: z.ZodNumber;
    remaining: z.ZodNumber;
  }, "strip", z.ZodTypeAny, {
    groups: {
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      filePath: string;
      artifactIds: string[];
    }[];
    total: number;
    remaining: number;
    completed: number;
  }, {
    groups: {
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      filePath: string;
      artifactIds: string[];
    }[];
    total: number;
    remaining: number;
    completed: number;
  }>;
  /** Optional design.md content */
  design: z.ZodOptional<z.ZodString>;
  /** Delta specs from changes/{id}/specs/ directory */
  deltaSpecs: z.ZodOptional<z.ZodArray<z.ZodObject<{
    /** Spec ID (directory name under changes/{id}/specs/) */
    specId: z.ZodString;
    /** Raw markdown content of the delta spec */
    content: z.ZodString;
  }, "strip", z.ZodTypeAny, {
    specId: string;
    content: string;
  }, {
    specId: string;
    content: string;
  }>, "many">>;
  /** Optional metadata */
  metadata: z.ZodOptional<z.ZodObject<{
    version: z.ZodDefault<z.ZodString>;
    format: z.ZodDefault<z.ZodLiteral<"openspec-change">>;
  }, "strip", z.ZodTypeAny, {
    version: string;
    format: "openspec-change";
  }, {
    version?: string | undefined;
    format?: "openspec-change" | undefined;
  }>>;
}, "strip", z.ZodTypeAny, {
  id: string;
  name: string;
  trackedTaskProgress: {
    source: {
      kind: "artifact";
      outputPath: string;
      artifactId: string;
      filePaths: string[];
    } | {
      kind: "top-level-fallback";
      outputPath: "tasks.md";
      artifactId: null;
      filePaths: ["tasks.md"];
    } | {
      kind: "none";
      outputPath: null;
      artifactId: null;
      filePaths: [];
    };
    tasks: {
      id: string;
      text: string;
      completed: boolean;
      location: {
        filePath: string;
        taskIndex: number;
      };
      section?: string | undefined;
    }[];
    total: number;
    remaining: number;
    completed: number;
    phase: "no-tasks" | "complete" | "in-progress";
  };
  why: string;
  whatChanges: string;
  deltas: {
    description: string;
    spec: string;
    operation: "ADDED" | "MODIFIED" | "REMOVED" | "RENAMED";
    requirements?: {
      id: string;
      text: string;
      title: string;
      scenarios: {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }[];
      bodyMarkdown: string;
    }[] | undefined;
    requirement?: {
      id: string;
      text: string;
      title: string;
      scenarios: {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }[];
      bodyMarkdown: string;
    } | undefined;
    rename?: {
      from: string;
      to: string;
    } | undefined;
  }[];
  documentChecklistSummary: {
    groups: {
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      filePath: string;
      artifactIds: string[];
    }[];
    total: number;
    remaining: number;
    completed: number;
  };
  metadata?: {
    version: string;
    format: "openspec-change";
  } | undefined;
  design?: string | undefined;
  deltaSpecs?: {
    specId: string;
    content: string;
  }[] | undefined;
}, {
  id: string;
  name: string;
  trackedTaskProgress: {
    source: {
      kind: "artifact";
      outputPath: string;
      artifactId: string;
      filePaths: string[];
    } | {
      kind: "top-level-fallback";
      outputPath: "tasks.md";
      artifactId: null;
      filePaths: ["tasks.md"];
    } | {
      kind: "none";
      outputPath: null;
      artifactId: null;
      filePaths: [];
    };
    tasks: {
      id: string;
      text: string;
      completed: boolean;
      location: {
        filePath: string;
        taskIndex: number;
      };
      section?: string | undefined;
    }[];
    total: number;
    remaining: number;
    completed: number;
    phase: "no-tasks" | "complete" | "in-progress";
  };
  why: string;
  whatChanges: string;
  deltas: {
    description: string;
    spec: string;
    operation: "ADDED" | "MODIFIED" | "REMOVED" | "RENAMED";
    requirements?: {
      id: string;
      text: string;
      title: string;
      scenarios: {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }[];
      bodyMarkdown: string;
    }[] | undefined;
    requirement?: {
      id: string;
      text: string;
      title: string;
      scenarios: {
        title: string;
        rawText: string;
        bodyMarkdown: string;
        steps?: {
          rawText: string;
          keyword: "GIVEN" | "WHEN" | "THEN" | "AND" | "BUT";
          contentMarkdown: string;
        }[] | undefined;
      }[];
      bodyMarkdown: string;
    } | undefined;
    rename?: {
      from: string;
      to: string;
    } | undefined;
  }[];
  documentChecklistSummary: {
    groups: {
      tasks: {
        id: string;
        text: string;
        completed: boolean;
        section?: string | undefined;
      }[];
      total: number;
      remaining: number;
      completed: number;
      filePath: string;
      artifactIds: string[];
    }[];
    total: number;
    remaining: number;
    completed: number;
  };
  metadata?: {
    version?: string | undefined;
    format?: "openspec-change" | undefined;
  } | undefined;
  design?: string | undefined;
  deltaSpecs?: {
    specId: string;
    content: string;
  }[] | undefined;
}>;
type Change = z.infer<typeof ChangeSchema>;
//#endregion
export { SpecSchema as _, Delta as a, TrackedTaskProgressSchema as b, DeltaSchema as c, Requirement as d, RequirementSchema as f, Spec as g, ScenarioStepSchema as h, ChangeSchema as i, DeltaSpec as l, ScenarioStepKeywordSchema as m, ChangeFile as n, DeltaOperation as o, ScenarioStep as p, ChangeFileSchema as r, DeltaOperationType as s, Change as t, DeltaSpecSchema as u, Task as v, TaskSchema as y };