import { L as Locale, d as FhirVersion, c as FhirResource } from '../types-CRTS25wG.js';
export { A as AddressTemplate, a as AnnotatedResource, b as AnnotationNote, B as BuilderOptions, C as CityDefinition, F as FhirMeta, G as GeneratedFixture, I as IdentifierContext, e as IdentifierDefinition, f as LocaleDefinition, N as NamePool, R as RandomFn, g as ResourceBuilder, S as SUPPORTED_FHIR_VERSIONS, h as SUPPORTED_LOCALES, i as SUPPORTED_RESOURCE_TYPES, j as SupportedResourceType } from '../types-CRTS25wG.js';

interface PatientBuilder {
    locale(locale: Locale): PatientBuilder;
    count(count: number): PatientBuilder;
    seed(seed: number): PatientBuilder;
    fhirVersion(version: FhirVersion): PatientBuilder;
    overrides(overrides: Record<string, unknown>): PatientBuilder;
    build(): FhirResource[];
}
/** Create a new PatientBuilder with default options. */
declare function createPatientBuilder(): PatientBuilder;

interface PractitionerBuilder {
    locale(locale: Locale): PractitionerBuilder;
    count(count: number): PractitionerBuilder;
    seed(seed: number): PractitionerBuilder;
    fhirVersion(version: FhirVersion): PractitionerBuilder;
    overrides(overrides: Record<string, unknown>): PractitionerBuilder;
    build(): FhirResource[];
}
/** Create a new PractitionerBuilder with default options. */
declare function createPractitionerBuilder(): PractitionerBuilder;

interface PractitionerRoleBuilder {
    locale(locale: Locale): PractitionerRoleBuilder;
    count(count: number): PractitionerRoleBuilder;
    seed(seed: number): PractitionerRoleBuilder;
    fhirVersion(version: FhirVersion): PractitionerRoleBuilder;
    /** Inject the ID of an already-built Practitioner so the reference is consistent. */
    practitionerId(id: string): PractitionerRoleBuilder;
    /** Inject the ID of an already-built Organization so the reference is consistent. */
    organizationId(id: string): PractitionerRoleBuilder;
    overrides(overrides: Record<string, unknown>): PractitionerRoleBuilder;
    build(): FhirResource[];
}
/** Create a new PractitionerRoleBuilder with default options. */
declare function createPractitionerRoleBuilder(): PractitionerRoleBuilder;

interface OrganizationBuilder {
    locale(locale: Locale): OrganizationBuilder;
    count(count: number): OrganizationBuilder;
    seed(seed: number): OrganizationBuilder;
    fhirVersion(version: FhirVersion): OrganizationBuilder;
    overrides(overrides: Record<string, unknown>): OrganizationBuilder;
    build(): FhirResource[];
}
/** Create a new OrganizationBuilder with default options. */
declare function createOrganizationBuilder(): OrganizationBuilder;

interface ObservationBuilder {
    locale(locale: Locale): ObservationBuilder;
    count(count: number): ObservationBuilder;
    seed(seed: number): ObservationBuilder;
    subject(patientReference: string): ObservationBuilder;
    category(category: "vital-signs" | "laboratory"): ObservationBuilder;
    fhirVersion(version: FhirVersion): ObservationBuilder;
    overrides(overrides: Record<string, unknown>): ObservationBuilder;
    build(): FhirResource[];
}
/** Create a new ObservationBuilder with default options. */
declare function createObservationBuilder(): ObservationBuilder;

interface ConditionBuilder {
    locale(locale: Locale): ConditionBuilder;
    count(count: number): ConditionBuilder;
    seed(seed: number): ConditionBuilder;
    subject(patientReference: string): ConditionBuilder;
    fhirVersion(version: FhirVersion): ConditionBuilder;
    overrides(overrides: Record<string, unknown>): ConditionBuilder;
    build(): FhirResource[];
}
/** Create a new ConditionBuilder with default options. */
declare function createConditionBuilder(): ConditionBuilder;

interface AllergyIntoleranceBuilder {
    locale(locale: Locale): AllergyIntoleranceBuilder;
    count(count: number): AllergyIntoleranceBuilder;
    seed(seed: number): AllergyIntoleranceBuilder;
    subject(patientReference: string): AllergyIntoleranceBuilder;
    fhirVersion(version: FhirVersion): AllergyIntoleranceBuilder;
    overrides(overrides: Record<string, unknown>): AllergyIntoleranceBuilder;
    build(): FhirResource[];
}
/** Create a new AllergyIntoleranceBuilder with default options. */
declare function createAllergyIntoleranceBuilder(): AllergyIntoleranceBuilder;

interface MedicationStatementBuilder {
    locale(locale: Locale): MedicationStatementBuilder;
    count(count: number): MedicationStatementBuilder;
    seed(seed: number): MedicationStatementBuilder;
    subject(patientReference: string): MedicationStatementBuilder;
    fhirVersion(version: FhirVersion): MedicationStatementBuilder;
    overrides(overrides: Record<string, unknown>): MedicationStatementBuilder;
    build(): FhirResource[];
}
/** Create a new MedicationStatementBuilder with default options. */
declare function createMedicationStatementBuilder(): MedicationStatementBuilder;

interface EncounterBuilder {
    locale(locale: Locale): EncounterBuilder;
    count(count: number): EncounterBuilder;
    seed(seed: number): EncounterBuilder;
    subject(patientReference: string): EncounterBuilder;
    fhirVersion(version: FhirVersion): EncounterBuilder;
    overrides(overrides: Record<string, unknown>): EncounterBuilder;
    build(): FhirResource[];
}
/** Create a new EncounterBuilder with default options. */
declare function createEncounterBuilder(): EncounterBuilder;

interface DiagnosticReportBuilder {
    locale(locale: Locale): DiagnosticReportBuilder;
    count(count: number): DiagnosticReportBuilder;
    seed(seed: number): DiagnosticReportBuilder;
    subject(patientReference: string): DiagnosticReportBuilder;
    fhirVersion(version: FhirVersion): DiagnosticReportBuilder;
    overrides(overrides: Record<string, unknown>): DiagnosticReportBuilder;
    build(): FhirResource[];
}
/** Create a new DiagnosticReportBuilder with default options. */
declare function createDiagnosticReportBuilder(): DiagnosticReportBuilder;

type BundleType = "transaction" | "document" | "collection" | "searchset";
interface BundleBuilder {
    locale(locale: Locale): BundleBuilder;
    count(count: number): BundleBuilder;
    seed(seed: number): BundleBuilder;
    type(bundleType: BundleType): BundleBuilder;
    fhirVersion(version: FhirVersion): BundleBuilder;
    clinicalResourcesPerPatient(count: number): BundleBuilder;
    overrides(overrides: Record<string, unknown>): BundleBuilder;
    build(): FhirResource[];
}
/** Create a new BundleBuilder with default options. */
declare function createBundleBuilder(): BundleBuilder;

declare const RECIPE_RESOURCE_TYPES: readonly ["Patient", "Practitioner", "PractitionerRole", "Organization", "Observation", "Condition", "AllergyIntolerance", "MedicationStatement", "Encounter", "DiagnosticReport"];
type RecipeResourceType = (typeof RECIPE_RESOURCE_TYPES)[number];
interface BundleRecipeResource {
    /** Existing builder resource type to generate. */
    type: RecipeResourceType;
    /** User-facing alias used by other recipe fields to reference this resource. */
    id: string;
    /** Number of resources to generate for this recipe entry. */
    count?: number;
    /** Fields deep-merged into generated resources after builder defaults. */
    fields?: Record<string, unknown>;
}
interface BundleRecipe {
    /** Human-readable recipe name for diagnostics and documentation. */
    name: string;
    /** Default locale for generated identifiers, names, and addresses. */
    locale?: Locale;
    /** Default FHIR version for generated resources. */
    fhirVersion?: FhirVersion;
    /** Bundle-level generation options. */
    bundle?: {
        type?: BundleType;
    };
    /** Ordered resource recipe entries. Later entries can reference earlier aliases. */
    resources: BundleRecipeResource[];
}
interface BundleRecipeOptions {
    /** Seed for deterministic generation. Same seed and recipe produce identical output. */
    seed?: number;
    /** Overrides recipe.locale when provided. */
    locale?: Locale;
    /** Overrides recipe.fhirVersion when provided. */
    fhirVersion?: FhirVersion;
    /** Number of Bundles to generate. */
    count?: number;
}
/** Error thrown when a user-supplied Bundle recipe is invalid or cannot be resolved. */
declare class BundleRecipeError extends Error {
    constructor(message: string);
}
/** Generate deterministic FHIR Bundle resources from a user-owned bundle recipe. */
declare function createBundleFromRecipe(recipe: BundleRecipe, options?: BundleRecipeOptions): FhirResource[];

export { type AllergyIntoleranceBuilder, type BundleBuilder, type BundleRecipe, BundleRecipeError, type BundleRecipeOptions, type BundleRecipeResource, type BundleType, type ConditionBuilder, type DiagnosticReportBuilder, type EncounterBuilder, FhirResource, FhirVersion, Locale, type MedicationStatementBuilder, type ObservationBuilder, type OrganizationBuilder, type PatientBuilder, type PractitionerBuilder, type PractitionerRoleBuilder, RECIPE_RESOURCE_TYPES, type RecipeResourceType, createAllergyIntoleranceBuilder, createBundleBuilder, createBundleFromRecipe, createConditionBuilder, createDiagnosticReportBuilder, createEncounterBuilder, createMedicationStatementBuilder, createObservationBuilder, createOrganizationBuilder, createPatientBuilder, createPractitionerBuilder, createPractitionerRoleBuilder };