speckeeper 0.4.1 → 0.6.0

package/dist/dsl/index.d.ts

@@ -1,2 +1,253 @@
+import { z } from 'zod';
+import { d as LintRule, E as Exporter, c as ExternalChecker, a as CoverageChecker } from '../model-2gVdKS3_.js';
 
-export {  }
+/**
+ * Core DSL — Base spec schema
+ *
+ * Common schema fields shared by all models: id, name, description, relations.
+ * Models extend this with domain-specific fields via `.extend()`.
+ */
+
+declare const baseSpecSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    relations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["dependsOn", "uses", "includes", "implements", "refines", "verifies", "verifiedBy", "satisfies", "traces", "relatedTo"]>;
+        target: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "dependsOn" | "uses" | "includes" | "implements" | "refines" | "verifies" | "verifiedBy" | "satisfies" | "traces" | "relatedTo";
+        target: string;
+        description?: string | undefined;
+    }, {
+        type: "dependsOn" | "uses" | "includes" | "implements" | "refines" | "verifies" | "verifiedBy" | "satisfies" | "traces" | "relatedTo";
+        target: string;
+        description?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    id: string;
+    name: string;
+    relations?: {
+        type: "dependsOn" | "uses" | "includes" | "implements" | "refines" | "verifies" | "verifiedBy" | "satisfies" | "traces" | "relatedTo";
+        target: string;
+        description?: string | undefined;
+    }[] | undefined;
+}, {
+    description: string;
+    id: string;
+    name: string;
+    relations?: {
+        type: "dependsOn" | "uses" | "includes" | "implements" | "refines" | "verifies" | "verifiedBy" | "satisfies" | "traces" | "relatedTo";
+        target: string;
+        description?: string | undefined;
+    }[] | undefined;
+}>;
+type BaseSpec = z.infer<typeof baseSpecSchema>;
+
+/**
+ * Core DSL — Lint rule factories
+ *
+ * Factory functions that produce LintRule<T> objects for common patterns.
+ * Users compose these in their model's `lintRules` array.
+ */
+
+/**
+ * Require a string field to be non-empty.
+ */
+declare function requireField<T>(field: keyof T & string, severity?: 'error' | 'warning' | 'info'): LintRule<T>;
+/**
+ * Require an array field to have at least `min` elements.
+ */
+declare function arrayMinLength<T>(field: keyof T & string, min: number, severity?: 'error' | 'warning'): LintRule<T>;
+/**
+ * Require the `id` field to match a prefix-based format.
+ *
+ * Default pattern: `{prefix}-{NNN}` (e.g. `FR-001`).
+ * Override with `opts.pattern` for custom formats.
+ */
+declare function idFormat<T>(prefix: string, opts?: {
+    digits?: number;
+    pattern?: RegExp;
+}): LintRule<T>;
+/**
+ * Require child element IDs to follow parent ID (e.g. `FR-001-01`).
+ */
+declare function childIdFormat<T>(arrayField: keyof T & string, idField: string): LintRule<T>;
+
+/**
+ * Core DSL — Exporter factories
+ *
+ * Factory functions that produce Exporter<T> objects from declarative config.
+ */
+
+interface MetaField<T> {
+    key: keyof T & string;
+    label?: string;
+}
+interface SectionConfig<T> {
+    heading: string;
+    field?: keyof T & string;
+    render?: (spec: T) => string;
+    optional?: boolean;
+}
+interface ColumnConfig<T> {
+    key: keyof T & string;
+    label?: string;
+    render?: (value: unknown, spec: T) => string;
+}
+interface MarkdownExporterConfig<T> {
+    outputDir: string;
+    single?: {
+        title: (keyof T & string) | ((spec: T) => string);
+        meta?: Array<keyof T & string | MetaField<T>>;
+        sections?: SectionConfig<T>[];
+    };
+    index?: {
+        title?: string;
+        columns: Array<keyof T & string | ColumnConfig<T>>;
+    };
+}
+/**
+ * Create a markdown exporter from declarative configuration.
+ */
+declare function markdownExporter<T extends {
+    id: string;
+}>(config: MarkdownExporterConfig<T>): Exporter<T>;
+
+interface TestCheckerConfig<T> {
+    sourcePath?: (spec: T) => string;
+}
+/**
+ * Creates an ExternalChecker that verifies test file existence and spec ID references.
+ */
+declare function testChecker<T extends {
+    id: string;
+}>(config?: TestCheckerConfig<T>): ExternalChecker<T>;
+interface OpenAPICheckerConfig<T> {
+    sourcePath?: (spec: T) => string;
+    mapper: (spec: T) => {
+        path: string;
+        method?: string;
+        parameters?: Array<{
+            name: string;
+            in?: string;
+            type?: string;
+        }>;
+        responseProperties?: Array<{
+            name: string;
+            type?: string;
+        }>;
+    };
+}
+/**
+ * Creates an ExternalChecker that verifies consistency with an OpenAPI spec file.
+ *
+ * Three validation levels:
+ * 1. Existence: spec ID found in operationId, path segment, schema name, or x-spec-id
+ * 2. Structural: HTTP method matches the matched path
+ * 3. Type: parameter/response property names and types match
+ */
+declare function externalOpenAPIChecker<T extends {
+    id: string;
+}>(config?: OpenAPICheckerConfig<T>): ExternalChecker<T>;
+interface SqlSchemaCheckerConfig<T> {
+    sourcePath?: (spec: T) => string;
+    mapper: (spec: T) => {
+        tableName: string;
+        columns?: Array<{
+            name: string;
+            type?: string;
+        }>;
+    };
+    checkTypes?: boolean;
+}
+/**
+ * Creates an ExternalChecker that verifies consistency with a SQL schema (DDL).
+ *
+ * Three validation levels:
+ * 1. Existence: table name found in DDL
+ * 2. Structural: column names exist in the DDL table
+ * 3. Type: column types use containment-based comparison
+ */
+declare function externalSqlSchemaChecker<T extends {
+    id: string;
+}>(config?: SqlSchemaCheckerConfig<T>): ExternalChecker<T>;
+interface RelationCoverageConfig {
+    targetModel: string;
+    description: string;
+    relationType?: string;
+    targetPrefix?: string;
+}
+/**
+ * Creates a CoverageChecker that computes coverage of a target model via relations.
+ */
+declare function relationCoverage<T extends {
+    id: string;
+    relations?: Array<{
+        type: string;
+        target: string;
+    }>;
+}>(config: RelationCoverageConfig): CoverageChecker<T>;
+
+/**
+ * Type Compatibility — Containment-based type comparison
+ *
+ * The spec defines the minimum required type. The DDL/OpenAPI satisfies the
+ * requirement if its type can hold all values of the spec type (equal or wider).
+ */
+/**
+ * Returns true if ddlType can hold all values representable by specType.
+ *
+ * Containment rules:
+ * - Numeric: SMALLINT ⊂ INT ⊂ BIGINT, FLOAT ⊂ DOUBLE
+ * - String: CHAR(n) ⊂ VARCHAR(n) ⊂ TEXT (with length comparison)
+ * - DECIMAL: precision/scale must be >= spec
+ * - OpenAPI: integer ⊂ number
+ */
+declare function isTypeContainedBy(specType: string, ddlType: string): boolean;
+
+/**
+ * Core DSL — Edge-typed relation schemas
+ *
+ * Specialized relation schemas for `implements` and `verifiedBy` edges.
+ * These carry additional properties beyond the generic RelationSchema.
+ */
+
+declare const ImplementsRelationSchema: z.ZodObject<{
+    target: z.ZodString;
+    targetType: z.ZodString;
+    sourcePath: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    target: string;
+    targetType: string;
+    description?: string | undefined;
+    sourcePath?: string | undefined;
+}, {
+    target: string;
+    targetType: string;
+    description?: string | undefined;
+    sourcePath?: string | undefined;
+}>;
+type ImplementsRelation = z.infer<typeof ImplementsRelationSchema>;
+declare const VerifiedByRelationSchema: z.ZodObject<{
+    target: z.ZodString;
+    testPath: z.ZodOptional<z.ZodString>;
+    framework: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    target: string;
+    description?: string | undefined;
+    testPath?: string | undefined;
+    framework?: string | undefined;
+}, {
+    target: string;
+    description?: string | undefined;
+    testPath?: string | undefined;
+    framework?: string | undefined;
+}>;
+type VerifiedByRelation = z.infer<typeof VerifiedByRelationSchema>;
+
+export { type BaseSpec, type ImplementsRelation, ImplementsRelationSchema, type MarkdownExporterConfig, type VerifiedByRelation, VerifiedByRelationSchema, arrayMinLength, baseSpecSchema, childIdFormat, externalOpenAPIChecker, externalSqlSchemaChecker, idFormat, isTypeContainedBy, markdownExporter, relationCoverage, requireField, testChecker };