speckeeper 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1377 @@
+import { z, ZodType } from 'zod';
+
+declare const PhaseSchema: z.ZodEnum<["REQ", "HLD", "LLD", "IMPL", "OPS", "CI"]>;
+type Phase = z.infer<typeof PhaseSchema>;
+declare const PrioritySchema: z.ZodEnum<["must", "should", "could", "wont"]>;
+type Priority = z.infer<typeof PrioritySchema>;
+type RequirementId = string;
+type ComponentId = string;
+type BoundaryId = string;
+type LayerId = string;
+type EntityId = string;
+type RelationId = string;
+type RuleId = string;
+type ScreenId = string;
+type TransitionId = string;
+type FormId = string;
+type UIComponentId = string;
+type ProcessFlowId = string;
+type UseCaseId = string;
+type ActorId = string;
+type DTORequirementId = string;
+type EventRequirementId = string;
+type APIRefId = string;
+type TableRefId = string;
+type IaCRefId = string;
+type BatchRefId = string;
+type ErrorCaseId = string;
+type TermId = string;
+type StateId = string;
+declare const createRequirementId: (id: string) => RequirementId;
+declare const createComponentId: (id: string) => ComponentId;
+declare const createBoundaryId: (id: string) => BoundaryId;
+declare const createLayerId: (id: string) => LayerId;
+declare const createEntityId: (id: string) => EntityId;
+declare const createRelationId: (id: string) => RelationId;
+declare const createRuleId: (id: string) => RuleId;
+declare const createScreenId: (id: string) => ScreenId;
+declare const createTransitionId: (id: string) => TransitionId;
+declare const createFormId: (id: string) => FormId;
+declare const createUIComponentId: (id: string) => UIComponentId;
+declare const createProcessFlowId: (id: string) => ProcessFlowId;
+declare const createUseCaseId: (id: string) => UseCaseId;
+declare const createActorId: (id: string) => ActorId;
+declare const createDTORequirementId: (id: string) => DTORequirementId;
+declare const createEventRequirementId: (id: string) => EventRequirementId;
+declare const createAPIRefId: (id: string) => APIRefId;
+declare const createTableRefId: (id: string) => TableRefId;
+declare const createIaCRefId: (id: string) => IaCRefId;
+declare const createBatchRefId: (id: string) => BatchRefId;
+declare const createErrorCaseId: (id: string) => ErrorCaseId;
+declare const createTermId: (id: string) => TermId;
+declare const createStateId: (id: string) => StateId;
+declare const ID_PATTERNS: {
+    readonly requirement: RegExp;
+    readonly component: RegExp;
+    readonly boundary: RegExp;
+    readonly layer: RegExp;
+    readonly entity: RegExp;
+    readonly relation: RegExp;
+    readonly rule: RegExp;
+    readonly screen: RegExp;
+    readonly transition: RegExp;
+    readonly form: RegExp;
+    readonly uiComponent: RegExp;
+    readonly processFlow: RegExp;
+    readonly useCase: RegExp;
+    readonly actor: RegExp;
+    readonly dtoRequirement: RegExp;
+    readonly eventRequirement: RegExp;
+    readonly apiRef: RegExp;
+    readonly tableRef: RegExp;
+    readonly iacRef: RegExp;
+    readonly batchRef: RegExp;
+    readonly errorCase: RegExp;
+    readonly term: RegExp;
+};
+declare const ConcretizationSlotSchema: z.ZodObject<{
+    field: z.ZodString;
+    mustDecideBy: z.ZodEnum<["REQ", "HLD", "LLD", "IMPL", "OPS", "CI"]>;
+    value: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    field: string;
+    mustDecideBy: "REQ" | "HLD" | "LLD" | "IMPL" | "OPS" | "CI";
+    value?: string | null | undefined;
+    description?: string | undefined;
+}, {
+    field: string;
+    mustDecideBy: "REQ" | "HLD" | "LLD" | "IMPL" | "OPS" | "CI";
+    value?: string | null | undefined;
+    description?: string | undefined;
+}>;
+type ConcretizationSlot = z.infer<typeof ConcretizationSlotSchema>;
+interface Link {
+    type: 'requirement' | 'component' | 'entity' | 'screen' | 'usecase' | 'external';
+    id: string;
+    label?: string;
+}
+declare const LinkSchema: z.ZodObject<{
+    type: z.ZodEnum<["requirement", "component", "entity", "screen", "usecase", "external"]>;
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "requirement" | "component" | "entity" | "screen" | "usecase" | "external";
+    id: string;
+    label?: string | undefined;
+}, {
+    type: "requirement" | "component" | "entity" | "screen" | "usecase" | "external";
+    id: string;
+    label?: string | undefined;
+}>;
+type Severity = 'error' | 'warning' | 'info';
+interface ValidationError {
+    severity: Severity;
+    code: string;
+    message: string;
+    path?: string;
+    id?: string;
+    suggestions?: string[];
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationError[];
+}
+interface ModelRegistrySchema {
+    requirements: Map<RequirementId, unknown>;
+    components: Map<ComponentId, unknown>;
+    boundaries: Map<BoundaryId, unknown>;
+    layers: Map<LayerId, unknown>;
+    entities: Map<EntityId, unknown>;
+    relations: Map<RelationId, unknown>;
+    rules: Map<RuleId, unknown>;
+    screens: Map<ScreenId, unknown>;
+    transitions: Map<TransitionId, unknown>;
+    forms: Map<FormId, unknown>;
+    uiComponents: Map<UIComponentId, unknown>;
+    processFlows: Map<ProcessFlowId, unknown>;
+    useCases: Map<UseCaseId, unknown>;
+    actors: Map<ActorId, unknown>;
+    dtoRequirements: Map<DTORequirementId, unknown>;
+    eventRequirements: Map<EventRequirementId, unknown>;
+    apiRefs: Map<APIRefId, unknown>;
+    tableRefs: Map<TableRefId, unknown>;
+    iacRefs: Map<IaCRefId, unknown>;
+    batchRefs: Map<BatchRefId, unknown>;
+    errorCases: Map<ErrorCaseId, unknown>;
+    terms: Map<TermId, unknown>;
+}
+
+/**
+ * Export Context
+ * Context information passed to exporter functions
+ */
+interface ExportContext {
+    /** Access to all models (MetaModelRegistry type, using unknown to avoid circular references) */
+    registry: unknown;
+    /** Configuration (SpeckeeperConfig type, using unknown to avoid circular references) */
+    config: unknown;
+    /** Output base directory */
+    outputDir: string;
+    /** Current date/time */
+    generatedAt: Date;
+}
+/**
+ * Lint Context
+ * Context information passed to lint functions
+ */
+interface LintContext {
+    /** Access to all models (MetaModelRegistry type) */
+    registry: unknown;
+    /** Current phase */
+    phase?: 'REQ' | 'HLD' | 'LLD' | 'OPS';
+    /** Strict mode */
+    strict?: boolean;
+}
+/**
+ * Check Context
+ * Context information passed to external SSOT check functions
+ */
+interface CheckContext {
+    /** Access to all models (MetaModelRegistry type) */
+    registry: unknown;
+    /** External SSOT file path */
+    sourcePath: string;
+    /** Configuration (SpeckeeperConfig type) */
+    config: unknown;
+}
+/**
+ * Lint Issue
+ */
+interface LintIssue {
+    /** Issue message */
+    message: string;
+    /** Problematic field (optional) */
+    field?: string;
+    /** Fix suggestion (optional) */
+    suggestion?: string;
+}
+/**
+ * Check Result
+ */
+interface CheckResult$1 {
+    /** Whether successful */
+    success: boolean;
+    /** List of error messages */
+    errors: CheckError[];
+    /** List of warning messages */
+    warnings: CheckWarning[];
+}
+interface CheckError {
+    /** Error message */
+    message: string;
+    /** Target model ID */
+    modelId: string;
+    /** External SSOT reference */
+    externalRef?: string;
+}
+interface CheckWarning {
+    /** Warning message */
+    message: string;
+    /** Target model ID */
+    modelId: string;
+}
+/**
+ * Markdown Exporter
+ */
+interface MarkdownExporter<T> {
+    /** Single document generation */
+    single: (model: T, context: ExportContext) => string;
+    /** Index page generation (optional) */
+    index?: (models: T[], context: ExportContext) => string;
+    /** Output directory (relative path from docs/) */
+    outputDir: string;
+    /** Filename generation (default is model.id) */
+    filename?: (model: T) => string;
+}
+/**
+ * Mermaid Diagram Exporter
+ */
+interface MermaidExporter<T> {
+    /** Diagram type */
+    diagramType: 'flowchart' | 'sequenceDiagram' | 'erDiagram' | 'stateDiagram' | 'C4Context' | 'C4Container' | 'C4Component' | 'custom';
+    /** Diagram generation function */
+    generate: (models: T[], context: ExportContext) => string;
+    /** Output file path (relative path from docs/) */
+    outputPath: string;
+    /** Diagram title */
+    title?: string;
+}
+/**
+ * JSON Schema Exporter Settings
+ */
+interface JsonSchemaExporter {
+    /** Enabled */
+    enabled: boolean;
+    /** Output directory (relative path from specs/) */
+    outputDir: string;
+}
+/**
+ * Lint Rule
+ */
+interface LintRule$1<T> {
+    /** Rule ID */
+    id: string;
+    /** Rule description */
+    description: string;
+    /** Severity */
+    severity: 'error' | 'warning' | 'info';
+    /** Check function */
+    check: (model: T, context: LintContext) => LintIssue | null;
+}
+/**
+ * External SSOT Checker
+ */
+interface ExternalChecker$1<T> {
+    /** External SSOT type to check */
+    targetType: 'openapi' | 'ddl' | 'iac' | 'custom';
+    /** Execute check */
+    check: (model: T, externalSource: unknown, context: CheckContext) => CheckResult$1;
+    /** Get external SSOT file path (from model) */
+    getSourcePath?: (model: T) => string | undefined;
+}
+/**
+ * Inter-model Reference Definition (for traceability)
+ */
+interface ReferenceDefinition {
+    /** Field name with reference */
+    field: string;
+    /** Referenced model ID */
+    targetModel: string;
+    /** Whether reference is required */
+    required?: boolean;
+    /** Whether reference is array */
+    isArray?: boolean;
+}
+/**
+ * Model Definition
+ * Interface for users to define new entities
+ */
+interface ModelDefinition<T extends z.ZodTypeAny = z.ZodTypeAny> {
+    /** Model unique identifier (kebab-case recommended) */
+    id: string;
+    /** Model name (PascalCase recommended) */
+    name: string;
+    /** Model description */
+    description: string;
+    /** Zod Schema */
+    schema: T;
+    /** ID prefix for generation */
+    idPrefix: string;
+    /** Exporter settings */
+    exporters?: {
+        /** Markdown exporter */
+        markdown?: MarkdownExporter<z.infer<T>>;
+        /** Mermaid diagram exporter (multiple allowed) */
+        mermaid?: MermaidExporter<z.infer<T>> | MermaidExporter<z.infer<T>>[];
+        /** JSON Schema exporter */
+        jsonSchema?: JsonSchemaExporter;
+    };
+    /** Lint rules */
+    lintRules?: LintRule$1<z.infer<T>>[];
+    /** External SSOT checker */
+    externalChecker?: ExternalChecker$1<z.infer<T>>;
+    /** Reference definitions (for traceability) */
+    references?: ReferenceDefinition[];
+    /** DSL function name (the Xxx part of defineXxx) */
+    dslName?: string;
+    /** Phase (the phase where this model is primarily used) */
+    phase?: 'REQ' | 'HLD' | 'LLD' | 'OPS';
+}
+/**
+ * Meta Model Registry
+ * Manages registered model definitions and model instances
+ */
+interface MetaModelRegistry {
+    /** Registered model definitions */
+    definitions: Map<string, ModelDefinition>;
+    /** Model instances (Map<instanceId, instance> for each model ID) */
+    instances: Map<string, Map<string, unknown>>;
+}
+/**
+ * Additional settings for meta model
+ */
+interface MetaModelConfig {
+    /** Custom model definitions */
+    models?: ModelDefinition[];
+    /** External SSOT settings */
+    externalSsot?: {
+        openapi?: {
+            enabled: boolean;
+            paths: string[];
+        };
+        ddl?: {
+            enabled: boolean;
+            type: 'ddl' | 'prisma' | 'typeorm' | 'drizzle';
+            path: string;
+        };
+        iac?: {
+            enabled: boolean;
+            type: 'cloudformation' | 'cdk' | 'terraform';
+            path: string;
+        };
+    };
+}
+/**
+ * Base type for model instances
+ * All model instances have an id
+ */
+interface BaseModelInstance {
+    id: string;
+}
+/**
+ * Helper type for creating type-safe model definitions
+ */
+type InferModelType<T extends ModelDefinition> = z.infer<T['schema']>;
+declare const ReferenceDefinitionSchema: z.ZodObject<{
+    field: z.ZodString;
+    targetModel: z.ZodString;
+    required: z.ZodOptional<z.ZodBoolean>;
+    isArray: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    field: string;
+    targetModel: string;
+    required?: boolean | undefined;
+    isArray?: boolean | undefined;
+}, {
+    field: string;
+    targetModel: string;
+    required?: boolean | undefined;
+    isArray?: boolean | undefined;
+}>;
+declare const LintIssueSchema: z.ZodObject<{
+    message: z.ZodString;
+    field: z.ZodOptional<z.ZodString>;
+    suggestion: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    field?: string | undefined;
+    suggestion?: string | undefined;
+}, {
+    message: string;
+    field?: string | undefined;
+    suggestion?: string | undefined;
+}>;
+declare const CheckErrorSchema: z.ZodObject<{
+    message: z.ZodString;
+    modelId: z.ZodString;
+    externalRef: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    modelId: string;
+    externalRef?: string | undefined;
+}, {
+    message: string;
+    modelId: string;
+    externalRef?: string | undefined;
+}>;
+declare const CheckWarningSchema: z.ZodObject<{
+    message: z.ZodString;
+    modelId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    modelId: string;
+}, {
+    message: string;
+    modelId: string;
+}>;
+declare const CheckResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    errors: z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        modelId: z.ZodString;
+        externalRef: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        modelId: string;
+        externalRef?: string | undefined;
+    }, {
+        message: string;
+        modelId: string;
+        externalRef?: string | undefined;
+    }>, "many">;
+    warnings: z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        modelId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        modelId: string;
+    }, {
+        message: string;
+        modelId: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    errors: {
+        message: string;
+        modelId: string;
+        externalRef?: string | undefined;
+    }[];
+    warnings: {
+        message: string;
+        modelId: string;
+    }[];
+}, {
+    success: boolean;
+    errors: {
+        message: string;
+        modelId: string;
+        externalRef?: string | undefined;
+    }[];
+    warnings: {
+        message: string;
+        modelId: string;
+    }[];
+}>;
+
+/**
+ * Definition and validation of model relations
+ */
+
+/**
+ * Model abstraction level
+ *
+ * - L0: Business + Domain Analysis (Why / Problem space)
+ *       Desired outcomes/value, business flows, actors, terminology, business rules
+ * - L1: Requirements (What)
+ *       Functional/non-functional requirements, constraints, acceptance criteria
+ * - L2: Design (How / Direction)
+ *       Architecture, component breakdown, domain model, key sequences
+ * - L3: Detailed Design/Implementation (How to build / Concrete artifacts)
+ *       Screen/API/DB definitions, external SSOT references
+ */
+type ModelLevel = 'L0' | 'L1' | 'L2' | 'L3';
+/**
+ * Get numeric index of level
+ */
+declare function getLevelIndex(level: ModelLevel): number;
+/**
+ * Relation types
+ */
+declare const RELATION_TYPES: readonly ["dependsOn", "uses", "includes", "implements", "refines", "verifies", "satisfies", "traces", "relatedTo"];
+type RelationType = typeof RELATION_TYPES[number];
+/**
+ * Relation schema
+ */
+declare const RelationSchema: z.ZodObject<{
+    /** Relation type */
+    type: z.ZodEnum<["dependsOn", "uses", "includes", "implements", "refines", "verifies", "satisfies", "traces", "relatedTo"]>;
+    /** Target ID */
+    target: z.ZodString;
+    /** Description (optional) */
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "includes" | "dependsOn" | "uses" | "implements" | "refines" | "verifies" | "satisfies" | "traces" | "relatedTo";
+    target: string;
+    description?: string | undefined;
+}, {
+    type: "includes" | "dependsOn" | "uses" | "implements" | "refines" | "verifies" | "satisfies" | "traces" | "relatedTo";
+    target: string;
+    description?: string | undefined;
+}>;
+/**
+ * Relation field to add to model schemas
+ * Usage: schema.extend({ relations: RelationsFieldSchema })
+ */
+declare const RelationsFieldSchema: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    /** Relation type */
+    type: z.ZodEnum<["dependsOn", "uses", "includes", "implements", "refines", "verifies", "satisfies", "traces", "relatedTo"]>;
+    /** Target ID */
+    target: z.ZodString;
+    /** Description (optional) */
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "includes" | "dependsOn" | "uses" | "implements" | "refines" | "verifies" | "satisfies" | "traces" | "relatedTo";
+    target: string;
+    description?: string | undefined;
+}, {
+    type: "includes" | "dependsOn" | "uses" | "implements" | "refines" | "verifies" | "satisfies" | "traces" | "relatedTo";
+    target: string;
+    description?: string | undefined;
+}>, "many">>;
+type Relation = z.infer<typeof RelationSchema>;
+/**
+ * Definition of relation constraints
+ */
+interface RelationConstraint {
+    /** Allowed target levels (all levels allowed if not specified) */
+    allowedTargetLevels?: ModelLevel[];
+    /** Level constraint rule */
+    levelRule: 'source>target' | 'source>=target' | 'same' | 'any';
+    /** Direction of impact propagation */
+    propagation: 'forward' | 'backward' | 'both';
+}
+/**
+ * Constraint definitions per relation type
+ *
+ * Level hierarchy:
+ *   L0 (Business) → L1 (Requirements) → L2 (Design) → L3 (Implementation)
+ *   Abstract ───────────────────────────→ Concrete
+ */
+declare const RELATION_CONSTRAINTS: Record<RelationType, RelationConstraint>;
+/**
+ * Relation validation error
+ */
+interface RelationValidationError {
+    type: 'level_violation' | 'target_level_violation' | 'self_reference' | 'cycle_detected';
+    message: string;
+    relation: Relation;
+    sourceId: string;
+}
+/**
+ * Validate level constraint for single relation
+ *
+ * @param sourceLevel - Source model level (set in _models/)
+ * @param sourceSpecId - Source spec ID
+ * @param relation - Relation
+ * @param targetLevel - Target model level
+ */
+declare function validateRelationLevel(sourceLevel: ModelLevel | undefined, sourceSpecId: string, relation: Relation, targetLevel: ModelLevel | undefined): RelationValidationError | null;
+/**
+ * Detect circular references
+ */
+declare function detectCycles(relations: Array<{
+    sourceId: string;
+    targetId: string;
+    type: RelationType;
+}>): RelationValidationError[];
+/**
+ * Infer model ID from spec ID (prefix-based)
+ */
+declare function inferModelIdFromSpecId(specId: string): string | undefined;
+
+/**
+ * Model base class
+ *
+ * All model definitions inherit from this class
+ */
+
+/**
+ * Lint rule definition
+ */
+interface LintRule<T> {
+    id: string;
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    check: (spec: T) => boolean;
+}
+/**
+ * Lint result
+ */
+interface LintResult {
+    ruleId: string;
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    specId?: string;
+}
+/**
+ * Exporter definition
+ */
+interface Exporter<T> {
+    format: 'markdown' | 'json' | 'mermaid';
+    single?: (spec: T) => string;
+    index?: (specs: T[]) => string;
+    outputDir?: string;
+    filename?: (spec: T) => string;
+}
+/**
+ * External checker definition
+ */
+interface ExternalChecker<T> {
+    targetType: string;
+    sourcePath: (spec: T) => string;
+    check: (spec: T, externalData: unknown) => CheckResult;
+}
+/**
+ * Check result
+ */
+interface CheckResult {
+    success: boolean;
+    errors: {
+        message: string;
+        field?: string;
+        specId?: string;
+    }[];
+    warnings: {
+        message: string;
+        field?: string;
+        specId?: string;
+    }[];
+}
+/**
+ * Coverage result
+ */
+interface CoverageResult {
+    /** Total target count */
+    total: number;
+    /** Covered count */
+    covered: number;
+    /** Uncovered count */
+    uncovered: number;
+    /** Coverage rate (%) */
+    coveragePercent: number;
+    /** Details of covered items */
+    coveredItems: {
+        id: string;
+        description?: string;
+    }[];
+    /** Details of uncovered items */
+    uncoveredItems: {
+        id: string;
+        description?: string;
+        sourceId?: string;
+    }[];
+}
+/**
+ * Coverage checker definition
+ *
+ * Verify cross-model consistency (coverage).
+ * Example: Whether TestRef covers acceptanceCriteria of Requirement
+ */
+interface CoverageChecker<T> {
+    /** Target model ID for coverage (e.g. 'requirement') */
+    targetModel: string;
+    /** Description of coverage check */
+    description: string;
+    /** Execute coverage check */
+    check: (specs: T[], registry: Record<string, Map<string, unknown>>) => CoverageResult;
+}
+/**
+ * Render context
+ * Simplified version compatible with embedoc's EmbedContext
+ */
+interface RenderContext {
+    /** Parameters (filter conditions other than format, etc.) */
+    params: Record<string, string | undefined>;
+    /** Markdown helpers */
+    markdown: {
+        /** Generate table */
+        table: (headers: string[], rows: (string | unknown)[][]) => string;
+    };
+}
+/**
+ * Renderer definition
+ *
+ * Model-specific rendering called from embeds
+ */
+interface Renderer<T> {
+    /** Format ID ('table', 'list', 'detail', 'spec-chapter', etc.) */
+    format: string;
+    /** Rendering process */
+    render: (specs: T[], ctx: RenderContext) => string;
+}
+/**
+ * Model base class
+ *
+ * @template TSchema - Zod schema type
+ */
+declare abstract class Model<TSchema extends ZodType> {
+    /** Singleton instance storage (per subclass) */
+    private static _instances;
+    /**
+     * Get singleton instance of the model
+     * Usage: RequirementModel.instance
+     */
+    static get instance(): Model<ZodType>;
+    /** Model ID ('requirement', 'usecase', etc.) */
+    abstract readonly id: string;
+    /** Model name ('Requirement', 'UseCase', etc.) */
+    abstract readonly name: string;
+    /** ID prefix ('REQ', 'UC', etc.) */
+    abstract readonly idPrefix: string;
+    /** Zod schema */
+    abstract readonly schema: TSchema;
+    /** Model description (optional) */
+    readonly description?: string;
+    /** External SSOT type (optional, e.g. 'OpenAPI', 'DDL/Prisma') */
+    readonly externalSsotType?: string;
+    /** Spec instance type */
+    protected get specType(): z.infer<TSchema>;
+    /** Lint rules (override in subclass) */
+    protected lintRules: LintRule<z.infer<TSchema>>[];
+    /** Exporters (override in subclass) */
+    protected exporters: Exporter<z.infer<TSchema>>[];
+    /** External checker (optional) */
+    protected externalChecker?: ExternalChecker<z.infer<TSchema>>;
+    /** Coverage checker (optional) */
+    protected coverageChecker?: CoverageChecker<z.infer<TSchema>>;
+    /** Model level (set in _models/) */
+    protected modelLevel?: ModelLevel;
+    /** Renderers (for embeds, override in subclass) */
+    protected renderers: Renderer<z.infer<TSchema>>[];
+    /**
+     * Get model level
+     * Returns modelLevel set in _models/
+     */
+    get level(): ModelLevel | undefined;
+    /**
+     * Execute schema validation
+     */
+    validate(spec: unknown): z.infer<TSchema>;
+    /**
+     * Schema validation (safe version, returns error object on failure)
+     */
+    safeParse(spec: unknown): {
+        success: true;
+        data: z.infer<TSchema>;
+    } | {
+        success: false;
+        error: z.ZodError;
+    };
+    /**
+     * Execute lint
+     */
+    lint(spec: z.infer<TSchema>): LintResult[];
+    /**
+     * Execute lint for multiple specs
+     */
+    lintAll(specs: z.infer<TSchema>[]): LintResult[];
+    /**
+     * Validate level constraints of relations
+     * @param spec - Spec instance (if it has relations property)
+     * @returns Array of validation errors
+     */
+    validateRelations(spec: z.infer<TSchema>): RelationValidationError[];
+    /**
+     * Validate relations of multiple specs (including circular reference check)
+     */
+    validateAllRelations(specs: z.infer<TSchema>[]): RelationValidationError[];
+    /**
+     * Export in specified format (single spec)
+     */
+    exportSingle(spec: z.infer<TSchema>, format: string): string | null;
+    /**
+     * Export in specified format (index)
+     */
+    exportIndex(specs: z.infer<TSchema>[], format: string): string | null;
+    /**
+     * Get exporter output directory
+     */
+    getOutputDir(format: string): string | null;
+    /**
+     * Get filename
+     */
+    getFilename(spec: z.infer<TSchema>, format: string): string | null;
+    /**
+     * Check consistency with external SSOT
+     */
+    check(spec: z.infer<TSchema>, externalData: unknown): CheckResult;
+    /**
+     * Get external SSOT path
+     */
+    getExternalSourcePath(spec: z.infer<TSchema>): string | null;
+    /**
+     * Execute coverage check
+     * @param specs - Array of spec instances for this model
+     * @param registry - Registry of all models
+     */
+    checkCoverage(specs: z.infer<TSchema>[], registry: Record<string, Map<string, unknown>>): CoverageResult | null;
+    /**
+     * Get coverage checker
+     */
+    getCoverageChecker(): CoverageChecker<z.infer<TSchema>> | undefined;
+    /**
+     * Get lint rules
+     */
+    getLintRules(): LintRule<z.infer<TSchema>>[];
+    /**
+     * Get exporters
+     */
+    getExporters(): Exporter<z.infer<TSchema>>[];
+    /**
+     * Render in specified format
+     * @param format - Format ID ('table', 'list', 'detail', etc.)
+     * @param specs - Array of specs to render
+     * @param ctx - Render context
+     * @returns Rendered result (Markdown string), null if no matching renderer
+     */
+    render(format: string, specs: z.infer<TSchema>[], ctx: RenderContext): string | null;
+    /**
+     * Get list of available formats
+     */
+    getAvailableFormats(): string[];
+    /**
+     * Get renderers
+     */
+    getRenderers(): Renderer<z.infer<TSchema>>[];
+    /**
+     * Check if renderer exists for specific format
+     */
+    hasRenderer(format: string): boolean;
+}
+/**
+ * Register model
+ */
+declare function registerModel(model: Model<any>): void;
+/**
+ * Get model
+ */
+declare function getModel(id: string): Model<any> | undefined;
+/**
+ * Get all registered models
+ */
+declare function getAllModels(): Model<any>[];
+/**
+ * Clear registry
+ */
+declare function clearModelRegistry(): void;
+
+/**
+ * Register model definition
+ */
+declare function registerModelDefinition<T extends z.ZodTypeAny>(definition: ModelDefinition<T>): void;
+/**
+ * Register multiple model definitions at once
+ */
+declare function registerModelDefinitions(definitions: ModelDefinition[]): void;
+/**
+ * Get model definition
+ */
+declare function getModelDefinition(modelId: string): ModelDefinition | undefined;
+/**
+ * Get all model definitions
+ */
+declare function getAllModelDefinitions(): ModelDefinition[];
+/**
+ * Register model instance
+ */
+declare function registerModelInstance<T extends {
+    id: string;
+}>(modelId: string, instance: T): void;
+/**
+ * Get model instance
+ */
+declare function getModelInstance<T = unknown>(modelId: string, instanceId: string): T | undefined;
+/**
+ * Get all instances of a model
+ */
+declare function getAllModelInstances<T = unknown>(modelId: string): T[];
+/**
+ * Get all instances of all models (flattened)
+ */
+declare function getAllInstances(): Array<{
+    modelId: string;
+    instance: unknown;
+}>;
+/**
+ * Get global registry
+ */
+declare function getGlobalModelRegistry(): MetaModelRegistry;
+/**
+ * Reset registry (for testing)
+ */
+declare function resetModelRegistry(): void;
+/**
+ * Reset instances only (keep definitions)
+ */
+declare function resetModelInstances(): void;
+/**
+ * Execute lint for specific model
+ */
+declare function lintModel<T extends {
+    id: string;
+}>(modelId: string, instance: T, context: LintContext): Array<{
+    rule: LintRule$1<T>;
+    issue: LintIssue;
+}>;
+/**
+ * Execute lint for all models
+ */
+declare function lintAllModels(context: LintContext): Array<{
+    modelId: string;
+    instanceId: string;
+    rule: LintRule$1<unknown>;
+    issue: LintIssue;
+}>;
+/**
+ * Execute Markdown export
+ */
+declare function exportMarkdown(modelId: string, context: ExportContext): Array<{
+    path: string;
+    content: string;
+}>;
+/**
+ * Execute Mermaid diagram export
+ */
+declare function exportMermaid(modelId: string, context: ExportContext): Array<{
+    path: string;
+    content: string;
+}>;
+/**
+ * Execute export for all models
+ */
+declare function exportAllModels(context: ExportContext): Array<{
+    path: string;
+    content: string;
+}>;
+/**
+ * Execute external SSOT check
+ */
+declare function checkExternalSsot<T extends {
+    id: string;
+}>(modelId: string, externalSource: unknown, context: CheckContext): CheckResult$1;
+/**
+ * Resolve reference
+ */
+declare function resolveReference(modelId: string, instanceId: string, field: string): unknown | undefined;
+/**
+ * Check reference integrity
+ */
+declare function checkReferenceIntegrity(): Array<{
+    modelId: string;
+    instanceId: string;
+    field: string;
+    targetModel: string;
+    missingIds: string[];
+}>;
+/**
+ * Get registry statistics
+ */
+declare function getModelRegistryStats(): {
+    definitionCount: number;
+    instanceCounts: Record<string, number>;
+    totalInstances: number;
+};
+
+/**
+ * Configuration API for speckeeper
+ *
+ * Provides `defineConfig` and `defineModel` functions for users to
+ * create speckeeper.config.ts files with custom model definitions.
+ */
+
+/**
+ * speckeeper configuration type
+ */
+interface SpeckeeperConfigInput {
+    /** Project name */
+    projectName?: string;
+    /** Project version */
+    version?: string;
+    /** Design files directory */
+    designDir?: string;
+    /** Docs output directory */
+    docsDir?: string;
+    /** Specs output directory */
+    specsDir?: string;
+    /** Custom model definitions (Model instances or ModelDefinition objects) */
+    models?: any[];
+    /** External SSOT configuration */
+    externalSsot?: {
+        openapi?: {
+            enabled: boolean;
+            paths: string[];
+        };
+        ddl?: {
+            enabled: boolean;
+            type: 'ddl' | 'prisma' | 'typeorm' | 'drizzle';
+            path: string;
+        };
+        iac?: {
+            enabled: boolean;
+            type: 'cloudformation' | 'cdk' | 'terraform';
+            path: string;
+        };
+    };
+    /** Lint configuration */
+    lint?: {
+        /** Strict mode */
+        strict?: boolean;
+        /** Disable specific rules */
+        disabledRules?: string[];
+    };
+}
+/**
+ * Resolved speckeeper configuration
+ */
+interface ResolvedSpeckeeperConfig extends SpeckeeperConfigInput {
+    designDir: string;
+    docsDir: string;
+    specsDir: string;
+}
+/**
+ * Define speckeeper configuration
+ *
+ * @example
+ * ```typescript
+ * // speckeeper.config.ts
+ * import { defineConfig, defineModel } from 'speckeeper';
+ *
+ * export default defineConfig({
+ *   projectName: 'My Project',
+ *   models: [
+ *     // Custom model definitions
+ *   ],
+ * });
+ * ```
+ */
+declare function defineConfig(input: SpeckeeperConfigInput): ResolvedSpeckeeperConfig;
+/**
+ * Model definition input type
+ */
+interface ModelDefinitionInput<T extends z.ZodTypeAny> {
+    /** Unique identifier for the model (kebab-case recommended) */
+    id: string;
+    /** Model name (PascalCase recommended) */
+    name: string;
+    /** Model description */
+    description: string;
+    /** Zod schema */
+    schema: T;
+    /** Prefix for ID generation */
+    idPrefix: string;
+    /** Exporter configuration */
+    exporters?: {
+        markdown?: MarkdownExporter<z.infer<T>>;
+        mermaid?: MermaidExporter<z.infer<T>> | MermaidExporter<z.infer<T>>[];
+        jsonSchema?: JsonSchemaExporter;
+    };
+    /** Lint rules */
+    lintRules?: LintRule$1<z.infer<T>>[];
+    /** External SSOT checker */
+    externalChecker?: ExternalChecker$1<z.infer<T>>;
+    /** Reference definitions */
+    references?: ReferenceDefinition[];
+    /** DSL function name */
+    dslName?: string;
+    /** Phase */
+    phase?: 'REQ' | 'HLD' | 'LLD' | 'OPS';
+}
+/**
+ * Create a custom model definition
+ *
+ * @example
+ * ```typescript
+ * const RetryPolicyModel = defineModel({
+ *   id: 'retry-policy',
+ *   name: 'RetryPolicy',
+ *   description: 'Retry policy definition',
+ *   schema: z.object({
+ *     id: z.string(),
+ *     name: z.string(),
+ *     maxAttempts: z.number().min(1),
+ *     initialDelay: z.number().min(0),
+ *     backoffMultiplier: z.number().min(1),
+ *   }),
+ *   idPrefix: 'RETRY',
+ *   exporters: {
+ *     markdown: {
+ *       single: (m) => `# ${m.name}\n\n- Max Attempts: ${m.maxAttempts}`,
+ *       outputDir: 'docs/retry-policies',
+ *     },
+ *   },
+ *   lintRules: [
+ *     {
+ *       id: 'retry-max-limit',
+ *       description: 'maxAttempts should not exceed 10',
+ *       severity: 'warning',
+ *       check: (m) => m.maxAttempts > 10
+ *         ? { message: `maxAttempts ${m.maxAttempts} exceeds recommended limit` }
+ *         : null,
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+declare function defineModel<T extends z.ZodTypeAny>(input: ModelDefinitionInput<T>): ModelDefinition<T>;
+/**
+ * Helper to create Markdown exporter
+ */
+declare function createMarkdownExporter<T>(config: {
+    outputDir: string;
+    single: (model: T, context: unknown) => string;
+    index?: (models: T[], context: unknown) => string;
+    filename?: (model: T) => string;
+}): MarkdownExporter<T>;
+/**
+ * Helper to create Mermaid diagram exporter
+ */
+declare function createMermaidExporter<T>(config: {
+    diagramType: MermaidExporter<T>['diagramType'];
+    outputPath: string;
+    generate: (models: T[], context: unknown) => string;
+    title?: string;
+}): MermaidExporter<T>;
+/**
+ * Helper to create lint rule
+ */
+declare function createLintRule<T>(config: {
+    id: string;
+    description: string;
+    severity: 'error' | 'warning' | 'info';
+    check: (model: T, context: unknown) => {
+        message: string;
+        field?: string;
+        suggestion?: string;
+    } | null;
+}): LintRule$1<T>;
+/**
+ * Load speckeeper.config.ts file and register custom models
+ */
+declare function loadSpeckeeperConfig(configPath?: string): Promise<ResolvedSpeckeeperConfig | null>;
+
+/**
+ * Specification-compliant output path definitions
+ *
+ * Human-readable artifacts (docs/):
+ *   requirements/     - Requirements Markdown
+ *   usecases/         - Use cases
+ *   architecture/     - Architecture (C4 diagrams)
+ *   data-model/       - Conceptual model (ER diagrams)
+ *   screens/          - Screen specifications
+ *   flows/            - Process flows
+ *   glossary/         - Glossary
+ *
+ * Machine-readable artifacts (specs/):
+ *   schemas/entities/       - Entity JSON Schema
+ *   index.json              - Aggregated data
+ */
+interface OutputPaths {
+    requirements: string;
+    usecases: string;
+    architecture: string;
+    dataModel: string;
+    screens: string;
+    flows: string;
+    glossary: string;
+    component: string;
+    schemasEntities: string;
+}
+interface SpeckeeperConfig {
+    projectName?: string;
+    version?: string;
+    srcDir: string;
+    requirementsDir?: string;
+    designDir?: string;
+    usecasesDir?: string;
+    docsDir: string;
+    specsDir: string;
+    externalSsot?: {
+        openapi?: {
+            enabled: boolean;
+            paths: string[];
+            microContracts?: {
+                enabled: boolean;
+                requiredExtensions?: string[];
+                strictMode?: boolean;
+            };
+        };
+        ddl?: {
+            enabled: boolean;
+            paths: string[];
+            type: 'ddl' | 'prisma' | 'typeorm' | 'drizzle';
+        };
+        iac?: {
+            enabled: boolean;
+            paths: string[];
+            type: 'cloudformation' | 'terraform' | 'cdk';
+        };
+    };
+    lint?: {
+        architecture?: {
+            allowCrossBoundaryDependencies?: boolean;
+            allowCrossLayerViolations?: boolean;
+            maxComponentsPerDiagram?: number;
+        };
+        conceptModel?: {
+            requireEntityDescription?: boolean;
+            requireAggregateRoot?: boolean;
+            warnOnOrphanEntities?: boolean;
+            namingConvention?: 'PascalCase' | 'camelCase' | 'snake_case' | 'none';
+        };
+        screen?: {
+            warnOnOrphanScreens?: boolean;
+            warnOnDeadEnds?: boolean;
+            checkAuthPaths?: boolean;
+        };
+        phaseGate?: {
+            currentPhase?: 'REQ' | 'HLD' | 'LLD' | 'OPS';
+            strictMode?: boolean;
+        };
+    };
+    build?: {
+        generateMermaidImages?: boolean;
+        mermaidCliPath?: string;
+    };
+    models?: unknown[];
+}
+/**
+ * Get output paths compliant with specification
+ */
+declare function getOutputPaths(config: SpeckeeperConfig, cwd?: string): OutputPaths;
+/**
+ * List of expected output paths (for drift check)
+ */
+declare function getExpectedOutputDirs(config: SpeckeeperConfig, cwd?: string): string[];
+/**
+ * Validate if output path complies with specification
+ */
+declare function validateOutputPaths(actualPath: string, config: SpeckeeperConfig, cwd?: string): {
+    valid: boolean;
+    expectedPaths: string[];
+    message?: string;
+};
+declare function findConfigFile(startDir?: string): string | null;
+declare function loadConfig(configPath?: string, cwd?: string): Promise<SpeckeeperConfig>;
+declare function validateConfig(config: SpeckeeperConfig): string[];
+
+interface WriteResult {
+    path: string;
+    created: boolean;
+    updated: boolean;
+    unchanged: boolean;
+}
+declare function ensureDir(dirPath: string): void;
+declare function writeFile(filePath: string, content: string): WriteResult;
+declare function writeJsonFile(filePath: string, data: unknown, indent?: number): WriteResult;
+interface BatchWriteResult {
+    results: WriteResult[];
+    created: number;
+    updated: number;
+    unchanged: number;
+    total: number;
+}
+declare function batchWriteFiles(files: Array<{
+    path: string;
+    content: string;
+}>): BatchWriteResult;
+interface DriftResult {
+    file: string;
+    hasDrift: boolean;
+    expectedHash?: string;
+    actualHash?: string;
+    missing?: boolean;
+}
+declare function computeHash(content: string): string;
+declare function checkFileDrift(filePath: string, expectedContent: string): DriftResult;
+declare function checkBatchDrift(files: Array<{
+    path: string;
+    content: string;
+}>): DriftResult[];
+declare function findFiles(pattern: string, cwd?: string): Promise<string[]>;
+declare function findTypeScriptFiles(srcDir: string): Promise<string[]>;
+declare function findDefinitionFiles(srcDir: string, subDir: string): Promise<string[]>;
+declare function generateDocsPath(baseDir: string, category: string, filename: string): string;
+declare function generateSpecsPath(baseDir: string, category: string, filename: string): string;
+
+/**
+ * Model Loader
+ *
+ * Load models defined in TypeScript and convert to usable format for build command
+ */
+
+/**
+ * Model registry - stores all loaded models
+ */
+interface ModelRegistry {
+    requirements: Map<string, unknown>;
+    useCases: Map<string, unknown>;
+    actors: Map<string, unknown>;
+    components: Map<string, unknown>;
+    entities: Map<string, unknown>;
+    relations: Map<string, unknown>;
+    rules: Map<string, unknown>;
+    screens: Map<string, unknown>;
+    transitions: Map<string, unknown>;
+    forms: Map<string, unknown>;
+    processFlows: Map<string, unknown>;
+    glossaryTerms: Map<string, unknown>;
+    apiRefs: Map<string, unknown>;
+    tableRefs: Map<string, unknown>;
+    testRefs: Map<string, unknown>;
+    layers: Map<string, unknown>;
+    boundaries: Map<string, unknown>;
+    artifacts: Map<string, unknown>;
+}
+declare function createEmptyRegistry(): ModelRegistry;
+declare function getGlobalRegistry(): ModelRegistry;
+declare function resetGlobalRegistry(): void;
+/**
+ * Dynamically import TS files from specified directory and collect models
+ */
+declare function loadModelsFromDirectory(dirPath: string, options?: {
+    recursive?: boolean;
+}): Promise<string[]>;
+/**
+ * Load all models based on configuration
+ */
+declare function loadAllModels(config: SpeckeeperConfig, cwd?: string): Promise<{
+    registry: ModelRegistry;
+    loadedFiles: string[];
+    errors: Array<{
+        file: string;
+        error: unknown;
+    }>;
+}>;
+/**
+ * Get registry statistics
+ */
+declare function getRegistryStats(registry: ModelRegistry): Record<string, number>;
+/**
+ * Get all IDs in registry
+ */
+declare function getAllIds(registry: ModelRegistry): Set<string>;
+/**
+ * Identify model type from ID
+ */
+declare function findModelType(registry: ModelRegistry, id: string): keyof ModelRegistry | null;
+/**
+ * Get model by ID
+ */
+declare function getModelById(registry: ModelRegistry, id: string): {
+    type: keyof ModelRegistry;
+    model: unknown;
+} | null;
+
+export { type APIRefId, type ActorId, type BaseModelInstance, type BatchRefId, type BatchWriteResult, type BoundaryId, type CheckContext, type CheckError, CheckErrorSchema, type CheckResult, CheckResultSchema, type CheckWarning, CheckWarningSchema, type ComponentId, type ConcretizationSlot, ConcretizationSlotSchema, type CoverageChecker, type CoverageResult, type DTORequirementId, type DriftResult, type EntityId, type ErrorCaseId, type EventRequirementId, type ExportContext, type Exporter, type ExternalChecker, type FormId, ID_PATTERNS, type IaCRefId, type InferModelType, type JsonSchemaExporter, type LayerId, type Link, LinkSchema, type LintContext, type LintIssue, LintIssueSchema, type LintResult, type LintRule, type MarkdownExporter, type MermaidExporter, type MetaModelConfig, type MetaModelRegistry, Model, type ModelDefinition, type ModelDefinitionInput, type ModelLevel, type ModelRegistry, type ModelRegistrySchema, type OutputPaths, type Phase, PhaseSchema, type Priority, PrioritySchema, type ProcessFlowId, RELATION_CONSTRAINTS, RELATION_TYPES, type ReferenceDefinition, ReferenceDefinitionSchema, type Relation, type RelationId, RelationSchema, type RelationValidationError, RelationsFieldSchema, type RenderContext, type Renderer, type RequirementId, type ResolvedSpeckeeperConfig, type RuleId, type ScreenId, type Severity, type SpeckeeperConfig, type SpeckeeperConfigInput, type StateId, type TableRefId, type TermId, type TransitionId, type UIComponentId, type UseCaseId, type ValidationError, type ValidationResult, type WriteResult, batchWriteFiles, checkBatchDrift, checkExternalSsot, checkFileDrift, checkReferenceIntegrity, clearModelRegistry, computeHash, createAPIRefId, createActorId, createBatchRefId, createBoundaryId, createComponentId, createDTORequirementId, createEmptyRegistry, createEntityId, createErrorCaseId, createEventRequirementId, createFormId, createIaCRefId, createLayerId, createLintRule, createMarkdownExporter, createMermaidExporter, createProcessFlowId, createRelationId, createRequirementId, createRuleId, createScreenId, createStateId, createTableRefId, createTermId, createTransitionId, createUIComponentId, createUseCaseId, defineConfig, defineModel, detectCycles, ensureDir, exportAllModels, exportMarkdown, exportMermaid, findConfigFile, findDefinitionFiles, findFiles, findModelType, findTypeScriptFiles, generateDocsPath, generateSpecsPath, getAllIds, getAllInstances, getAllModelDefinitions, getAllModelInstances, getAllModels, getExpectedOutputDirs, getGlobalModelRegistry, getGlobalRegistry, getLevelIndex, getModel, getModelById, getModelDefinition, getModelInstance, getModelRegistryStats, getOutputPaths, getRegistryStats, inferModelIdFromSpecId, lintAllModels, lintModel, loadAllModels, loadConfig, loadModelsFromDirectory, loadSpeckeeperConfig, registerModel, registerModelDefinition, registerModelDefinitions, registerModelInstance, resetGlobalRegistry, resetModelInstances, resetModelRegistry, resolveReference, validateConfig, validateOutputPaths, validateRelationLevel, writeFile, writeJsonFile };