@nice2dev/ui-tools 1.0.10

package/dist/testing-qa.d.ts

@@ -0,0 +1,1013 @@
+/**
+ * @file testing-qa.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-24 — Testing & QA
+ *
+ * Types for test management, visual testing, performance testing,
+ * and API contract testing.
+ */
+/** Test status */
+export type TestStatus = 'not_run' | 'passed' | 'failed' | 'blocked' | 'skipped' | 'in_progress';
+/** Test priority */
+export type TestPriority = 'critical' | 'high' | 'medium' | 'low';
+/** Test type */
+export type TestType = 'functional' | 'regression' | 'smoke' | 'integration' | 'e2e' | 'performance' | 'security' | 'exploratory' | 'acceptance';
+/** Test manager config */
+export interface TestManagerConfig {
+    project: TestProject;
+    features?: TestFeatures;
+    integrations?: TestIntegrations;
+    reporting?: TestReporting;
+}
+/** Test project */
+export interface TestProject {
+    id: string;
+    name: string;
+    description?: string;
+    prefix?: string;
+    defaultPriority?: TestPriority;
+    statuses?: CustomTestStatus[];
+    customFields?: CustomField[];
+}
+/** Custom test status */
+export interface CustomTestStatus {
+    id: string;
+    name: string;
+    color: string;
+    isFinal?: boolean;
+    isDefault?: boolean;
+}
+/** Custom field */
+export interface CustomField {
+    id: string;
+    name: string;
+    type: CustomFieldType;
+    required?: boolean;
+    options?: string[];
+    default?: unknown;
+}
+/** Custom field type */
+export type CustomFieldType = 'text' | 'number' | 'date' | 'select' | 'multiselect' | 'checkbox' | 'url' | 'user';
+/** Test features */
+export interface TestFeatures {
+    testCases?: boolean;
+    testSuites?: boolean;
+    testPlans?: boolean;
+    testRuns?: boolean;
+    defectTracking?: boolean;
+    requirementsCoverage?: boolean;
+    exploratoryTesting?: boolean;
+    importExport?: boolean;
+}
+/** Test integrations */
+export interface TestIntegrations {
+    jira?: JiraIntegration;
+    github?: GitHubIntegration;
+    azure?: AzureDevOpsIntegration;
+    selenium?: SeleniumIntegration;
+    cypress?: CypressIntegration;
+    playwright?: PlaywrightIntegration;
+}
+/** Jira integration */
+export interface JiraIntegration {
+    enabled: boolean;
+    url?: string;
+    projectKey?: string;
+    issueTypes?: string[];
+    syncDefects?: boolean;
+    syncRequirements?: boolean;
+}
+/** GitHub integration */
+export interface GitHubIntegration {
+    enabled: boolean;
+    repository?: string;
+    syncIssues?: boolean;
+    syncPRs?: boolean;
+}
+/** Azure DevOps integration */
+export interface AzureDevOpsIntegration {
+    enabled: boolean;
+    organization?: string;
+    project?: string;
+    syncWorkItems?: boolean;
+}
+/** Selenium integration */
+export interface SeleniumIntegration {
+    enabled: boolean;
+    gridUrl?: string;
+    capabilities?: Record<string, unknown>;
+}
+/** Cypress integration */
+export interface CypressIntegration {
+    enabled: boolean;
+    dashboardKey?: string;
+    recordKey?: string;
+}
+/** Playwright integration */
+export interface PlaywrightIntegration {
+    enabled: boolean;
+    reportServer?: string;
+}
+/** Test reporting */
+export interface TestReporting {
+    enabled?: boolean;
+    formats?: ReportFormat[];
+    schedule?: ReportSchedule;
+    recipients?: string[];
+}
+/** Report format */
+export type ReportFormat = 'html' | 'pdf' | 'excel' | 'json' | 'junit';
+/** Report schedule */
+export interface ReportSchedule {
+    type: 'daily' | 'weekly' | 'after_run' | 'manual';
+    dayOfWeek?: number;
+    time?: string;
+}
+/** Test case */
+export interface TestCase {
+    id: string;
+    key: string;
+    title: string;
+    description?: string;
+    preconditions?: string;
+    steps: TestStep[];
+    expectedResult?: string;
+    priority: TestPriority;
+    type: TestType;
+    status: TestCaseStatus;
+    automationStatus?: AutomationStatus;
+    labels?: string[];
+    component?: string;
+    folder?: string;
+    author?: string;
+    assignee?: string;
+    estimate?: number;
+    customFields?: Record<string, unknown>;
+    attachments?: TestAttachment[];
+    links?: TestLink[];
+    createdAt: Date;
+    updatedAt: Date;
+    version?: number;
+}
+/** Test case status */
+export type TestCaseStatus = 'draft' | 'approved' | 'deprecated' | 'archived';
+/** Automation status */
+export type AutomationStatus = 'not_automated' | 'automated' | 'needs_update' | 'cannot_automate';
+/** Test step */
+export interface TestStep {
+    id: string;
+    order: number;
+    action: string;
+    expectedResult?: string;
+    data?: string;
+    attachments?: TestAttachment[];
+}
+/** Test attachment */
+export interface TestAttachment {
+    id: string;
+    name: string;
+    type: string;
+    size: number;
+    url: string;
+    uploadedAt: Date;
+}
+/** Test link */
+export interface TestLink {
+    id: string;
+    type: TestLinkType;
+    targetId: string;
+    targetKey?: string;
+    targetTitle?: string;
+    url?: string;
+}
+/** Test link type */
+export type TestLinkType = 'requirement' | 'defect' | 'test_case' | 'story' | 'epic' | 'external';
+/** Test suite */
+export interface TestSuite {
+    id: string;
+    name: string;
+    description?: string;
+    parentId?: string;
+    testCases: string[];
+    order?: number;
+    metadata?: SuiteMetadata;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** Suite metadata */
+export interface SuiteMetadata {
+    owner?: string;
+    tags?: string[];
+    environment?: string;
+    browser?: string;
+}
+/** Test suite tree */
+export interface TestSuiteTree {
+    id: string;
+    name: string;
+    testCaseCount: number;
+    children: TestSuiteTree[];
+}
+/** Test plan */
+export interface TestPlan {
+    id: string;
+    name: string;
+    description?: string;
+    objective?: string;
+    scope?: TestScope;
+    schedule?: TestPlanSchedule;
+    environment?: TestEnvironment;
+    entries: TestPlanEntry[];
+    status: TestPlanStatus;
+    milestone?: string;
+    release?: string;
+    owner?: string;
+    team?: string[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** Test scope */
+export interface TestScope {
+    included?: string[];
+    excluded?: string[];
+    riskyAreas?: string[];
+}
+/** Test plan schedule */
+export interface TestPlanSchedule {
+    startDate?: Date;
+    endDate?: Date;
+    estimatedHours?: number;
+}
+/** Test environment */
+export interface TestEnvironment {
+    name: string;
+    url?: string;
+    database?: string;
+    config?: Record<string, string>;
+}
+/** Test plan entry */
+export interface TestPlanEntry {
+    id: string;
+    type: 'suite' | 'case';
+    suiteId?: string;
+    caseId?: string;
+    assignee?: string;
+    configurations?: TestConfiguration[];
+}
+/** Test configuration */
+export interface TestConfiguration {
+    id: string;
+    name: string;
+    browser?: string;
+    os?: string;
+    device?: string;
+    locale?: string;
+}
+/** Test plan status */
+export type TestPlanStatus = 'draft' | 'active' | 'completed' | 'archived';
+/** Test run */
+export interface TestRun {
+    id: string;
+    name: string;
+    planId?: string;
+    description?: string;
+    environment: TestEnvironment;
+    configuration?: TestConfiguration;
+    status: TestRunStatus;
+    executor?: string;
+    startedAt?: Date;
+    completedAt?: Date;
+    results: TestResult[];
+    summary?: TestRunSummary;
+    defectsFound?: string[];
+    notes?: string;
+}
+/** Test run status */
+export type TestRunStatus = 'not_started' | 'in_progress' | 'completed' | 'aborted';
+/** Test result */
+export interface TestResult {
+    id: string;
+    testCaseId: string;
+    testCaseKey: string;
+    status: TestStatus;
+    stepResults?: StepResult[];
+    duration?: number;
+    executedAt?: Date;
+    executedBy?: string;
+    defects?: string[];
+    comment?: string;
+    attachments?: TestAttachment[];
+    automationResult?: AutomationResult;
+}
+/** Step result */
+export interface StepResult {
+    stepId: string;
+    status: TestStatus;
+    actualResult?: string;
+    comment?: string;
+    attachments?: TestAttachment[];
+}
+/** Automation result */
+export interface AutomationResult {
+    tool: string;
+    runId?: string;
+    logs?: string;
+    screenshots?: string[];
+    video?: string;
+    trace?: string;
+}
+/** Test run summary */
+export interface TestRunSummary {
+    total: number;
+    passed: number;
+    failed: number;
+    blocked: number;
+    skipped: number;
+    notRun: number;
+    passRate: number;
+    duration?: number;
+}
+/** Test defect */
+export interface TestDefect {
+    id: string;
+    key: string;
+    title: string;
+    description?: string;
+    status: DefectStatus;
+    priority: TestPriority;
+    severity: DefectSeverity;
+    stepsToReproduce?: string;
+    environment?: string;
+    assignee?: string;
+    reporter?: string;
+    linkedTests: string[];
+    attachments?: TestAttachment[];
+    externalId?: string;
+    externalUrl?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    resolvedAt?: Date;
+}
+/** Defect status */
+export type DefectStatus = 'new' | 'open' | 'in_progress' | 'fixed' | 'verified' | 'closed' | 'rejected' | 'deferred';
+/** Defect severity */
+export type DefectSeverity = 'blocker' | 'critical' | 'major' | 'minor' | 'trivial';
+/** Coverage matrix config */
+export interface CoverageMatrixConfig {
+    requirements: RequirementSource;
+    testCases: TestCaseSource;
+    display?: MatrixDisplay;
+}
+/** Requirement source */
+export interface RequirementSource {
+    type: 'jira' | 'azure' | 'csv' | 'manual';
+    filter?: string;
+    fields?: string[];
+}
+/** Test case source */
+export interface TestCaseSource {
+    suites?: string[];
+    labels?: string[];
+    types?: TestType[];
+}
+/** Matrix display */
+export interface MatrixDisplay {
+    groupBy?: 'requirement' | 'feature' | 'epic';
+    showStatus?: boolean;
+    showLastRun?: boolean;
+}
+/** Coverage report */
+export interface CoverageReport {
+    summary: CoverageSummary;
+    requirements: RequirementCoverage[];
+    gaps: CoverageGap[];
+    generatedAt: Date;
+}
+/** Coverage summary */
+export interface CoverageSummary {
+    totalRequirements: number;
+    coveredRequirements: number;
+    coveragePercentage: number;
+    passedRequirements: number;
+    failedRequirements: number;
+}
+/** Requirement coverage */
+export interface RequirementCoverage {
+    requirementId: string;
+    requirementKey: string;
+    requirementTitle: string;
+    testCases: TestCaseCoverage[];
+    coverageStatus: CoverageStatus;
+}
+/** Test case coverage */
+export interface TestCaseCoverage {
+    testCaseId: string;
+    testCaseKey: string;
+    lastResult?: TestStatus;
+    lastRunDate?: Date;
+}
+/** Coverage status */
+export type CoverageStatus = 'covered_pass' | 'covered_fail' | 'covered_not_run' | 'not_covered';
+/** Coverage gap */
+export interface CoverageGap {
+    requirementId: string;
+    requirementKey: string;
+    reason: 'no_tests' | 'all_failed' | 'not_run';
+    recommendation?: string;
+}
+/** Exploratory session */
+export interface ExploratorySession {
+    id: string;
+    charter: SessionCharter;
+    tester: string;
+    status: SessionStatus;
+    startedAt: Date;
+    endedAt?: Date;
+    duration?: number;
+    notes: SessionNote[];
+    findings: SessionFinding[];
+    metrics?: SessionMetrics;
+}
+/** Session charter */
+export interface SessionCharter {
+    title: string;
+    mission: string;
+    areas?: string[];
+    risks?: string[];
+    timeBox?: number;
+}
+/** Session status */
+export type SessionStatus = 'planned' | 'in_progress' | 'paused' | 'completed' | 'cancelled';
+/** Session note */
+export interface SessionNote {
+    id: string;
+    timestamp: Date;
+    type: NoteType;
+    content: string;
+    screenshot?: string;
+}
+/** Note type */
+export type NoteType = 'observation' | 'question' | 'idea' | 'issue' | 'positive';
+/** Session finding */
+export interface SessionFinding {
+    id: string;
+    type: FindingType;
+    title: string;
+    description: string;
+    severity?: DefectSeverity;
+    screenshots?: string[];
+    linkedDefect?: string;
+}
+/** Finding type */
+export type FindingType = 'bug' | 'improvement' | 'question' | 'risk';
+/** Session metrics */
+export interface SessionMetrics {
+    areasExplored: number;
+    bugsFound: number;
+    questionsRaised: number;
+    testIdeasGenerated: number;
+    coverage?: number;
+}
+/** Visual test config */
+export interface VisualTestConfig {
+    project: VisualProject;
+    capture?: CaptureConfig;
+    comparison?: ComparisonConfig;
+    approval?: ApprovalConfig;
+    ci?: VisualCIConfig;
+}
+/** Visual project */
+export interface VisualProject {
+    id: string;
+    name: string;
+    baselineUrl?: string;
+    branches?: BranchConfig;
+}
+/** Branch config */
+export interface BranchConfig {
+    main: string;
+    baselineBranch?: string;
+    featureBranches?: boolean;
+}
+/** Capture config */
+export interface CaptureConfig {
+    fullPage?: boolean;
+    selector?: string;
+    hideSelectors?: string[];
+    removeSelectors?: string[];
+    waitForSelector?: string;
+    waitForTimeout?: number;
+    animations?: 'disabled' | 'allow';
+    caret?: 'hide' | 'initial';
+}
+/** Comparison config */
+export interface ComparisonConfig {
+    algorithm: ComparisonAlgorithm;
+    threshold?: number;
+    ignoreRegions?: IgnoreRegion[];
+    ignoreColors?: boolean;
+    ignoreAntialiasing?: boolean;
+    sensitivity?: VisualSensitivity;
+}
+/** Comparison algorithm */
+export type ComparisonAlgorithm = 'pixel' | 'perceptual' | 'structural';
+/** Ignore region */
+export interface IgnoreRegion {
+    type: 'selector' | 'coordinates';
+    selector?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+}
+/** Visual sensitivity */
+export type VisualSensitivity = 'strict' | 'balanced' | 'relaxed';
+/** Approval config */
+export interface ApprovalConfig {
+    autoApprove?: boolean;
+    reviewers?: string[];
+    requireApproval?: boolean;
+}
+/** Visual CI config */
+export interface VisualCIConfig {
+    failOnDiff?: boolean;
+    failThreshold?: number;
+    reportFormat?: string;
+    artifactsPath?: string;
+}
+/** Visual snapshot */
+export interface VisualSnapshot {
+    id: string;
+    name: string;
+    url: string;
+    viewport: Viewport;
+    browser?: string;
+    os?: string;
+    baseline?: SnapshotImage;
+    current?: SnapshotImage;
+    diff?: SnapshotDiff;
+    status: VisualStatus;
+    createdAt: Date;
+    reviewedAt?: Date;
+    reviewedBy?: string;
+}
+/** Viewport */
+export interface Viewport {
+    width: number;
+    height: number;
+    deviceScaleFactor?: number;
+}
+/** Snapshot image */
+export interface SnapshotImage {
+    url: string;
+    width: number;
+    height: number;
+    hash?: string;
+}
+/** Snapshot diff */
+export interface SnapshotDiff {
+    url: string;
+    percentage: number;
+    pixelCount: number;
+    regions?: DiffRegion[];
+}
+/** Diff region */
+export interface DiffRegion {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Visual status */
+export type VisualStatus = 'new' | 'matching' | 'different' | 'approved' | 'rejected';
+/** Visual test run */
+export interface VisualTestRun {
+    id: string;
+    name: string;
+    branch?: string;
+    commit?: string;
+    buildId?: string;
+    status: VisualRunStatus;
+    snapshots: VisualSnapshot[];
+    summary: VisualSummary;
+    startedAt: Date;
+    completedAt?: Date;
+}
+/** Visual run status */
+export type VisualRunStatus = 'running' | 'completed' | 'failed' | 'pending_approval';
+/** Visual summary */
+export interface VisualSummary {
+    total: number;
+    new: number;
+    matching: number;
+    different: number;
+    approved: number;
+    rejected: number;
+}
+/** Load test config */
+export interface LoadTestConfig {
+    name: string;
+    description?: string;
+    target: LoadTarget;
+    scenarios: LoadScenario[];
+    loadProfile: LoadProfile;
+    thresholds?: LoadThreshold[];
+    options?: LoadOptions;
+}
+/** Load target */
+export interface LoadTarget {
+    baseUrl: string;
+    headers?: Record<string, string>;
+    auth?: LoadAuth;
+}
+/** Load auth */
+export interface LoadAuth {
+    type: 'basic' | 'bearer' | 'oauth2' | 'custom';
+    username?: string;
+    password?: string;
+    token?: string;
+    oauth?: OAuthConfig;
+}
+/** OAuth config */
+export interface OAuthConfig {
+    tokenUrl: string;
+    clientId: string;
+    clientSecret?: string;
+    scope?: string;
+}
+/** Load scenario */
+export interface LoadScenario {
+    id: string;
+    name: string;
+    weight?: number;
+    steps: LoadStep[];
+    think?: ThinkTime;
+}
+/** Load step */
+export interface LoadStep {
+    id: string;
+    type: LoadStepType;
+    name: string;
+    request?: LoadRequest;
+    wait?: number;
+    condition?: LoadCondition;
+    loop?: LoadLoop;
+}
+/** Load step type */
+export type LoadStepType = 'http' | 'websocket' | 'grpc' | 'wait' | 'group' | 'transaction';
+/** Load request */
+export interface LoadRequest {
+    method: HttpMethod;
+    url: string;
+    headers?: Record<string, string>;
+    body?: string | Record<string, unknown>;
+    contentType?: string;
+    timeout?: number;
+    followRedirects?: boolean;
+    captures?: LoadCapture[];
+    checks?: LoadCheck[];
+}
+/** HTTP method */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+/** Load capture */
+export interface LoadCapture {
+    name: string;
+    source: 'body' | 'header' | 'json' | 'regex';
+    path?: string;
+    pattern?: string;
+}
+/** Load check */
+export interface LoadCheck {
+    type: 'status' | 'body' | 'header' | 'json' | 'duration';
+    condition: CheckCondition;
+    value: string | number;
+    path?: string;
+}
+/** Check condition */
+export type CheckCondition = 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'lt' | 'lte' | 'gt' | 'gte' | 'regex';
+/** Load condition */
+export interface LoadCondition {
+    variable: string;
+    condition: CheckCondition;
+    value: string | number;
+}
+/** Load loop */
+export interface LoadLoop {
+    count?: number;
+    duration?: number;
+    dataSource?: string;
+}
+/** Think time */
+export interface ThinkTime {
+    type: 'fixed' | 'random' | 'normal';
+    min?: number;
+    max?: number;
+    average?: number;
+    stddev?: number;
+}
+/** Load profile */
+export interface LoadProfile {
+    type: LoadProfileType;
+    stages: LoadStage[];
+}
+/** Load profile type */
+export type LoadProfileType = 'constant' | 'ramp' | 'spike' | 'stress' | 'soak';
+/** Load stage */
+export interface LoadStage {
+    duration: number;
+    target: number;
+    rampUp?: number;
+}
+/** Load threshold */
+export interface LoadThreshold {
+    metric: LoadMetric;
+    condition: ThresholdCondition;
+    abortOnFail?: boolean;
+}
+/** Load metric */
+export type LoadMetric = 'response_time_avg' | 'response_time_p95' | 'response_time_p99' | 'error_rate' | 'throughput' | 'active_users' | 'custom';
+/** Threshold condition */
+export interface ThresholdCondition {
+    operator: 'lt' | 'lte' | 'gt' | 'gte' | 'eq';
+    value: number;
+    aggregation?: 'avg' | 'min' | 'max' | 'p95' | 'p99';
+}
+/** Load options */
+export interface LoadOptions {
+    maxVUs?: number;
+    iterations?: number;
+    duration?: number;
+    setupTimeout?: number;
+    teardownTimeout?: number;
+    gracefulStop?: number;
+    noConnectionReuse?: boolean;
+}
+/** Load test result */
+export interface LoadTestResult {
+    id: string;
+    testId: string;
+    name: string;
+    status: LoadTestStatus;
+    startedAt: Date;
+    completedAt?: Date;
+    duration?: number;
+    summary: LoadResultSummary;
+    metrics: LoadMetrics;
+    timeline: LoadTimelinePoint[];
+    errors: LoadError[];
+    thresholdResults?: ThresholdResult[];
+}
+/** Load test status */
+export type LoadTestStatus = 'running' | 'completed' | 'failed' | 'aborted';
+/** Load result summary */
+export interface LoadResultSummary {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    avgResponseTime: number;
+    p95ResponseTime: number;
+    p99ResponseTime: number;
+    minResponseTime: number;
+    maxResponseTime: number;
+    throughput: number;
+    errorRate: number;
+    dataReceived: number;
+    dataSent: number;
+}
+/** Load metrics */
+export interface LoadMetrics {
+    responseTime: MetricSeries;
+    throughput: MetricSeries;
+    errorRate: MetricSeries;
+    activeUsers: MetricSeries;
+    custom?: Record<string, MetricSeries>;
+}
+/** Metric series */
+export interface MetricSeries {
+    timestamps: number[];
+    values: number[];
+    percentiles?: PercentileData;
+}
+/** Percentile data */
+export interface PercentileData {
+    p50: number;
+    p75: number;
+    p90: number;
+    p95: number;
+    p99: number;
+}
+/** Load timeline point */
+export interface LoadTimelinePoint {
+    timestamp: number;
+    activeUsers: number;
+    requestsPerSecond: number;
+    avgResponseTime: number;
+    errorCount: number;
+}
+/** Load error */
+export interface LoadError {
+    timestamp: Date;
+    type: string;
+    message: string;
+    url?: string;
+    count: number;
+}
+/** Threshold result */
+export interface ThresholdResult {
+    metric: LoadMetric;
+    passed: boolean;
+    value: number;
+    threshold: number;
+}
+/** Contract test config */
+export interface ContractTestConfig {
+    provider: ContractProvider;
+    consumer?: ContractConsumer;
+    broker?: ContractBroker;
+    verification?: VerificationConfig;
+}
+/** Contract provider */
+export interface ContractProvider {
+    name: string;
+    version?: string;
+    branch?: string;
+    baseUrl?: string;
+    stateHandlers?: StateHandler[];
+}
+/** Contract consumer */
+export interface ContractConsumer {
+    name: string;
+    version?: string;
+    branch?: string;
+}
+/** Contract broker */
+export interface ContractBroker {
+    url: string;
+    token?: string;
+    username?: string;
+    password?: string;
+}
+/** Verification config */
+export interface VerificationConfig {
+    publishResults?: boolean;
+    providerVersion?: string;
+    providerTags?: string[];
+    consumerVersionSelectors?: VersionSelector[];
+    enablePending?: boolean;
+    includeWipPacts?: boolean;
+}
+/** Version selector */
+export interface VersionSelector {
+    tag?: string;
+    branch?: string;
+    consumer?: string;
+    latest?: boolean;
+    deployedOrReleased?: boolean;
+    deployed?: boolean;
+    released?: boolean;
+    environment?: string;
+}
+/** State handler */
+export interface StateHandler {
+    state: string;
+    handler: () => Promise<void>;
+    teardown?: () => Promise<void>;
+}
+/** Contract */
+export interface Contract {
+    id: string;
+    consumer: ContractParticipant;
+    provider: ContractParticipant;
+    interactions: ContractInteraction[];
+    metadata?: ContractMetadata;
+    createdAt: Date;
+    publishedAt?: Date;
+}
+/** Contract participant */
+export interface ContractParticipant {
+    name: string;
+    version?: string;
+}
+/** Contract interaction */
+export interface ContractInteraction {
+    id: string;
+    description: string;
+    providerStates?: ProviderState[];
+    request: ContractRequest;
+    response: ContractResponse;
+}
+/** Provider state */
+export interface ProviderState {
+    name: string;
+    params?: Record<string, unknown>;
+}
+/** Contract request */
+export interface ContractRequest {
+    method: HttpMethod;
+    path: string;
+    query?: Record<string, string | string[]>;
+    headers?: Record<string, string>;
+    body?: unknown;
+    matchingRules?: MatchingRules;
+}
+/** Contract response */
+export interface ContractResponse {
+    status: number;
+    headers?: Record<string, string>;
+    body?: unknown;
+    matchingRules?: MatchingRules;
+}
+/** Matching rules */
+export interface MatchingRules {
+    body?: MatcherDefinition;
+    header?: MatcherDefinition;
+    path?: MatcherDefinition;
+    query?: MatcherDefinition;
+}
+/** Matcher definition */
+export interface MatcherDefinition {
+    [path: string]: MatcherRule;
+}
+/** Matcher rule */
+export interface MatcherRule {
+    match: MatcherType;
+    regex?: string;
+    min?: number;
+    max?: number;
+    value?: unknown;
+    format?: string;
+}
+/** Matcher type */
+export type MatcherType = 'type' | 'regex' | 'equality' | 'include' | 'integer' | 'decimal' | 'null' | 'date' | 'time' | 'datetime' | 'arrayContains';
+/** Contract metadata */
+export interface ContractMetadata {
+    pactSpecification?: PactVersion;
+    environment?: string;
+    tags?: string[];
+}
+/** Pact version */
+export interface PactVersion {
+    version: '2.0.0' | '3.0.0' | '4.0.0';
+}
+/** Verification result */
+export interface ContractVerificationResult {
+    id: string;
+    contractId: string;
+    provider: ContractParticipant;
+    consumer: ContractParticipant;
+    status: VerificationStatus;
+    interactions: InteractionResult[];
+    summary: VerificationSummary;
+    executedAt: Date;
+    publishedAt?: Date;
+}
+/** Verification status */
+export type VerificationStatus = 'passed' | 'failed' | 'pending';
+/** Interaction result */
+export interface InteractionResult {
+    interactionId: string;
+    description: string;
+    status: VerificationStatus;
+    mismatches?: ContractMismatch[];
+    duration?: number;
+}
+/** Contract mismatch */
+export interface ContractMismatch {
+    type: MismatchType;
+    path?: string;
+    expected?: unknown;
+    actual?: unknown;
+    message: string;
+}
+/** Mismatch type */
+export type MismatchType = 'StatusMismatch' | 'HeaderMismatch' | 'BodyMismatch' | 'QueryMismatch' | 'PathMismatch' | 'MethodMismatch';
+/** Verification summary */
+export interface VerificationSummary {
+    total: number;
+    passed: number;
+    failed: number;
+    pending: number;
+}
+/** Breaking change report */
+export interface BreakingChangeReport {
+    baseVersion: string;
+    targetVersion: string;
+    changes: ContractChange[];
+    breakingChanges: ContractChange[];
+    isCompatible: boolean;
+    generatedAt: Date;
+}
+/** Contract change */
+export interface ContractChange {
+    type: ChangeType;
+    severity: ChangeSeverity;
+    path: string;
+    description: string;
+    before?: unknown;
+    after?: unknown;
+}
+/** Change type */
+export type ChangeType = 'added' | 'removed' | 'modified' | 'renamed';
+/** Change severity */
+export type ChangeSeverity = 'breaking' | 'compatible' | 'unknown';
+//# sourceMappingURL=testing-qa.d.ts.map