@wrongstack/requirement-intake 0.299.0

package/dist/lifecycle.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Requirements Intake — deterministic lifecycle.
+ *
+ * Status transitions are enforced by application logic. The LLM never
+ * changes status directly; it may only *suggest* information that moves a
+ * draft into `collecting_information` through the service.
+ */
+import { type IntakeStatus } from './constants.js';
+export declare const ALLOWED_TRANSITIONS: Readonly<Record<IntakeStatus, readonly IntakeStatus[]>>;
+/**
+ * Statuses whose content may still be edited. Submitted, cancelled, and
+ * archived records are locked (except for lifecycle operations).
+ */
+export declare const MUTABLE_STATUSES: readonly IntakeStatus[];
+export declare function canTransition(from: IntakeStatus, to: IntakeStatus): boolean;
+/** Throw `IntakeStateTransitionError` when the transition is not allowed. */
+export declare function assertTransition(from: IntakeStatus, to: IntakeStatus): void;
+export declare function isMutableStatus(status: IntakeStatus): boolean;
+export declare function isTerminalStatus(status: IntakeStatus): boolean;
+export declare function isKnownStatus(value: string): value is IntakeStatus;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/logger.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Requirements Intake — structured logging.
+ *
+ * The service logs identifiers and safe metadata only. Request content,
+ * answers, and attachments are NEVER passed to the logger, so no secret or
+ * sensitive requirement content can leak into logs.
+ */
+export interface IntakeLogFields {
+    [key: string]: string | number | boolean | undefined;
+}
+export interface IntakeLogger {
+    info(scope: string, message: string, fields?: IntakeLogFields): void;
+    warn(scope: string, message: string, fields?: IntakeLogFields): void;
+    error(scope: string, message: string, fields?: IntakeLogFields): void;
+}
+/** Default logger — silent. Hosts may wire their own structured logger. */
+export declare class NoopIntakeLogger implements IntakeLogger {
+    info(_scope: string, _message: string, _fields?: IntakeLogFields): void;
+    warn(_scope: string, _message: string, _fields?: IntakeLogFields): void;
+    error(_scope: string, _message: string, _fields?: IntakeLogFields): void;
+}
+/** In-memory logger for tests. */
+export declare class InMemoryIntakeLogger implements IntakeLogger {
+    readonly entries: Array<{
+        level: 'info' | 'warn' | 'error';
+        scope: string;
+        message: string;
+        fields?: IntakeLogFields | undefined;
+    }>;
+    info(scope: string, message: string, fields?: IntakeLogFields): void;
+    warn(scope: string, message: string, fields?: IntakeLogFields): void;
+    error(scope: string, message: string, fields?: IntakeLogFields): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/metrics.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Requirements Intake — metrics.
+ *
+ * Lightweight counters/timers for the observability surface. The service
+ * never records request content; only identifiers and outcome counts.
+ */
+export declare const INTAKE_COUNTERS: readonly ['intake.created', 'intake.submitted', 'intake.cancelled', 'intake.archived', 'intake.duplicate_create', 'intake.duplicate_submit', 'intake.validation_failure', 'intake.suggestions.requested', 'intake.suggestions.succeeded', 'intake.suggestions.failed', 'intake.unauthorized_attempt'];
+export type IntakeCounter = (typeof INTAKE_COUNTERS)[number];
+export declare const INTAKE_TIMERS: readonly ['intake.time_to_submit'];
+export type IntakeTimer = (typeof INTAKE_TIMERS)[number];
+export interface IntakeMetrics {
+    increment(counter: IntakeCounter, by?: number, labels?: Record<string, string>): void;
+    recordDuration(timer: IntakeTimer, milliseconds: number): void;
+}
+/** Default metrics — silent. */
+export declare class NoopIntakeMetrics implements IntakeMetrics {
+    increment(_counter: IntakeCounter, _by?: number, _labels?: Record<string, string>): void;
+    recordDuration(_timer: IntakeTimer, _milliseconds: number): void;
+}
+/** In-memory metrics for tests and lightweight hosts. */
+export declare class InMemoryIntakeMetrics implements IntakeMetrics {
+    readonly counters: Map<string, number>;
+    readonly durations: Map<string, number[]>;
+    increment(counter: IntakeCounter, by?: number, _labels?: Record<string, string>): void;
+    recordDuration(timer: IntakeTimer, milliseconds: number): void;
+    count(counter: IntakeCounter): number;
+    /** Sum of recorded durations for a timer, or undefined when none recorded. */
+    durationSum(timer: IntakeTimer): number | undefined;
+}
+//# sourceMappingURL=metrics.d.ts.map

package/dist/questions.d.ts

@@ -0,0 +1,13 @@
+import { type IntakeQuestionTemplate } from './constants.js';
+import type { CreateIntakeInput, IntakeQuestion, RequirementIntakeRecord } from './types.js';
+/**
+ * Build the initial question set for a new record. Skipped questions are
+ * retained with status `skipped` so the record documents why they were never
+ * asked; `pendingQuestions()` only surfaces unanswered ones.
+ */
+export declare function buildInitialQuestions(input: CreateIntakeInput, catalog?: readonly IntakeQuestionTemplate[]): IntakeQuestion[];
+/** Questions still awaiting an answer on a record. */
+export declare function pendingQuestions(record: RequirementIntakeRecord): IntakeQuestion[];
+/** Merge a question template into a record's question list (no duplicates). */
+export declare function upsertQuestion(record: RequirementIntakeRecord, template: IntakeQuestionTemplate): boolean;
+//# sourceMappingURL=questions.d.ts.map

package/dist/service.d.ts

@@ -0,0 +1,72 @@
+import { type IntakeQuestionTemplate, type IntakeStatus } from './constants.js';
+import type { IntakeAuthorizer } from './authorization.js';
+import { IntakeEventEmitter } from './events.js';
+import { type IntakeLogger } from './logger.js';
+import { type IntakeMetrics } from './metrics.js';
+import { type LlmSuggestionGenerator } from './suggestions.js';
+import { type RequirementIntakeStore } from './store.js';
+import type { AddAnswerInput, AttachResourceInput, CreateIntakeInput, IntakeContext, IntakeEvent, IntakeQuestion, LlmSuggestionProposal, RequirementIntakeRecord, UpdateIntakeInput } from './types.js';
+export interface RequirementIntakeServiceOptions {
+    store: RequirementIntakeStore;
+    authorizer: IntakeAuthorizer;
+    /** Optional LLM adapter. `generateSuggestions` fails until one is wired. */
+    generator?: LlmSuggestionGenerator | undefined;
+    emitter?: IntakeEventEmitter | undefined;
+    logger?: IntakeLogger | undefined;
+    metrics?: IntakeMetrics | undefined;
+    /** Default question catalog override. */
+    questions?: readonly IntakeQuestionTemplate[] | undefined;
+}
+export interface IntakeCreateResult {
+    record: RequirementIntakeRecord;
+    created: boolean;
+    idempotent: boolean;
+}
+export interface IntakeSubmitResult {
+    record: RequirementIntakeRecord;
+    idempotent: boolean;
+}
+export interface IntakeListFilter {
+    statuses?: readonly IntakeStatus[] | undefined;
+}
+export declare class RequirementIntakeService {
+    private readonly store;
+    private readonly authorizer;
+    private readonly generator;
+    private readonly emitter;
+    private readonly logger;
+    private readonly metrics;
+    private readonly catalog;
+    constructor(options: RequirementIntakeServiceOptions);
+    /** Subscribe to domain events. Returns a disposer. */
+    subscribe(listener: (event: IntakeEvent) => void): () => void;
+    createIntake(input: CreateIntakeInput, ctx: IntakeContext): Promise<IntakeCreateResult>;
+    getIntake(id: string, ctx: IntakeContext): Promise<RequirementIntakeRecord | null>;
+    listIntakes(projectId: string, ctx: IntakeContext, filter?: IntakeListFilter | undefined): Promise<RequirementIntakeRecord[]>;
+    pendingQuestions(id: string, ctx: IntakeContext): Promise<IntakeQuestion[]>;
+    updateIntake(id: string, patch: UpdateIntakeInput, ctx: IntakeContext, expectedVersion?: number | undefined): Promise<RequirementIntakeRecord>;
+    addAnswer(id: string, input: AddAnswerInput, ctx: IntakeContext, expectedVersion?: number | undefined): Promise<RequirementIntakeRecord>;
+    updateAnswer(id: string, answerId: string, patch: {
+        answer: string;
+    }, ctx: IntakeContext, expectedVersion?: number | undefined): Promise<RequirementIntakeRecord>;
+    attachResource(id: string, input: AttachResourceInput, ctx: IntakeContext, expectedVersion?: number | undefined): Promise<RequirementIntakeRecord>;
+    generateSuggestions(id: string, ctx: IntakeContext, focus?: string[] | undefined): Promise<LlmSuggestionProposal[]>;
+    acceptSuggestion(id: string, proposalId: string, ctx: IntakeContext, expectedVersion?: number | undefined): Promise<RequirementIntakeRecord>;
+    rejectSuggestion(id: string, proposalId: string, ctx: IntakeContext, expectedVersion?: number | undefined): Promise<RequirementIntakeRecord>;
+    submitIntake(id: string, ctx: IntakeContext, expectedVersion?: number | undefined): Promise<IntakeSubmitResult>;
+    cancelIntake(id: string, ctx: IntakeContext, reason?: string | undefined, expectedVersion?: number | undefined): Promise<RequirementIntakeRecord>;
+    archiveIntake(id: string, ctx: IntakeContext, expectedVersion?: number | undefined): Promise<RequirementIntakeRecord>;
+    private buildNewRecord;
+    private requireRecord;
+    private authorize;
+    private assertMutable;
+    private assertAnswerField;
+    private assertSubmitReady;
+    private findSuggestion;
+    private applyProposal;
+    private updateMeta;
+    private afterMutation;
+    private emit;
+    private guardValidation;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/store.d.ts

@@ -0,0 +1,81 @@
+import { type IntakeStatus } from './constants.js';
+import type { RequirementIntakeRecord } from './types.js';
+export interface IntakeIndexEntry {
+    id: string;
+    projectId: string;
+    title: string;
+    status: IntakeStatus;
+    requestType: RequirementIntakeRecord['requestType'];
+    priority: RequirementIntakeRecord['priority'];
+    requestedBy: string;
+    updatedAt: number;
+    createdAt: number;
+}
+export interface RequirementIntakeStoreOptions {
+    /**
+     * Directory where intake records are stored. Defaults to
+     * `resolveWstackPaths({ projectRoot: process.cwd() }).projectRequirementIntakes`
+     * (`~/.wrongstack/projects/<slug>/requirement-intakes`).
+     */
+    baseDir?: string | undefined;
+    /** Cap on retained idempotency-key entries; oldest are pruned. Default 10_000. */
+    maxIdempotencyEntries?: number | undefined;
+    /** Timeout for acquiring the per-record write lock, in ms. Default 15_000. */
+    lockTimeoutMs?: number | undefined;
+}
+export interface StoreUpdateOptions {
+    /** Enforce optimistic concurrency. Undefined = unconditional write. */
+    expectedVersion?: number | undefined;
+    actorId?: string | undefined;
+    actorType?: string | undefined;
+    action?: string | undefined;
+    fields?: string[] | undefined;
+    from?: IntakeStatus | undefined;
+    to?: IntakeStatus | undefined;
+}
+export interface StoreCreateResult {
+    record: RequirementIntakeRecord;
+    created: boolean;
+    idempotent: boolean;
+}
+export declare class RequirementIntakeStore {
+    private readonly baseDir;
+    private readonly indexPath;
+    private readonly idempotencyPath;
+    private readonly maxIdempotencyEntries;
+    private readonly lockTimeoutMs;
+    constructor(options: RequirementIntakeStoreOptions);
+    get directory(): string;
+    private recordPath;
+    load(id: string): Promise<RequirementIntakeRecord | null>;
+    exists(id: string): Promise<boolean>;
+    /** List full records for a project, newest-updated first. */
+    list(projectId?: string | undefined, filter?: {
+        statuses?: readonly IntakeStatus[] | undefined;
+    } | undefined): Promise<RequirementIntakeRecord[]>;
+    /** Cheap listing via the index — no record file reads. */
+    listIndex(projectId?: string | undefined, filter?: {
+        statuses?: readonly IntakeStatus[] | undefined;
+    } | undefined): Promise<IntakeIndexEntry[]>;
+    findByIdempotencyKey(key: string): Promise<RequirementIntakeRecord | null>;
+    /**
+     * Persist a new record. When `idempotencyKey` is given, a second create
+     * with the same key returns the existing record instead of duplicating it.
+     */
+    create(record: RequirementIntakeRecord, idempotencyKey?: string): Promise<StoreCreateResult>;
+    /**
+     * Read-modify-write with optimistic concurrency. `mutate` receives a
+     * mutable copy; the store bumps `version`, refreshes `updatedAt`, appends
+     * the history entry, and persists atomically under the record lock.
+     */
+    update(id: string, options: StoreUpdateOptions, mutate: (record: RequirementIntakeRecord) => void | Promise<void>): Promise<RequirementIntakeRecord>;
+    private writeRecord;
+    private appendHistory;
+    private readIndex;
+    private updateIndexFor;
+    private readIdempotency;
+    private pruneIdempotency;
+}
+/** Generate a store-compatible record id (`reqi_<ulid>`). */
+export declare function newIntakeId(): string;
+//# sourceMappingURL=store.d.ts.map

package/dist/suggestions.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Requirements Intake — LLM suggestion pipeline.
+ *
+ * LLM output is always treated as a *proposal*:
+ *  1. returned in structured form,
+ *  2. validated against a zod schema (malformed output is rejected),
+ *  3. stored separately with `source: 'llm'`,
+ *  4. never allowed to overwrite the original request,
+ *  5. accept/reject is an explicit user decision,
+ *  6. never controls persistence, authorization, or workflow state directly.
+ */
+import { z } from 'zod';
+import { type IntakePriority, type RequestType } from './constants.js';
+import type { IntakeQuestionTemplateInput, LlmSuggestionProposal, RequirementIntakeRecord } from './types.js';
+/** What the module hands to the host's LLM adapter. */
+export interface LlmSuggestionRequest {
+    record: RequirementIntakeRecord;
+    /** Optional focus hint, e.g. ['title', 'questions']. */
+    focus?: string[] | undefined;
+}
+/** Structured output contract for the LLM adapter. */
+export interface LlmSuggestionOutput {
+    suggested_title?: string | undefined;
+    normalized_summary?: string | undefined;
+    suggested_request_type?: string | undefined;
+    suggested_priority?: string | undefined;
+    extracted_constraints?: string[] | undefined;
+    extracted_target_users?: string[] | undefined;
+    suggested_outcome?: string | undefined;
+    suggested_questions?: IntakeQuestionTemplateInput[] | undefined;
+}
+/** Host-provided LLM adapter. Must return structured output. */
+export interface LlmSuggestionGenerator {
+    generate(request: LlmSuggestionRequest): Promise<LlmSuggestionOutput>;
+}
+/** Schema for raw (untrusted) LLM output. */
+export declare const llmSuggestionOutputSchema: z.ZodObject<{
+    suggested_title: z.ZodOptional<z.ZodString>;
+    normalized_summary: z.ZodOptional<z.ZodString>;
+    suggested_request_type: z.ZodOptional<z.ZodString>;
+    suggested_priority: z.ZodOptional<z.ZodString>;
+    extracted_constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    extracted_target_users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    suggested_outcome: z.ZodOptional<z.ZodString>;
+    suggested_questions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        question: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** Validated + normalized LLM output ready for proposal conversion. */
+export interface NormalizedLlmSuggestion {
+    suggestedTitle?: string | undefined;
+    normalizedSummary?: string | undefined;
+    suggestedRequestType?: RequestType | undefined;
+    suggestedPriority?: IntakePriority | undefined;
+    extractedConstraints: string[];
+    extractedTargetUsers: string[];
+    suggestedOutcome?: string | undefined;
+    suggestedQuestions: IntakeQuestionTemplateInput[];
+}
+/**
+ * Validate raw LLM output. Throws `IntakeSuggestionError` when the shape is
+ * malformed; unknown request-type/priority values are normalized, not kept.
+ */
+export declare function validateLlmSuggestionOutput(raw: unknown): NormalizedLlmSuggestion;
+/** Convert validated LLM output into pending proposals. */
+export declare function toProposals(suggestion: NormalizedLlmSuggestion): LlmSuggestionProposal[];
+/** Ensure a raw value is a non-blank string within a length bound. */
+export declare function assertSuggestionString(value: unknown, label: string, max: number): string;
+//# sourceMappingURL=suggestions.d.ts.map

package/dist/types.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Requirements Intake — domain types.
+ *
+ * The record model preserves the exact original request verbatim
+ * (`originalRequest`) and keeps every derived, normalized, or machine-
+ * generated value separate, source-annotated, and user-editable.
+ */
+import type { IntakeAttachmentKind, IntakeField, IntakeFieldSource, IntakePriority, IntakeQuestionStatus, IntakeStatus, RelatedResourceKind, RequestType, SuggestionKind, SuggestionStatus } from './constants.js';
+/** Actor identity used for authorization and audit. */
+export interface IntakeActor {
+    /** Stable actor id (user id, agent id, or automation id). */
+    id: string;
+    /** Actor class. Automation/LLM identities should get minimal permissions. */
+    type: 'user' | 'agent' | 'system' | 'automation';
+}
+/** Per-operation security context. `projectId` is the authorization scope. */
+export interface IntakeContext extends IntakeActor {
+    /** The project the operation targets. Cross-project access must be denied. */
+    projectId: string;
+}
+/** A supporting file/document/link attached to an intake record. */
+export interface IntakeAttachment {
+    id: string;
+    name: string;
+    kind: IntakeAttachmentKind;
+    /** Host-resolved path for file-like attachments. */
+    path?: string | undefined;
+    /** http(s) URL for link-kind attachments. */
+    url?: string | undefined;
+    sizeBytes?: number | undefined;
+    mimeType?: string | undefined;
+    source: IntakeFieldSource;
+    addedBy?: string | undefined;
+    addedAt: number;
+}
+/** A reference to an existing resource (spec, issue, PR, doc, URL, …). */
+export interface RelatedResource {
+    id: string;
+    kind: RelatedResourceKind;
+    /** Resource id, URL, or path. */
+    reference: string;
+    title?: string | undefined;
+    source: IntakeFieldSource;
+    addedBy?: string | undefined;
+    addedAt: number;
+}
+/** A structured question/answer pair collected during intake. */
+export interface IntakeAnswer {
+    id: string;
+    /** The intake field this answer fills (see constants.INTAKE_FIELDS). */
+    field: string;
+    /** Snapshot of the question text at ask time. */
+    question: string;
+    answer: string;
+    source: IntakeFieldSource;
+    answeredBy?: string | undefined;
+    answeredAt: number;
+}
+/** A question asked (or offered) during intake. */
+export interface IntakeQuestion {
+    id: string;
+    field: string;
+    question: string;
+    answer?: string | undefined;
+    required: boolean;
+    status: IntakeQuestionStatus;
+    /** Catalog order — stable across re-derivations. */
+    order: number;
+}
+/** One append-only entry of the record's change history. */
+export interface ChangeHistoryEntry {
+    at: number;
+    actor?: string | undefined;
+    actorType?: string | undefined;
+    action: string;
+    /** Fields whose values changed in this entry. */
+    fields?: string[] | undefined;
+    from?: IntakeStatus | undefined;
+    to?: IntakeStatus | undefined;
+}
+/** An LLM-generated proposal. Never authoritative until accepted by a user. */
+export interface LlmSuggestionProposal {
+    id: string;
+    kind: SuggestionKind;
+    /** Target record field for field-backed kinds (title, request_type, …). */
+    field?: string | undefined;
+    value: unknown;
+    rationale?: string | undefined;
+    status: SuggestionStatus;
+    createdAt: number;
+    resolvedAt?: number | undefined;
+}
+/** The persistent requirement intake record. */
+export interface RequirementIntakeRecord {
+    /** `reqi_<ulid>` — stable, generated by the module. */
+    id: string;
+    /** `proj_<ulid>` project identifier (see core project-identity). */
+    projectId: string;
+    title: string;
+    /** Exact original user request. Immutable after creation. */
+    originalRequest: string;
+    normalizedSummary: string;
+    requestType: RequestType;
+    status: IntakeStatus;
+    priority: IntakePriority;
+    requestedBy: string;
+    businessGoal?: string | undefined;
+    targetUsers: string[];
+    expectedOutcome?: string | undefined;
+    scopeNotes?: string | undefined;
+    constraints: string[];
+    providedContext: string[];
+    attachments: IntakeAttachment[];
+    relatedResources: RelatedResource[];
+    answers: IntakeAnswer[];
+    questions: IntakeQuestion[];
+    llmSuggestions: LlmSuggestionProposal[];
+    metadata: Record<string, unknown>;
+    /** Source annotation per record field ('user' | 'llm' | 'deterministic'). */
+    fieldSources: Partial<Record<IntakeField, IntakeFieldSource>>;
+    /** Raw idempotency key used at creation (kept for diagnostics). */
+    idempotencyKey?: string | undefined;
+    /** Optimistic-concurrency counter; every write increments it. */
+    version: number;
+    history: ChangeHistoryEntry[];
+    createdAt: number;
+    updatedAt: number;
+    submittedAt?: number | undefined;
+    submittedBy?: string | undefined;
+    submittedByType?: string | undefined;
+    cancelledAt?: number | undefined;
+    cancelledReason?: string | undefined;
+    archivedAt?: number | undefined;
+}
+/** Payload for creating an intake record. */
+export interface CreateIntakeInput {
+    projectId: string;
+    /** Exact original request. Required, non-blank, ≤ MAX_REQUEST_LENGTH. */
+    originalRequest: string;
+    title?: string | undefined;
+    /** Any string is accepted and normalized; unknown values become 'other'. */
+    requestType?: string | undefined;
+    priority?: IntakePriority | undefined;
+    requestedBy: string;
+    businessGoal?: string | undefined;
+    targetUsers?: string[] | undefined;
+    expectedOutcome?: string | undefined;
+    scopeNotes?: string | undefined;
+    constraints?: string[] | undefined;
+    providedContext?: string[] | undefined;
+    attachments?: IntakeAttachmentInput[] | undefined;
+    relatedResources?: RelatedResourceInput[] | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    /** Idempotent-create key: same key + project returns the existing record. */
+    idempotencyKey?: string | undefined;
+    /**
+     * Fields already answerable from existing project data. Their questions
+     * are skipped instead of asked.
+     */
+    knownFields?: string[] | undefined;
+    /** Question catalog override. Defaults to DEFAULT_INTAKE_QUESTIONS. */
+    questions?: IntakeQuestionTemplateInput[] | undefined;
+}
+export interface IntakeAttachmentInput {
+    name: string;
+    kind: IntakeAttachmentKind;
+    path?: string | undefined;
+    url?: string | undefined;
+    sizeBytes?: number | undefined;
+    mimeType?: string | undefined;
+}
+export interface RelatedResourceInput {
+    kind: RelatedResourceKind;
+    reference: string;
+    title?: string | undefined;
+}
+export interface IntakeQuestionTemplateInput {
+    field: string;
+    question: string;
+    required?: boolean | undefined;
+}
+/** Payload for updating a draft intake record. */
+export interface UpdateIntakeInput {
+    title?: string | undefined;
+    requestType?: string | undefined;
+    priority?: IntakePriority | undefined;
+    businessGoal?: string | undefined;
+    targetUsers?: string[] | undefined;
+    expectedOutcome?: string | undefined;
+    scopeNotes?: string | undefined;
+    constraints?: string[] | undefined;
+    providedContext?: string[] | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}
+/** Payload for answering an intake question. */
+export interface AddAnswerInput {
+    field: string;
+    answer: string;
+    question?: string | undefined;
+}
+/** Payload for attaching a supporting resource. */
+export interface AttachResourceInput {
+    attachment?: IntakeAttachmentInput | undefined;
+    relatedResource?: RelatedResourceInput | undefined;
+}
+/** Domain events published by the service. */
+export declare const INTAKE_EVENT_NAMES: readonly ['RequirementIntakeCreated', 'RequirementIntakeUpdated', 'RequirementIntakeInformationRequested', 'RequirementIntakeSubmitted', 'RequirementIntakeCancelled', 'RequirementIntakeArchived'];
+export type IntakeEventName = (typeof INTAKE_EVENT_NAMES)[number];
+/**
+ * Event payload. Carries identifiers and safe metadata only — never a copy
+ * of the user request.
+ */
+export interface IntakeEvent {
+    event: IntakeEventName;
+    intakeId: string;
+    projectId: string;
+    actorId?: string | undefined;
+    actorType?: string | undefined;
+    previousStatus?: IntakeStatus | undefined;
+    status: IntakeStatus;
+    timestamp: string;
+}
+//# sourceMappingURL=types.d.ts.map