@contractspec/lib.contracts 1.62.0 → 1.63.0

package/dist/workspace-config/contractsrc-schema.js

@@ -1,344 +0,0 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-// src/workspace-config/contractsrc-schema.ts
-import * as z from "zod";
-var SchemaFormatSchema = z.enum([
-  "contractspec",
-  "zod",
-  "json-schema",
-  "graphql"
-]);
-var OpenApiSourceConfigSchema = z.object({
-  name: z.string(),
-  url: z.string().url().optional(),
-  file: z.string().optional(),
-  syncMode: z.enum(["import", "sync", "validate"]).default("validate").optional(),
-  tags: z.array(z.string()).optional(),
-  exclude: z.array(z.string()).optional(),
-  include: z.array(z.string()).optional(),
-  prefix: z.string().optional(),
-  defaultStability: z.enum(["experimental", "beta", "stable", "deprecated"]).optional(),
-  defaultAuth: z.enum(["anonymous", "user", "admin"]).optional(),
-  defaultOwners: z.array(z.string()).optional(),
-  schemaFormat: SchemaFormatSchema.default("contractspec").optional()
-});
-var OpenApiExportConfigSchema = z.object({
-  outputPath: z.string().default("./openapi.json").optional(),
-  format: z.enum(["json", "yaml"]).default("json").optional(),
-  title: z.string().optional(),
-  version: z.string().optional(),
-  description: z.string().optional(),
-  servers: z.array(z.object({
-    url: z.string(),
-    description: z.string().optional()
-  })).optional()
-});
-var OpenApiConfigSchema = z.object({
-  sources: z.array(OpenApiSourceConfigSchema).optional(),
-  export: OpenApiExportConfigSchema.optional()
-});
-var GroupingStrategySchema = z.enum([
-  "by-tag",
-  "by-owner",
-  "by-domain",
-  "by-url-path-single",
-  "by-url-path-multi",
-  "by-feature",
-  "none"
-]);
-var GroupingRuleSchema = z.object({
-  strategy: GroupingStrategySchema,
-  urlPathLevel: z.number().optional(),
-  pattern: z.string().optional()
-});
-var FolderConventionsSchema = z.object({
-  models: z.string().default("models").optional(),
-  operations: z.string().default("operations/commands|queries").optional(),
-  events: z.string().default("events").optional(),
-  presentations: z.string().default("presentations").optional(),
-  forms: z.string().default("forms").optional(),
-  groupByFeature: z.boolean().default(true).optional(),
-  operationsGrouping: GroupingRuleSchema.optional(),
-  modelsGrouping: GroupingRuleSchema.optional(),
-  eventsGrouping: GroupingRuleSchema.optional()
-});
-var PrCommentConfigSchema = z.object({
-  enabled: z.boolean().default(true).optional(),
-  template: z.enum(["minimal", "detailed"]).default("detailed").optional(),
-  updateExisting: z.boolean().default(true).optional()
-});
-var CheckRunConfigSchema = z.object({
-  enabled: z.boolean().default(true).optional(),
-  name: z.string().default("ContractSpec Impact").optional(),
-  failOnBreaking: z.boolean().default(true).optional(),
-  failOnChanges: z.boolean().default(false).optional()
-});
-var ImpactConfigSchema = z.object({
-  baseline: z.string().default("default-branch").optional(),
-  include: z.array(z.string()).optional(),
-  exclude: z.array(z.string()).optional()
-});
-var CiConfigSchema = z.object({
-  checks: z.array(z.string()).default(["structure", "integrity", "deps"]).optional(),
-  skipChecks: z.array(z.string()).optional(),
-  failOnWarnings: z.boolean().default(false).optional(),
-  uploadSarif: z.boolean().default(true).optional(),
-  prComment: PrCommentConfigSchema.optional(),
-  checkRun: CheckRunConfigSchema.optional(),
-  impact: ImpactConfigSchema.optional()
-});
-var ExternalWorkspaceSchema = z.object({
-  alias: z.string(),
-  submodule: z.string(),
-  packages: z.array(z.string()).optional(),
-  autoResolve: z.boolean().default(true).optional()
-});
-var MetaRepoConfigSchema = z.object({
-  activeScope: z.string().optional(),
-  externalWorkspaces: z.array(ExternalWorkspaceSchema).optional(),
-  crossWorkspaceSearch: z.boolean().default(false).optional()
-});
-var FormatterTypeSchema = z.enum([
-  "prettier",
-  "eslint",
-  "biome",
-  "dprint",
-  "custom"
-]);
-var FormatterConfigSchema = z.object({
-  enabled: z.boolean().default(true).optional(),
-  type: FormatterTypeSchema.optional(),
-  command: z.string().optional(),
-  args: z.array(z.string()).optional(),
-  timeout: z.number().default(30000).optional()
-});
-var BumpStrategySchema = z.enum([
-  "impact",
-  "conventional"
-]);
-var ChangelogFormatSchema = z.enum([
-  "keep-a-changelog",
-  "conventional",
-  "custom"
-]);
-var ChangelogTierSchema = z.enum([
-  "spec",
-  "library",
-  "monorepo"
-]);
-var VersioningConfigSchema = z.object({
-  autoBump: z.boolean().default(false).optional(),
-  bumpStrategy: BumpStrategySchema.default("impact").optional(),
-  integrateWithChangesets: z.boolean().default(false).optional(),
-  changelogTiers: z.array(ChangelogTierSchema).default(["spec", "library", "monorepo"]).optional(),
-  format: ChangelogFormatSchema.default("keep-a-changelog").optional(),
-  commitChanges: z.boolean().default(false).optional(),
-  commitMessage: z.string().default("chore: bump spec versions").optional(),
-  createTags: z.boolean().default(false).optional(),
-  tagPrefix: z.string().default("v").optional(),
-  include: z.array(z.string()).optional(),
-  exclude: z.array(z.string()).optional()
-});
-var RuleSyncTargetSchema = z.enum([
-  "cursor",
-  "windsurf",
-  "cline",
-  "claude-code",
-  "copilot",
-  "subagent",
-  "skill"
-]);
-var RuleSyncConfigSchema = z.object({
-  enabled: z.boolean().default(false).optional(),
-  rulesDir: z.string().default("./.rules").optional(),
-  rules: z.array(z.string()).default(["**/*.rule.md"]).optional(),
-  targets: z.array(RuleSyncTargetSchema).default(["cursor", "windsurf"]).optional(),
-  autoSync: z.boolean().default(true).optional(),
-  ejectMode: z.boolean().default(false).optional()
-});
-var ClaudeAgentSDKConfigSchema = z.object({
-  enabled: z.boolean().default(false).optional(),
-  apiKey: z.string().optional(),
-  model: z.string().default("claude-sonnet-4-20250514").optional(),
-  computerUse: z.boolean().default(false).optional(),
-  extendedThinking: z.boolean().default(false).optional()
-});
-var OpenCodeSDKConfigSchema = z.object({
-  enabled: z.boolean().default(false).optional(),
-  serverUrl: z.string().optional(),
-  port: z.number().optional(),
-  agentType: z.enum(["build", "plan", "general", "explore"]).default("general").optional(),
-  model: z.string().optional()
-});
-var ExternalAgentsConfigSchema = z.object({
-  claudeAgent: ClaudeAgentSDKConfigSchema.optional(),
-  openCode: OpenCodeSDKConfigSchema.optional()
-});
-var RuleSeveritySchema = z.enum([
-  "off",
-  "warn",
-  "error"
-]);
-var SpecKindSchema = z.enum([
-  "operation",
-  "event",
-  "presentation",
-  "feature",
-  "workflow",
-  "data-view",
-  "migration",
-  "telemetry",
-  "experiment",
-  "app-config"
-]);
-var LintRulesSchema = z.object({
-  "require-acceptance": RuleSeveritySchema.optional(),
-  "require-examples": RuleSeveritySchema.optional(),
-  "require-stability": RuleSeveritySchema.optional(),
-  "require-owners-format": RuleSeveritySchema.optional(),
-  "event-past-tense": RuleSeveritySchema.optional(),
-  "no-todo": RuleSeveritySchema.optional(),
-  "workflow-transitions": RuleSeveritySchema.optional(),
-  "telemetry-privacy": RuleSeveritySchema.optional(),
-  "experiment-allocation": RuleSeveritySchema.optional(),
-  "app-config-appid": RuleSeveritySchema.optional(),
-  "app-config-capabilities": RuleSeveritySchema.optional(),
-  "data-view-fields": RuleSeveritySchema.optional()
-});
-var TestLinkingStrategySchema = z.enum([
-  "target-first",
-  "convention-only",
-  "both"
-]);
-var TestLinkingConfigSchema = z.object({
-  strategy: TestLinkingStrategySchema.default("both").optional(),
-  warnOnConvention: z.boolean().default(false).optional()
-});
-var TestingConfigSchema = z.object({
-  runner: z.enum(["internal", "jest", "vitest", "bun"]).default("internal").optional(),
-  testMatch: z.array(z.string()).default(["**/*.{test,spec}.{ts,js}"]).optional(),
-  autoGenerate: z.boolean().default(false).optional(),
-  integrity: z.object({
-    requireTestsFor: z.array(SpecKindSchema).optional(),
-    minCoverage: z.number().optional()
-  }).optional(),
-  testLinking: TestLinkingConfigSchema.optional()
-});
-var RulesConfigSchema = z.object({
-  defaults: LintRulesSchema.optional(),
-  overrides: z.record(SpecKindSchema, LintRulesSchema).optional()
-});
-var HooksConfigSchema = z.record(z.string(), z.array(z.string()));
-var ContractsrcSchema = z.object({
-  aiProvider: z.enum(["claude", "openai", "ollama", "custom"]).default("claude").optional(),
-  aiModel: z.string().optional(),
-  agentMode: z.enum([
-    "simple",
-    "cursor",
-    "claude-code",
-    "openai-codex",
-    "claude-agent-sdk",
-    "opencode",
-    "opencode-sdk"
-  ]).default("simple").optional(),
-  customEndpoint: z.url().nullable().optional(),
-  customApiKey: z.string().nullable().optional(),
-  outputDir: z.string().default("./src").optional(),
-  conventions: FolderConventionsSchema.optional(),
-  defaultOwners: z.array(z.string()).default([]).optional(),
-  defaultTags: z.array(z.string()).default([]).optional(),
-  packages: z.array(z.string()).optional(),
-  excludePackages: z.array(z.string()).optional(),
-  recursive: z.boolean().optional(),
-  openapi: OpenApiConfigSchema.optional(),
-  ci: CiConfigSchema.optional(),
-  metaRepo: MetaRepoConfigSchema.optional(),
-  rules: RulesConfigSchema.optional(),
-  testing: TestingConfigSchema.optional(),
-  hooks: HooksConfigSchema.optional(),
-  schemaFormat: SchemaFormatSchema.default("contractspec").optional(),
-  formatter: FormatterConfigSchema.optional(),
-  versioning: VersioningConfigSchema.optional(),
-  ruleSync: RuleSyncConfigSchema.optional(),
-  externalAgents: ExternalAgentsConfigSchema.optional()
-});
-var DEFAULT_CONTRACTSRC = {
-  aiProvider: "claude",
-  agentMode: "simple",
-  outputDir: "./src",
-  conventions: {
-    models: "models",
-    operations: "interactions/commands|queries",
-    events: "events",
-    presentations: "presentations",
-    forms: "forms",
-    groupByFeature: true
-  },
-  defaultOwners: [],
-  defaultTags: [],
-  schemaFormat: "contractspec"
-};
-export {
-  VersioningConfigSchema,
-  TestingConfigSchema,
-  TestLinkingStrategySchema,
-  TestLinkingConfigSchema,
-  SpecKindSchema,
-  SchemaFormatSchema,
-  RulesConfigSchema,
-  RuleSyncTargetSchema,
-  RuleSyncConfigSchema,
-  RuleSeveritySchema,
-  PrCommentConfigSchema,
-  OpenCodeSDKConfigSchema,
-  OpenApiSourceConfigSchema,
-  OpenApiExportConfigSchema,
-  OpenApiConfigSchema,
-  MetaRepoConfigSchema,
-  LintRulesSchema,
-  ImpactConfigSchema,
-  HooksConfigSchema,
-  GroupingStrategySchema,
-  GroupingRuleSchema,
-  FormatterTypeSchema,
-  FormatterConfigSchema,
-  FolderConventionsSchema,
-  ExternalWorkspaceSchema,
-  ExternalAgentsConfigSchema,
-  DEFAULT_CONTRACTSRC,
-  ContractsrcSchema,
-  ClaudeAgentSDKConfigSchema,
-  CiConfigSchema,
-  CheckRunConfigSchema,
-  ChangelogTierSchema,
-  ChangelogFormatSchema,
-  BumpStrategySchema
-};

package/dist/workspace-config/contractsrc-schema.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=contractsrc-schema.test.d.ts.map

package/dist/workspace-config/contractsrc-schema.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contractsrc-schema.test.d.ts","sourceRoot":"","sources":["../../src/workspace-config/contractsrc-schema.test.ts"],"names":[],"mappings":""}

package/dist/workspace-config/contractsrc-types.d.ts

@@ -1,343 +0,0 @@
-/**
- * Explicit type definitions for ContractSpec configuration.
- *
- * These interfaces mirror the Zod schemas in `contractsrc-schema.ts` but are
- * statically defined to reduce compiler inference cost and memory usage.
- */
-export type SchemaFormat = 'contractspec' | 'zod' | 'json-schema' | 'graphql';
-export type GroupingStrategy = 'by-tag' | 'by-owner' | 'by-domain' | 'by-url-path-single' | 'by-url-path-multi' | 'by-feature' | 'none';
-export type FormatterType = 'prettier' | 'eslint' | 'biome' | 'dprint' | 'custom';
-export type BumpStrategy = 'impact' | 'conventional';
-export type ChangelogFormat = 'keep-a-changelog' | 'conventional' | 'custom';
-export type ChangelogTier = 'spec' | 'library' | 'monorepo';
-export type RuleSyncTarget = 'cursor' | 'windsurf' | 'cline' | 'claude-code' | 'copilot' | 'subagent' | 'skill';
-export type RuleSeverity = 'off' | 'warn' | 'error';
-export type SpecKind = 'operation' | 'event' | 'presentation' | 'feature' | 'workflow' | 'data-view' | 'migration' | 'telemetry' | 'experiment' | 'app-config';
-export type TestLinkingStrategy = 'target-first' | 'convention-only' | 'both';
-export type AgentProvider = 'claude' | 'openai' | 'ollama' | 'custom';
-export type AgentMode = 'simple' | 'cursor' | 'claude-code' | 'openai-codex' | 'claude-agent-sdk' | 'opencode' | 'opencode-sdk';
-export interface OpenApiSourceConfig {
-    /** Friendly name for the source */
-    name: string;
-    /** Remote URL to fetch OpenAPI spec from */
-    url?: string;
-    /** Local file path to OpenAPI spec */
-    file?: string;
-    /** Sync mode: import (one-time), sync (update), validate (check only) */
-    syncMode?: 'import' | 'sync' | 'validate';
-    /** Only import operations with these tags */
-    tags?: string[];
-    /** Exclude operations with these operationIds */
-    exclude?: string[];
-    /** Include operations with these operationIds (overrides exclude) */
-    include?: string[];
-    /** Prefix for generated spec names */
-    prefix?: string;
-    /** Default stability for imported specs */
-    defaultStability?: 'experimental' | 'beta' | 'stable' | 'deprecated';
-    /** Default auth level for imported specs */
-    defaultAuth?: 'anonymous' | 'user' | 'admin';
-    /** Default owners for imported specs */
-    defaultOwners?: string[];
-    /** Output schema format for generated models */
-    schemaFormat?: SchemaFormat;
-}
-export interface OpenApiExportConfig {
-    /** Output path for exported OpenAPI document */
-    outputPath?: string;
-    /** Output format */
-    format?: 'json' | 'yaml';
-    /** API title for export */
-    title?: string;
-    /** API version for export */
-    version?: string;
-    /** API description for export */
-    description?: string;
-    /** Server URLs to include in export */
-    servers?: {
-        url: string;
-        description?: string;
-    }[];
-}
-export interface OpenApiConfig {
-    /** External OpenAPI sources to import/sync from */
-    sources?: OpenApiSourceConfig[];
-    /** Export configuration */
-    export?: OpenApiExportConfig;
-}
-export interface GroupingRule {
-    /** Grouping strategy to apply */
-    strategy: GroupingStrategy;
-    /** For url-path strategies, the level depth (default: 1) */
-    urlPathLevel?: number;
-    /** Custom key extraction pattern (regex or glob) */
-    pattern?: string;
-}
-export interface FolderConventions {
-    models?: string;
-    operations?: string;
-    events?: string;
-    presentations?: string;
-    forms?: string;
-    /** Enable feature/module folder grouping (default: true) */
-    groupByFeature?: boolean;
-    /** Grouping rule for operations */
-    operationsGrouping?: GroupingRule;
-    /** Grouping rule for models */
-    modelsGrouping?: GroupingRule;
-    /** Grouping rule for events */
-    eventsGrouping?: GroupingRule;
-}
-export interface PrCommentConfig {
-    /** Enable PR comments */
-    enabled?: boolean;
-    /** Comment template: 'minimal' | 'detailed' */
-    template?: 'minimal' | 'detailed';
-    /** Update existing comment instead of creating new */
-    updateExisting?: boolean;
-}
-export interface CheckRunConfig {
-    /** Enable GitHub check run creation */
-    enabled?: boolean;
-    /** Check run name */
-    name?: string;
-    /** Fail check on breaking changes */
-    failOnBreaking?: boolean;
-    /** Fail check on any contract changes */
-    failOnChanges?: boolean;
-}
-export interface ImpactConfig {
-    /** Baseline for comparison: 'default-branch' | 'base-ref' | 'tag:v*' */
-    baseline?: string;
-    /** Paths to include in impact detection (glob patterns) */
-    include?: string[];
-    /** Paths to exclude from impact detection (glob patterns) */
-    exclude?: string[];
-}
-export interface CiConfig {
-    /** Default checks to run */
-    checks?: string[];
-    /** Checks to skip */
-    skipChecks?: string[];
-    /** Fail CI on warnings */
-    failOnWarnings?: boolean;
-    /** Upload SARIF to GitHub Code Scanning */
-    uploadSarif?: boolean;
-    /** PR comment configuration */
-    prComment?: PrCommentConfig;
-    /** GitHub check run configuration */
-    checkRun?: CheckRunConfig;
-    /** Impact detection configuration */
-    impact?: ImpactConfig;
-}
-export interface ExternalWorkspace {
-    /** Alias for referencing this workspace (e.g., 'core', 'internal') */
-    alias: string;
-    /** Submodule name or relative path from meta-repo root */
-    submodule: string;
-    /** Package patterns to include from this workspace */
-    packages?: string[];
-    /** Whether to auto-resolve internal dependencies */
-    autoResolve?: boolean;
-}
-export interface MetaRepoConfig {
-    /** Active submodule scope (defaults to auto-detected) */
-    activeScope?: string;
-    /** External workspace references for cross-workspace dependencies */
-    externalWorkspaces?: ExternalWorkspace[];
-    /** Whether to search for specs across all submodules */
-    crossWorkspaceSearch?: boolean;
-}
-export interface FormatterConfig {
-    /** Enable/disable formatting (default: true if formatter detected) */
-    enabled?: boolean;
-    /** Formatter to use (auto-detected if not specified) */
-    type?: FormatterType;
-    /** Custom command for 'custom' type (e.g., "bunx prettier --write") */
-    command?: string;
-    /** Extra arguments to pass to formatter */
-    args?: string[];
-    /** Timeout in milliseconds (default: 30000) */
-    timeout?: number;
-}
-export interface VersioningConfig {
-    /** Enable automated version bumping in CI */
-    autoBump?: boolean;
-    /** Strategy for determining version bumps */
-    bumpStrategy?: BumpStrategy;
-    /** Integrate with Changesets (generate .changeset files) */
-    integrateWithChangesets?: boolean;
-    /** Changelog tiers to generate */
-    changelogTiers?: ChangelogTier[];
-    /** Changelog format template */
-    format?: ChangelogFormat;
-    /** Commit changes after version bump (CI mode) */
-    commitChanges?: boolean;
-    /** Commit message template (supports {version}, {specs}) */
-    commitMessage?: string;
-    /** Create git tags for versions */
-    createTags?: boolean;
-    /** Tag prefix (e.g., "v" -> v1.0.0, "spec-" -> spec-1.0.0) */
-    tagPrefix?: string;
-    /** Paths to include for version analysis (glob patterns) */
-    include?: string[];
-    /** Paths to exclude from version analysis (glob patterns) */
-    exclude?: string[];
-}
-export interface RuleSyncConfig {
-    /** Enable automated rule synchronization */
-    enabled?: boolean;
-    /** Root directory for source rule files */
-    rulesDir?: string;
-    /** Source rule files (glob patterns) */
-    rules?: string[];
-    /** Synchronization targets (tools to generate rules for) */
-    targets?: RuleSyncTarget[];
-    /** Automatically synchronize rules on workspace changes or builds */
-    autoSync?: boolean;
-    /** Whether to eject/copy source rules instead of generating from Unified Rules */
-    ejectMode?: boolean;
-}
-export interface ClaudeAgentSDKConfig {
-    /** Enable Claude Agent SDK provider */
-    enabled?: boolean;
-    /** API key (defaults to ANTHROPIC_API_KEY env var) */
-    apiKey?: string;
-    /** Model to use (defaults to claude-sonnet-4-20250514) */
-    model?: string;
-    /** Enable computer use capabilities */
-    computerUse?: boolean;
-    /** Enable extended thinking mode */
-    extendedThinking?: boolean;
-}
-export interface OpenCodeSDKConfig {
-    /** Enable OpenCode SDK provider */
-    enabled?: boolean;
-    /** Server URL (defaults to http://127.0.0.1:4096) */
-    serverUrl?: string;
-    /** Server port (alternative to full URL) */
-    port?: number;
-    /** Agent type to use */
-    agentType?: 'build' | 'plan' | 'general' | 'explore';
-    /** Model to use */
-    model?: string;
-}
-export interface ExternalAgentsConfig {
-    /** Claude Agent SDK configuration */
-    claudeAgent?: ClaudeAgentSDKConfig;
-    /** OpenCode SDK configuration */
-    openCode?: OpenCodeSDKConfig;
-}
-export interface LintRules {
-    /** Require acceptance scenarios for operations */
-    'require-acceptance'?: RuleSeverity;
-    /** Require examples for operations */
-    'require-examples'?: RuleSeverity;
-    /** Require stability field */
-    'require-stability'?: RuleSeverity;
-    /** Require owners to follow proper format (@team or Enum) */
-    'require-owners-format'?: RuleSeverity;
-    /** Require event names to use past tense */
-    'event-past-tense'?: RuleSeverity;
-    /** Warn on placeholder comments */
-    'no-todo'?: RuleSeverity;
-    /** Require workflow transitions */
-    'workflow-transitions'?: RuleSeverity;
-    /** Require privacy classification for telemetry */
-    'telemetry-privacy'?: RuleSeverity;
-    /** Require allocation config for experiments */
-    'experiment-allocation'?: RuleSeverity;
-    /** Require appId for app blueprints */
-    'app-config-appid'?: RuleSeverity;
-    /** Require capabilities for app blueprints */
-    'app-config-capabilities'?: RuleSeverity;
-    /** Require fields for data views */
-    'data-view-fields'?: RuleSeverity;
-}
-export interface TestLinkingConfig {
-    /** Strategy for linking tests to specs */
-    strategy?: TestLinkingStrategy;
-    /** Warn when tests only use naming convention (no TestSpec.target) */
-    warnOnConvention?: boolean;
-}
-export interface TestingConfig {
-    /** Test runner to use */
-    runner?: 'internal' | 'jest' | 'vitest' | 'bun';
-    /** Glob patterns for matching test files */
-    testMatch?: string[];
-    /** Enable automatic test generation */
-    autoGenerate?: boolean;
-    /** Integrity requirements for testing */
-    integrity?: {
-        /** Spec types that require test coverage */
-        requireTestsFor?: SpecKind[];
-        /** Minimum coverage percentage (if supported) */
-        minCoverage?: number;
-    };
-    /** Test linking configuration for contract-first test discovery */
-    testLinking?: TestLinkingConfig;
-}
-export interface RulesConfig {
-    /** Global default rule severities */
-    defaults?: LintRules;
-    /** Per-kind rule severity overrides */
-    overrides?: Partial<Record<SpecKind, LintRules>>;
-}
-export type HooksConfig = Record<string, string[]>;
-/**
- * Full ContractSpec configuration (.contractsrc.json).
- * All fields are optional as they come from user configuration.
- */
-export interface ContractsrcFileConfig {
-    aiProvider?: AgentProvider;
-    aiModel?: string;
-    agentMode?: AgentMode;
-    customEndpoint?: string | null;
-    customApiKey?: string | null;
-    outputDir?: string;
-    conventions?: FolderConventions;
-    defaultOwners?: string[];
-    defaultTags?: string[];
-    packages?: string[];
-    excludePackages?: string[];
-    recursive?: boolean;
-    openapi?: OpenApiConfig;
-    ci?: CiConfig;
-    metaRepo?: MetaRepoConfig;
-    rules?: RulesConfig;
-    testing?: TestingConfig;
-    hooks?: HooksConfig;
-    schemaFormat?: SchemaFormat;
-    formatter?: FormatterConfig;
-    versioning?: VersioningConfig;
-    ruleSync?: RuleSyncConfig;
-    externalAgents?: ExternalAgentsConfig;
-}
-/**
- * Resolved configuration with guaranteed defaults.
- * This is what the application uses at runtime.
- */
-export interface ResolvedContractsrcConfig extends ContractsrcFileConfig {
-    aiProvider: 'claude' | 'openai' | 'ollama' | 'custom';
-    agentMode: 'simple' | 'cursor' | 'claude-code' | 'openai-codex' | 'claude-agent-sdk' | 'opencode' | 'opencode-sdk';
-    outputDir: string;
-    conventions: {
-        models: string;
-        operations: string;
-        events: string;
-        presentations: string;
-        forms: string;
-        groupByFeature: boolean;
-        operationsGrouping?: GroupingRule;
-        modelsGrouping?: GroupingRule;
-        eventsGrouping?: GroupingRule;
-    };
-    defaultOwners: string[];
-    defaultTags: string[];
-    schemaFormat: SchemaFormat;
-}
-/**
- * @deprecated Use ContractsrcFileConfig for file inputs or ResolvedContractsrcConfig for app usage.
- */
-export type ContractsrcConfig = ContractsrcFileConfig;
-//# sourceMappingURL=contractsrc-types.d.ts.map