import { U as UseCase, h as UseCaseSummary } from '../types-BkxyKhsg.cjs';
export { B as BusinessIdentity, F as FormAudience, N as NotificationChannel, P as PostalAddress, i as UseCaseDashboardQuestion, j as UseCaseDocumentTemplate, b as UseCaseField, d as UseCaseForm, e as UseCaseFormField, k as UseCaseMergeField, l as UseCaseNotificationRule, f as UseCaseNotificationTrigger, m as UseCasePipeline, n as UseCasePipelineStage, g as UseCaseProvenance, o as UseCaseRelationship, c as UseCaseRow, a as UseCaseTable } from '../types-BkxyKhsg.cjs';
export { M as MIN_ROWS_IN_PRIMARY_TABLE, R as RESOLVABLE_FIELD_TYPE_WORDS, U as UseCaseProblem, a as UseCaseVerdict, b as assertUseCase, v as validateUseCase } from '../validate-WfZ9gpUV.cjs';
import '../record-C3thPhpR.cjs';
import '../field-BJBjyD8y.cjs';

/** One banned pattern, with the reason and what to do instead. */
interface PlaceholderPattern {
    /** Stable id, used in the guard's output so a failure is greppable. */
    id: string;
    /** Matches the junk. Always global + case-insensitive. */
    test: RegExp;
    /** What is wrong with it, in one line. */
    why: string;
    /** What to write instead. */
    instead: string;
    /**
     * Skip the hit when the LINE it sits on matches this. For words that are junk
     * in one world and vocabulary in another: "Acme" is a cartoon company, but
     * ACME is also RFC 8555, the protocol Let's Encrypt speaks, and a guard that
     * cannot tell them apart will be told to shut up rather than obeyed.
     */
    unlessLineMatches?: RegExp;
    /** Fire only when the WHOLE text matches this (a rule about a kind of file, not a kind of line). */
    onlyInTextMatching?: RegExp;
}
/**
 * The pragma that exempts a single line. The reason is not optional: a bare
 * `matrx-real-data:allow` does not match and does not exempt anything.
 */
declare const ALLOW_PRAGMA: RegExp;
/**
 * THE LIST. Every entry is anchored on word boundaries so it catches the token
 * and not the vocabulary it lives inside.
 */
declare const PLACEHOLDER_PATTERNS: readonly PlaceholderPattern[];
/**
 * THE ACCOUNT DOORS (junk-data-cleanup, 2026-09-30).
 *
 * `PLACEHOLDER_PATTERNS` guards data a SCREEN shows. These guard how a test, script or
 * agent makes a PERSON: agents hand-made `zzz.*@example.invalid` accounts with inline
 * scripts and MCP SQL, ran them once against the live database and never deleted them (28
 * reserved-TLD accounts, 0 of 1,520 carrying any test marker). They are applied only to
 * scripts and tests (`ACCOUNT_DOOR_SCOPE` in each guard), never product code: the
 * portal-invite route and guest sign-in create real accounts on purpose.
 *
 * The one lawful door is the persona factory (aidream/aidream/testing/persona.py,
 * matrx-frontend scripts/lib/persona.mjs): a realistic person, tagged
 * `app_metadata.test_fixture` with an expiry, on `fixtures.aimatrx.com`. The exemption is a
 * line pragma, NOT `matrx-real-data:allow`:
 *
 *   matrx-fixture:rollback-only <reason>   the account lives in a transaction that is rolled back
 *   matrx-fixture:factory-only <reason>    the factory's own call to the admin door
 *   matrx-fixture:read-only <reason>       the line reads or looks up an account, never creates one
 *   matrx-fixture:named-permanent <reason> a NAMED permanent fixture the script tags itself (expires_at null)
 *   matrx-fixture:not-a-person <reason>    the name looks like a junk head but is a stub, never an account or row
 *
 * The reason is required and it is in the diff.
 */
declare const FIXTURE_PRAGMA: RegExp;
/**
 * A file that CREATES accounts. Reserved-TLD mailboxes are everywhere in plumbing tests that mock
 * a mail parser, a proxy URL or a DSN and never touch auth; the junk-account class is the file that
 * also makes an auth user, so `reserved-tld-mailbox` fires only in such a file.
 */
declare const ACCOUNT_CREATION_SIGNAL: RegExp;
declare const ACCOUNT_DOOR_PATTERNS: readonly PlaceholderPattern[];
/** Every account-door violation in `text`. Line-scoped: one pragma never blinds the rest of a file. */
declare function findAccountDoorViolations(text: string): PlaceholderHit[];
/** One hit of one pattern. */
interface PlaceholderHit {
    patternId: string;
    /** The exact text that matched. */
    match: string;
    why: string;
    instead: string;
    /** 1-based line, set by `findAccountDoorViolations`. */
    line?: number;
}
/**
 * Every banned pattern in `text`, ignoring any LINE carrying the allow pragma.
 *
 * Line-scoped rather than whole-text so one exemption never blinds the rest of
 * a file, which is the failure mode of a file-level ignore comment.
 */
declare function findPlaceholders(text: string): PlaceholderHit[];
/** The sentence a guard or a suite prints for one hit. Never a bare code. */
declare function describePlaceholder(hit: PlaceholderHit): string;
type LabelKind = "table" | "field" | "choice" | "person" | "title";
interface BannedLabel {
    id: string;
    test: RegExp;
    kinds: readonly LabelKind[];
    why: string;
}
declare const BANNED_LABELS: readonly BannedLabel[];
/** The first banned-label rule `label` breaks for its kind, or null. */
declare function findBannedLabel(label: string, kind: LabelKind): BannedLabel | null;

/**
 * Every registered use case, by id. ADD YOUR LINE HERE and nowhere else.
 *
 * Keep it alphabetical — it is read by people looking for an industry.
 */
declare const USE_CASE_LOADERS: Record<string, () => Promise<{
    useCase: UseCase;
}>>;
/** The ids, sorted, so any listing is stable. */
declare function useCaseIds(): string[];
/** Load one by id. Throws by name when it is not registered. */
declare function loadUseCase(id: string): Promise<UseCase>;
/** Load all of them. For the suite, the seeders and the census. */
declare function loadAllUseCases(): Promise<UseCase[]>;
/** Summarize one without the caller walking its tables. */
declare function summarize(useCase: UseCase): UseCaseSummary;
/** Every use case, summarized. Loads all of them, so call it server-side. */
declare function listUseCases(): Promise<UseCaseSummary[]>;
/**
 * Pick the use case for a given consumer, deterministically.
 *
 * The law says to ROTATE across industries so the platform is exercised by many
 * kinds of business rather than one toy. A suite, a demo or a screenshot script
 * passes a stable name for itself and always gets the same business — stable
 * enough to assert on, different enough across consumers that the platform gets
 * exercised broadly.
 */
declare function useCaseFor(consumer: string): string;

export { ACCOUNT_CREATION_SIGNAL, ACCOUNT_DOOR_PATTERNS, ALLOW_PRAGMA, BANNED_LABELS, FIXTURE_PRAGMA, PLACEHOLDER_PATTERNS, USE_CASE_LOADERS, UseCase, UseCaseSummary, describePlaceholder, findAccountDoorViolations, findBannedLabel, findPlaceholders, listUseCases, loadAllUseCases, loadUseCase, summarize, useCaseFor, useCaseIds };
export type { BannedLabel, LabelKind, PlaceholderHit, PlaceholderPattern };