import {
  // Types
  type ApiVersion,
  type ResourceKind,
  type Metadata,
  type Condition,
  type SecretRef,
  type MetricCondition,
  type Duration,
  type Resource,
  type Pipeline,
  type AgentRole,
  type QualityGate,
  type AutonomyPolicy,
  type AdapterBinding,
  type AnyResource,
  // ... (all resource sub-types)

  // Constants
  API_VERSION,

  // Validation
  validate,
  validateResource,
  type ValidationResult,
  type ValidationError,

  // Provenance
  createProvenance,
  provenanceToAnnotations,
  provenanceFromAnnotations,
  validateProvenance,
  PROVENANCE_ANNOTATION_PREFIX,
  type ProvenanceRecord,
  type ReviewDecision,

  // Comparison
  compareMetric,
  exceedsSeverity,
} from '@ai-sdlc/reference';

const API_VERSION = 'ai-sdlc.io/v1alpha1';

type ResourceKind = 'Pipeline' | 'AgentRole' | 'QualityGate' | 'AutonomyPolicy' | 'AdapterBinding';

interface Resource<K extends ResourceKind, S, St = unknown> {
  apiVersion: ApiVersion;
  kind: K;
  metadata: Metadata;
  spec: S;
  status?: St;
}

interface Metadata {
  name: string;
  namespace?: string;
  labels?: Record<string, string>;
  annotations?: Record<string, string>;
}

interface Condition {
  type: string;
  status: 'True' | 'False' | 'Unknown';
  reason?: string;
  message?: string;
  lastTransitionTime?: string;
  lastEvaluated?: string;
}

type Duration = string;

type AnyResource = Pipeline | AgentRole | QualityGate | AutonomyPolicy | AdapterBinding;

function validate<T extends AnyResource = AnyResource>(
  kind: ResourceKind,
  data: unknown,
): ValidationResult<T>;

const result = validate('Pipeline', pipelineDoc);
if (result.valid) {
  console.log(result.data); // typed as Pipeline
} else {
  for (const err of result.errors!) {
    console.error(`${err.path}: ${err.message}`);
  }
}

function validateResource(data: unknown): ValidationResult;

import { parse } from 'yaml';
import { readFileSync } from 'fs';
import { validateResource } from '@ai-sdlc/reference';

const doc = parse(readFileSync('pipeline.yaml', 'utf-8'));
const result = validateResource(doc);
// Automatically detects kind from doc.kind

function createProvenance(
  partial: Omit<ProvenanceRecord, 'timestamp' | 'reviewDecision'> & {
    timestamp?: string;
    reviewDecision?: ReviewDecision;
  },
): ProvenanceRecord;

const prov = createProvenance({
  model: 'claude-sonnet-4-5-20250929',
  tool: 'ai-sdlc-cli',
  promptHash: 'sha256:abc123...',
});
// prov.timestamp is set to now
// prov.reviewDecision defaults to 'pending'

function provenanceToAnnotations(provenance: ProvenanceRecord): Record<string, string>;

function provenanceFromAnnotations(
  annotations: Record<string, string>,
): ProvenanceRecord | undefined;

function validateProvenance(provenance: Partial<ProvenanceRecord>): {
  valid: boolean;
  missing: string[];
};

function compareMetric(actual: number, operator: string, threshold: number): boolean;

function exceedsSeverity(
  actual: 'low' | 'medium' | 'high' | 'critical',
  max: 'low' | 'medium' | 'high' | 'critical',
): boolean;

import { readFileSync } from 'fs';
import { parse } from 'yaml';
import { validateResource } from '@ai-sdlc/reference';

const doc = parse(readFileSync('my-pipeline.yaml', 'utf-8'));
const result = validateResource(doc);

if (!result.valid) {
  for (const err of result.errors!) {
    console.error(`${err.path}: ${err.message} [${err.keyword}]`);
  }
  process.exit(1);
}

console.log(`Valid ${result.data!.kind}: ${result.data!.metadata.name}`);

import { createProvenance, provenanceToAnnotations } from '@ai-sdlc/reference';

const prov = createProvenance({
  model: 'claude-sonnet-4-5-20250929',
  tool: 'ai-sdlc-cli',
  promptHash: 'sha256:abc123def456',
  humanReviewer: 'alice@example.com',
  reviewDecision: 'approved',
});

// Merge into resource annotations
const resource = {
  apiVersion: 'ai-sdlc.io/v1alpha1' as const,
  kind: 'Pipeline' as const,
  metadata: {
    name: 'my-pipeline',
    annotations: {
      ...provenanceToAnnotations(prov),
    },
  },
  spec: { triggers: [], providers: {}, stages: [] },
};