@openhi/types 0.0.17 → 0.0.18

package/lib/data/constants.d.ts

@@ -1,102 +1,4076 @@
-/**
- * FHIR R4 value-set constants (const-as-const pattern).
- * Use these for both types and runtime values (e.g. PUBLICATION_STATUS.ACTIVE).
- */
-/** Publication status: draft | active | retired | unknown (used by many FHIR resources) */
-export declare const PUBLICATION_STATUS: {
-    readonly DRAFT: "draft";
+import { z } from "zod";
+export declare const ACCOUNT_STATUS: {
     readonly ACTIVE: "active";
-    readonly RETIRED: "retired";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly INACTIVE: "inactive";
+    readonly ON_HOLD: "on-hold";
     readonly UNKNOWN: "unknown";
 };
-export type PublicationStatus = (typeof PUBLICATION_STATUS)[keyof typeof PUBLICATION_STATUS];
-/** Administrative gender: male | female | other | unknown */
+export type AccountStatus = (typeof ACCOUNT_STATUS)[keyof typeof ACCOUNT_STATUS];
+export declare const accountStatusSchema: z.ZodEnum<["active", "entered-in-error", "inactive", "on-hold", "unknown"]>;
+export declare const ACTION_CARDINALITY_BEHAVIOR: {
+    readonly MULTIPLE: "multiple";
+    readonly SINGLE: "single";
+};
+export type ActionCardinalityBehavior = (typeof ACTION_CARDINALITY_BEHAVIOR)[keyof typeof ACTION_CARDINALITY_BEHAVIOR];
+export declare const actionCardinalityBehaviorSchema: z.ZodEnum<["multiple", "single"]>;
+export declare const ACTION_CONDITION_KIND: {
+    readonly APPLICABILITY: "applicability";
+    readonly START: "start";
+    readonly STOP: "stop";
+};
+export type ActionConditionKind = (typeof ACTION_CONDITION_KIND)[keyof typeof ACTION_CONDITION_KIND];
+export declare const actionConditionKindSchema: z.ZodEnum<["applicability", "start", "stop"]>;
+export declare const ACTION_GROUPING_BEHAVIOR: {
+    readonly LOGICAL_GROUP: "logical-group";
+    readonly SENTENCE_GROUP: "sentence-group";
+    readonly VISUAL_GROUP: "visual-group";
+};
+export type ActionGroupingBehavior = (typeof ACTION_GROUPING_BEHAVIOR)[keyof typeof ACTION_GROUPING_BEHAVIOR];
+export declare const actionGroupingBehaviorSchema: z.ZodEnum<["logical-group", "sentence-group", "visual-group"]>;
+export declare const ACTION_PARTICIPANT_TYPE: {
+    readonly DEVICE: "device";
+    readonly PATIENT: "patient";
+    readonly PRACTITIONER: "practitioner";
+    readonly RELATED_PERSON: "related-person";
+};
+export type ActionParticipantType = (typeof ACTION_PARTICIPANT_TYPE)[keyof typeof ACTION_PARTICIPANT_TYPE];
+export declare const actionParticipantTypeSchema: z.ZodEnum<["device", "patient", "practitioner", "related-person"]>;
+export declare const ACTION_PRECHECK_BEHAVIOR: {
+    readonly NO: "no";
+    readonly YES: "yes";
+};
+export type ActionPrecheckBehavior = (typeof ACTION_PRECHECK_BEHAVIOR)[keyof typeof ACTION_PRECHECK_BEHAVIOR];
+export declare const actionPrecheckBehaviorSchema: z.ZodEnum<["no", "yes"]>;
+export declare const ACTION_RELATIONSHIP_TYPE: {
+    readonly AFTER: "after";
+    readonly AFTER_END: "after-end";
+    readonly AFTER_START: "after-start";
+    readonly BEFORE: "before";
+    readonly BEFORE_END: "before-end";
+    readonly BEFORE_START: "before-start";
+    readonly CONCURRENT: "concurrent";
+    readonly CONCURRENT_WITH_END: "concurrent-with-end";
+    readonly CONCURRENT_WITH_START: "concurrent-with-start";
+};
+export type ActionRelationshipType = (typeof ACTION_RELATIONSHIP_TYPE)[keyof typeof ACTION_RELATIONSHIP_TYPE];
+export declare const actionRelationshipTypeSchema: z.ZodEnum<["after", "after-end", "after-start", "before", "before-end", "before-start", "concurrent", "concurrent-with-end", "concurrent-with-start"]>;
+export declare const ACTION_REQUIRED_BEHAVIOR: {
+    readonly COULD: "could";
+    readonly MUST: "must";
+    readonly MUST_UNLESS_DOCUMENTED: "must-unless-documented";
+};
+export type ActionRequiredBehavior = (typeof ACTION_REQUIRED_BEHAVIOR)[keyof typeof ACTION_REQUIRED_BEHAVIOR];
+export declare const actionRequiredBehaviorSchema: z.ZodEnum<["could", "must", "must-unless-documented"]>;
+export declare const ACTION_SELECTION_BEHAVIOR: {
+    readonly ALL: "all";
+    readonly ALL_OR_NONE: "all-or-none";
+    readonly ANY: "any";
+    readonly AT_MOST_ONE: "at-most-one";
+    readonly EXACTLY_ONE: "exactly-one";
+    readonly ONE_OR_MORE: "one-or-more";
+};
+export type ActionSelectionBehavior = (typeof ACTION_SELECTION_BEHAVIOR)[keyof typeof ACTION_SELECTION_BEHAVIOR];
+export declare const actionSelectionBehaviorSchema: z.ZodEnum<["all", "all-or-none", "any", "at-most-one", "exactly-one", "one-or-more"]>;
+export declare const ACTION_TYPE: {
+    readonly CREATE: "create";
+    readonly FIRE_EVENT: "fire-event";
+    readonly REMOVE: "remove";
+    readonly UPDATE: "update";
+};
+export type ActionType = (typeof ACTION_TYPE)[keyof typeof ACTION_TYPE];
+export declare const actionTypeSchema: z.ZodEnum<["create", "fire-event", "remove", "update"]>;
+export declare const ADDRESS_TYPE: {
+    readonly BOTH: "both";
+    readonly PHYSICAL: "physical";
+    readonly POSTAL: "postal";
+};
+export type AddressType = (typeof ADDRESS_TYPE)[keyof typeof ADDRESS_TYPE];
+export declare const addressTypeSchema: z.ZodEnum<["both", "physical", "postal"]>;
+export declare const ADDRESS_USE: {
+    readonly BILLING: "billing";
+    readonly HOME: "home";
+    readonly OLD: "old";
+    readonly TEMP: "temp";
+    readonly WORK: "work";
+};
+export type AddressUse = (typeof ADDRESS_USE)[keyof typeof ADDRESS_USE];
+export declare const addressUseSchema: z.ZodEnum<["billing", "home", "old", "temp", "work"]>;
 export declare const ADMINISTRATIVE_GENDER: {
-    readonly MALE: "male";
     readonly FEMALE: "female";
+    readonly MALE: "male";
     readonly OTHER: "other";
     readonly UNKNOWN: "unknown";
 };
 export type AdministrativeGender = (typeof ADMINISTRATIVE_GENDER)[keyof typeof ADMINISTRATIVE_GENDER];
-/** Status: active | inactive | entered-in-error (MedicationKnowledge, Substance, Medication, Flag, Device) */
-export declare const ACTIVE_INACTIVE_ENTERED_IN_ERROR_STATUS: {
+export declare const administrativeGenderSchema: z.ZodEnum<["female", "male", "other", "unknown"]>;
+export declare const ADVERSE_EVENT_ACTUALITY: {
+    readonly ACTUAL: "actual";
+    readonly POTENTIAL: "potential";
+};
+export type AdverseEventActuality = (typeof ADVERSE_EVENT_ACTUALITY)[keyof typeof ADVERSE_EVENT_ACTUALITY];
+export declare const adverseEventActualitySchema: z.ZodEnum<["actual", "potential"]>;
+export declare const ADVERSE_EVENT_CATEGORY: {
+    readonly EXPIRED_DRUG: "expired-drug";
+    readonly INCORRECT_PRESCRIBING_INFORMATION: "incorrect-prescribing-information";
+    readonly MEDICAL_DEVICE_USE_ERROR: "medical-device-use-error";
+    readonly PROBLEM_DIFFERENT_MANUFACTURER: "problem-different-manufacturer";
+    readonly PRODUCT_PROBLEM: "product-problem";
+    readonly PRODUCT_QUALITY: "product-quality";
+    readonly PRODUCT_USE_ERROR: "product-use-error";
+    readonly UNSAFE_PHYSICAL_ENVIRONMENT: "unsafe-physical-environment";
+    readonly WRONG_DOSE: "wrong-dose";
+    readonly WRONG_DURATION: "wrong-duration";
+    readonly WRONG_RATE: "wrong-rate";
+    readonly WRONG_ROUTE_OF_ADMINISTRATION: "wrong-route-of-administration";
+    readonly WRONG_TECHNIQUE: "wrong-technique";
+    readonly WRONG_TIME: "wrong-time";
+};
+export type AdverseEventCategory = (typeof ADVERSE_EVENT_CATEGORY)[keyof typeof ADVERSE_EVENT_CATEGORY];
+export declare const adverseEventCategorySchema: z.ZodEnum<["expired-drug", "incorrect-prescribing-information", "medical-device-use-error", "problem-different-manufacturer", "product-problem", "product-quality", "product-use-error", "unsafe-physical-environment", "wrong-dose", "wrong-duration", "wrong-rate", "wrong-route-of-administration", "wrong-technique", "wrong-time"]>;
+export declare const ADVERSE_EVENT_OUTCOME: {
+    readonly FATAL: "fatal";
+    readonly ONGOING: "ongoing";
+    readonly RECOVERING: "recovering";
+    readonly RESOLVED: "resolved";
+    readonly RESOLVEDWITHSEQUELAE: "resolvedWithSequelae";
+    readonly UNKNOWN: "unknown";
+};
+export type AdverseEventOutcome = (typeof ADVERSE_EVENT_OUTCOME)[keyof typeof ADVERSE_EVENT_OUTCOME];
+export declare const adverseEventOutcomeSchema: z.ZodEnum<["fatal", "ongoing", "recovering", "resolved", "resolvedWithSequelae", "unknown"]>;
+export declare const ADVERSE_EVENT_SEVERITY: {
+    readonly MILD: "mild";
+    readonly MODERATE: "moderate";
+    readonly SEVERE: "severe";
+};
+export type AdverseEventSeverity = (typeof ADVERSE_EVENT_SEVERITY)[keyof typeof ADVERSE_EVENT_SEVERITY];
+export declare const adverseEventSeveritySchema: z.ZodEnum<["mild", "moderate", "severe"]>;
+export declare const AGGREGATION_MODE: {
+    readonly BUNDLED: "bundled";
+    readonly CONTAINED: "contained";
+    readonly REFERENCED: "referenced";
+};
+export type AggregationMode = (typeof AGGREGATION_MODE)[keyof typeof AGGREGATION_MODE];
+export declare const aggregationModeSchema: z.ZodEnum<["bundled", "contained", "referenced"]>;
+export declare const ALLERGY_INTOLERANCE_CATEGORY: {
+    readonly BIOLOGIC: "biologic";
+    readonly ENVIRONMENT: "environment";
+    readonly FOOD: "food";
+    readonly MEDICATION: "medication";
+};
+export type AllergyIntoleranceCategory = (typeof ALLERGY_INTOLERANCE_CATEGORY)[keyof typeof ALLERGY_INTOLERANCE_CATEGORY];
+export declare const allergyIntoleranceCategorySchema: z.ZodEnum<["biologic", "environment", "food", "medication"]>;
+export declare const ALLERGY_INTOLERANCE_CLINICAL_STATUS_CODES: {
     readonly ACTIVE: "active";
     readonly INACTIVE: "inactive";
-    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly RESOLVED: "resolved";
 };
-export type ActiveInactiveEnteredInErrorStatus = (typeof ACTIVE_INACTIVE_ENTERED_IN_ERROR_STATUS)[keyof typeof ACTIVE_INACTIVE_ENTERED_IN_ERROR_STATUS];
-/** MIME type for TestScript: xml | json | ttl | none */
-export declare const TESTSCRIPT_MIME_TYPE: {
-    readonly XML: "xml";
-    readonly JSON: "json";
-    readonly TTL: "ttl";
-    readonly NONE: "none";
+export type AllergyIntoleranceClinicalStatusCodes = (typeof ALLERGY_INTOLERANCE_CLINICAL_STATUS_CODES)[keyof typeof ALLERGY_INTOLERANCE_CLINICAL_STATUS_CODES];
+export declare const allergyIntoleranceClinicalStatusCodesSchema: z.ZodEnum<["active", "inactive", "resolved"]>;
+export declare const ALLERGY_INTOLERANCE_CRITICALITY: {
+    readonly HIGH: "high";
+    readonly LOW: "low";
+    readonly UNABLE_TO_ASSESS: "unable-to-assess";
 };
-export type TestScriptMimeType = (typeof TESTSCRIPT_MIME_TYPE)[keyof typeof TESTSCRIPT_MIME_TYPE];
-/** TestReport overall result: pass | fail | pending */
-export declare const TESTREPORT_RESULT: {
-    readonly PASS: "pass";
-    readonly FAIL: "fail";
+export type AllergyIntoleranceCriticality = (typeof ALLERGY_INTOLERANCE_CRITICALITY)[keyof typeof ALLERGY_INTOLERANCE_CRITICALITY];
+export declare const allergyIntoleranceCriticalitySchema: z.ZodEnum<["high", "low", "unable-to-assess"]>;
+export declare const ALLERGY_INTOLERANCE_SEVERITY: {
+    readonly MILD: "mild";
+    readonly MODERATE: "moderate";
+    readonly SEVERE: "severe";
+};
+export type AllergyIntoleranceSeverity = (typeof ALLERGY_INTOLERANCE_SEVERITY)[keyof typeof ALLERGY_INTOLERANCE_SEVERITY];
+export declare const allergyIntoleranceSeveritySchema: z.ZodEnum<["mild", "moderate", "severe"]>;
+export declare const ALLERGY_INTOLERANCE_TYPE: {
+    readonly ALLERGY: "allergy";
+    readonly INTOLERANCE: "intolerance";
+};
+export type AllergyIntoleranceType = (typeof ALLERGY_INTOLERANCE_TYPE)[keyof typeof ALLERGY_INTOLERANCE_TYPE];
+export declare const allergyIntoleranceTypeSchema: z.ZodEnum<["allergy", "intolerance"]>;
+export declare const ALLERGY_INTOLERANCE_VERIFICATION_STATUS_CODES: {
+    readonly CONFIRMED: "confirmed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly REFUTED: "refuted";
+    readonly UNCONFIRMED: "unconfirmed";
+};
+export type AllergyIntoleranceVerificationStatusCodes = (typeof ALLERGY_INTOLERANCE_VERIFICATION_STATUS_CODES)[keyof typeof ALLERGY_INTOLERANCE_VERIFICATION_STATUS_CODES];
+export declare const allergyIntoleranceVerificationStatusCodesSchema: z.ZodEnum<["confirmed", "entered-in-error", "refuted", "unconfirmed"]>;
+export declare const APPOINTMENT_STATUS: {
+    readonly ARRIVED: "arrived";
+    readonly BOOKED: "booked";
+    readonly CANCELLED: "cancelled";
+    readonly CHECKED_IN: "checked-in";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly FULFILLED: "fulfilled";
+    readonly NOSHOW: "noshow";
     readonly PENDING: "pending";
+    readonly PROPOSED: "proposed";
+    readonly WAITLIST: "waitlist";
 };
-export type TestReportResult = (typeof TESTREPORT_RESULT)[keyof typeof TESTREPORT_RESULT];
-/** TestReport result (operation/assert): pass | skip | fail | warning | error */
-export declare const TESTREPORT_RESULT_DETAIL: {
-    readonly PASS: "pass";
-    readonly SKIP: "skip";
-    readonly FAIL: "fail";
-    readonly WARNING: "warning";
+export type AppointmentStatus = (typeof APPOINTMENT_STATUS)[keyof typeof APPOINTMENT_STATUS];
+export declare const appointmentStatusSchema: z.ZodEnum<["arrived", "booked", "cancelled", "checked-in", "entered-in-error", "fulfilled", "noshow", "pending", "proposed", "waitlist"]>;
+export declare const ASSERTION_DIRECTION_TYPE: {
+    readonly REQUEST: "request";
+    readonly RESPONSE: "response";
+};
+export type AssertionDirectionType = (typeof ASSERTION_DIRECTION_TYPE)[keyof typeof ASSERTION_DIRECTION_TYPE];
+export declare const assertionDirectionTypeSchema: z.ZodEnum<["request", "response"]>;
+export declare const ASSERTION_OPERATOR_TYPE: {
+    readonly CONTAINS: "contains";
+    readonly EMPTY: "empty";
+    readonly EQUALS: "equals";
+    readonly EVAL: "eval";
+    readonly GREATERTHAN: "greaterThan";
+    readonly IN: "in";
+    readonly LESSTHAN: "lessThan";
+    readonly NOTCONTAINS: "notContains";
+    readonly NOTEMPTY: "notEmpty";
+    readonly NOTEQUALS: "notEquals";
+    readonly NOTIN: "notIn";
+};
+export type AssertionOperatorType = (typeof ASSERTION_OPERATOR_TYPE)[keyof typeof ASSERTION_OPERATOR_TYPE];
+export declare const assertionOperatorTypeSchema: z.ZodEnum<["contains", "empty", "equals", "eval", "greaterThan", "in", "lessThan", "notContains", "notEmpty", "notEquals", "notIn"]>;
+export declare const ASSERTION_RESPONSE_TYPES: {
+    readonly BAD: "bad";
+    readonly CONFLICT: "conflict";
+    readonly CREATED: "created";
+    readonly FORBIDDEN: "forbidden";
+    readonly GONE: "gone";
+    readonly METHODNOTALLOWED: "methodNotAllowed";
+    readonly NOCONTENT: "noContent";
+    readonly NOTFOUND: "notFound";
+    readonly NOTMODIFIED: "notModified";
+    readonly OKAY: "okay";
+    readonly PRECONDITIONFAILED: "preconditionFailed";
+    readonly UNPROCESSABLE: "unprocessable";
+};
+export type AssertionResponseTypes = (typeof ASSERTION_RESPONSE_TYPES)[keyof typeof ASSERTION_RESPONSE_TYPES];
+export declare const assertionResponseTypesSchema: z.ZodEnum<["bad", "conflict", "created", "forbidden", "gone", "methodNotAllowed", "noContent", "notFound", "notModified", "okay", "preconditionFailed", "unprocessable"]>;
+export declare const AUDIT_EVENT_ACTION: {
+    readonly C: "C";
+    readonly D: "D";
+    readonly E: "E";
+    readonly R: "R";
+    readonly U: "U";
+};
+export type AuditEventAction = (typeof AUDIT_EVENT_ACTION)[keyof typeof AUDIT_EVENT_ACTION];
+export declare const auditEventActionSchema: z.ZodEnum<["C", "D", "E", "R", "U"]>;
+export declare const AUDIT_EVENT_AGENT_NETWORK_TYPE: {
+    readonly _1: "1";
+    readonly _2: "2";
+    readonly _3: "3";
+    readonly _4: "4";
+    readonly _5: "5";
+};
+export type AuditEventAgentNetworkType = (typeof AUDIT_EVENT_AGENT_NETWORK_TYPE)[keyof typeof AUDIT_EVENT_AGENT_NETWORK_TYPE];
+export declare const auditEventAgentNetworkTypeSchema: z.ZodEnum<["1", "2", "3", "4", "5"]>;
+export declare const AUDIT_EVENT_ENTITY_ROLE: {
+    readonly _1: "1";
+    readonly _10: "10";
+    readonly _11: "11";
+    readonly _12: "12";
+    readonly _13: "13";
+    readonly _14: "14";
+    readonly _15: "15";
+    readonly _16: "16";
+    readonly _17: "17";
+    readonly _18: "18";
+    readonly _19: "19";
+    readonly _2: "2";
+    readonly _20: "20";
+    readonly _21: "21";
+    readonly _22: "22";
+    readonly _23: "23";
+    readonly _24: "24";
+    readonly _3: "3";
+    readonly _4: "4";
+    readonly _5: "5";
+    readonly _6: "6";
+    readonly _7: "7";
+    readonly _8: "8";
+    readonly _9: "9";
+};
+export type AuditEventEntityRole = (typeof AUDIT_EVENT_ENTITY_ROLE)[keyof typeof AUDIT_EVENT_ENTITY_ROLE];
+export declare const auditEventEntityRoleSchema: z.ZodEnum<["1", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "2", "20", "21", "22", "23", "24", "3", "4", "5", "6", "7", "8", "9"]>;
+export declare const AUDIT_EVENT_ENTITY_TYPE: {
+    readonly _1: "1";
+    readonly _2: "2";
+    readonly _3: "3";
+    readonly _4: "4";
+    readonly ACCOUNT: "Account";
+    readonly ACTIVITYDEFINITION: "ActivityDefinition";
+    readonly ADVERSEEVENT: "AdverseEvent";
+    readonly ALLERGYINTOLERANCE: "AllergyIntolerance";
+    readonly APPOINTMENT: "Appointment";
+    readonly APPOINTMENTRESPONSE: "AppointmentResponse";
+    readonly AUDITEVENT: "AuditEvent";
+    readonly BASIC: "Basic";
+    readonly BINARY: "Binary";
+    readonly BIOLOGICALLYDERIVEDPRODUCT: "BiologicallyDerivedProduct";
+    readonly BODYSTRUCTURE: "BodyStructure";
+    readonly BUNDLE: "Bundle";
+    readonly CAPABILITYSTATEMENT: "CapabilityStatement";
+    readonly CAREPLAN: "CarePlan";
+    readonly CARETEAM: "CareTeam";
+    readonly CATALOGENTRY: "CatalogEntry";
+    readonly CHARGEITEM: "ChargeItem";
+    readonly CHARGEITEMDEFINITION: "ChargeItemDefinition";
+    readonly CLAIM: "Claim";
+    readonly CLAIMRESPONSE: "ClaimResponse";
+    readonly CLINICALIMPRESSION: "ClinicalImpression";
+    readonly CODESYSTEM: "CodeSystem";
+    readonly COMMUNICATION: "Communication";
+    readonly COMMUNICATIONREQUEST: "CommunicationRequest";
+    readonly COMPARTMENTDEFINITION: "CompartmentDefinition";
+    readonly COMPOSITION: "Composition";
+    readonly CONCEPTMAP: "ConceptMap";
+    readonly CONDITION: "Condition";
+    readonly CONSENT: "Consent";
+    readonly CONTRACT: "Contract";
+    readonly COVERAGE: "Coverage";
+    readonly COVERAGEELIGIBILITYREQUEST: "CoverageEligibilityRequest";
+    readonly COVERAGEELIGIBILITYRESPONSE: "CoverageEligibilityResponse";
+    readonly DETECTEDISSUE: "DetectedIssue";
+    readonly DEVICE: "Device";
+    readonly DEVICEDEFINITION: "DeviceDefinition";
+    readonly DEVICEMETRIC: "DeviceMetric";
+    readonly DEVICEREQUEST: "DeviceRequest";
+    readonly DEVICEUSESTATEMENT: "DeviceUseStatement";
+    readonly DIAGNOSTICREPORT: "DiagnosticReport";
+    readonly DOCUMENTMANIFEST: "DocumentManifest";
+    readonly DOCUMENTREFERENCE: "DocumentReference";
+    readonly DOMAINRESOURCE: "DomainResource";
+    readonly EFFECTEVIDENCESYNTHESIS: "EffectEvidenceSynthesis";
+    readonly ENCOUNTER: "Encounter";
+    readonly ENDPOINT: "Endpoint";
+    readonly ENROLLMENTREQUEST: "EnrollmentRequest";
+    readonly ENROLLMENTRESPONSE: "EnrollmentResponse";
+    readonly EPISODEOFCARE: "EpisodeOfCare";
+    readonly EVENTDEFINITION: "EventDefinition";
+    readonly EVIDENCE: "Evidence";
+    readonly EVIDENCEVARIABLE: "EvidenceVariable";
+    readonly EXAMPLESCENARIO: "ExampleScenario";
+    readonly EXPLANATIONOFBENEFIT: "ExplanationOfBenefit";
+    readonly FAMILYMEMBERHISTORY: "FamilyMemberHistory";
+    readonly FLAG: "Flag";
+    readonly GOAL: "Goal";
+    readonly GRAPHDEFINITION: "GraphDefinition";
+    readonly GROUP: "Group";
+    readonly GUIDANCERESPONSE: "GuidanceResponse";
+    readonly HEALTHCARESERVICE: "HealthcareService";
+    readonly IMAGINGSTUDY: "ImagingStudy";
+    readonly IMMUNIZATION: "Immunization";
+    readonly IMMUNIZATIONEVALUATION: "ImmunizationEvaluation";
+    readonly IMMUNIZATIONRECOMMENDATION: "ImmunizationRecommendation";
+    readonly IMPLEMENTATIONGUIDE: "ImplementationGuide";
+    readonly INSURANCEPLAN: "InsurancePlan";
+    readonly INVOICE: "Invoice";
+    readonly LIBRARY: "Library";
+    readonly LINKAGE: "Linkage";
+    readonly LIST: "List";
+    readonly LOCATION: "Location";
+    readonly MEASURE: "Measure";
+    readonly MEASUREREPORT: "MeasureReport";
+    readonly MEDIA: "Media";
+    readonly MEDICATION: "Medication";
+    readonly MEDICATIONADMINISTRATION: "MedicationAdministration";
+    readonly MEDICATIONDISPENSE: "MedicationDispense";
+    readonly MEDICATIONKNOWLEDGE: "MedicationKnowledge";
+    readonly MEDICATIONREQUEST: "MedicationRequest";
+    readonly MEDICATIONSTATEMENT: "MedicationStatement";
+    readonly MEDICINALPRODUCT: "MedicinalProduct";
+    readonly MEDICINALPRODUCTAUTHORIZATION: "MedicinalProductAuthorization";
+    readonly MEDICINALPRODUCTCONTRAINDICATION: "MedicinalProductContraindication";
+    readonly MEDICINALPRODUCTINDICATION: "MedicinalProductIndication";
+    readonly MEDICINALPRODUCTINGREDIENT: "MedicinalProductIngredient";
+    readonly MEDICINALPRODUCTINTERACTION: "MedicinalProductInteraction";
+    readonly MEDICINALPRODUCTMANUFACTURED: "MedicinalProductManufactured";
+    readonly MEDICINALPRODUCTPACKAGED: "MedicinalProductPackaged";
+    readonly MEDICINALPRODUCTPHARMACEUTICAL: "MedicinalProductPharmaceutical";
+    readonly MEDICINALPRODUCTUNDESIRABLEEFFECT: "MedicinalProductUndesirableEffect";
+    readonly MESSAGEDEFINITION: "MessageDefinition";
+    readonly MESSAGEHEADER: "MessageHeader";
+    readonly MOLECULARSEQUENCE: "MolecularSequence";
+    readonly NAMINGSYSTEM: "NamingSystem";
+    readonly NUTRITIONORDER: "NutritionOrder";
+    readonly OBSERVATION: "Observation";
+    readonly OBSERVATIONDEFINITION: "ObservationDefinition";
+    readonly OPERATIONDEFINITION: "OperationDefinition";
+    readonly OPERATIONOUTCOME: "OperationOutcome";
+    readonly ORGANIZATION: "Organization";
+    readonly ORGANIZATIONAFFILIATION: "OrganizationAffiliation";
+    readonly PARAMETERS: "Parameters";
+    readonly PATIENT: "Patient";
+    readonly PAYMENTNOTICE: "PaymentNotice";
+    readonly PAYMENTRECONCILIATION: "PaymentReconciliation";
+    readonly PERSON: "Person";
+    readonly PLANDEFINITION: "PlanDefinition";
+    readonly PRACTITIONER: "Practitioner";
+    readonly PRACTITIONERROLE: "PractitionerRole";
+    readonly PROCEDURE: "Procedure";
+    readonly PROVENANCE: "Provenance";
+    readonly QUESTIONNAIRE: "Questionnaire";
+    readonly QUESTIONNAIRERESPONSE: "QuestionnaireResponse";
+    readonly RELATEDPERSON: "RelatedPerson";
+    readonly REQUESTGROUP: "RequestGroup";
+    readonly RESEARCHDEFINITION: "ResearchDefinition";
+    readonly RESEARCHELEMENTDEFINITION: "ResearchElementDefinition";
+    readonly RESEARCHSTUDY: "ResearchStudy";
+    readonly RESEARCHSUBJECT: "ResearchSubject";
+    readonly RESOURCE: "Resource";
+    readonly RISKASSESSMENT: "RiskAssessment";
+    readonly RISKEVIDENCESYNTHESIS: "RiskEvidenceSynthesis";
+    readonly SCHEDULE: "Schedule";
+    readonly SEARCHPARAMETER: "SearchParameter";
+    readonly SERVICEREQUEST: "ServiceRequest";
+    readonly SLOT: "Slot";
+    readonly SPECIMEN: "Specimen";
+    readonly SPECIMENDEFINITION: "SpecimenDefinition";
+    readonly STRUCTUREDEFINITION: "StructureDefinition";
+    readonly STRUCTUREMAP: "StructureMap";
+    readonly SUBSCRIPTION: "Subscription";
+    readonly SUBSTANCE: "Substance";
+    readonly SUBSTANCENUCLEICACID: "SubstanceNucleicAcid";
+    readonly SUBSTANCEPOLYMER: "SubstancePolymer";
+    readonly SUBSTANCEPROTEIN: "SubstanceProtein";
+    readonly SUBSTANCEREFERENCEINFORMATION: "SubstanceReferenceInformation";
+    readonly SUBSTANCESOURCEMATERIAL: "SubstanceSourceMaterial";
+    readonly SUBSTANCESPECIFICATION: "SubstanceSpecification";
+    readonly SUPPLYDELIVERY: "SupplyDelivery";
+    readonly SUPPLYREQUEST: "SupplyRequest";
+    readonly TASK: "Task";
+    readonly TERMINOLOGYCAPABILITIES: "TerminologyCapabilities";
+    readonly TESTREPORT: "TestReport";
+    readonly TESTSCRIPT: "TestScript";
+    readonly VALUESET: "ValueSet";
+    readonly VERIFICATIONRESULT: "VerificationResult";
+    readonly VISIONPRESCRIPTION: "VisionPrescription";
+};
+export type AuditEventEntityType = (typeof AUDIT_EVENT_ENTITY_TYPE)[keyof typeof AUDIT_EVENT_ENTITY_TYPE];
+export declare const auditEventEntityTypeSchema: z.ZodEnum<["1", "2", "3", "4", "Account", "ActivityDefinition", "AdverseEvent", "AllergyIntolerance", "Appointment", "AppointmentResponse", "AuditEvent", "Basic", "Binary", "BiologicallyDerivedProduct", "BodyStructure", "Bundle", "CapabilityStatement", "CarePlan", "CareTeam", "CatalogEntry", "ChargeItem", "ChargeItemDefinition", "Claim", "ClaimResponse", "ClinicalImpression", "CodeSystem", "Communication", "CommunicationRequest", "CompartmentDefinition", "Composition", "ConceptMap", "Condition", "Consent", "Contract", "Coverage", "CoverageEligibilityRequest", "CoverageEligibilityResponse", "DetectedIssue", "Device", "DeviceDefinition", "DeviceMetric", "DeviceRequest", "DeviceUseStatement", "DiagnosticReport", "DocumentManifest", "DocumentReference", "DomainResource", "EffectEvidenceSynthesis", "Encounter", "Endpoint", "EnrollmentRequest", "EnrollmentResponse", "EpisodeOfCare", "EventDefinition", "Evidence", "EvidenceVariable", "ExampleScenario", "ExplanationOfBenefit", "FamilyMemberHistory", "Flag", "Goal", "GraphDefinition", "Group", "GuidanceResponse", "HealthcareService", "ImagingStudy", "Immunization", "ImmunizationEvaluation", "ImmunizationRecommendation", "ImplementationGuide", "InsurancePlan", "Invoice", "Library", "Linkage", "List", "Location", "Measure", "MeasureReport", "Media", "Medication", "MedicationAdministration", "MedicationDispense", "MedicationKnowledge", "MedicationRequest", "MedicationStatement", "MedicinalProduct", "MedicinalProductAuthorization", "MedicinalProductContraindication", "MedicinalProductIndication", "MedicinalProductIngredient", "MedicinalProductInteraction", "MedicinalProductManufactured", "MedicinalProductPackaged", "MedicinalProductPharmaceutical", "MedicinalProductUndesirableEffect", "MessageDefinition", "MessageHeader", "MolecularSequence", "NamingSystem", "NutritionOrder", "Observation", "ObservationDefinition", "OperationDefinition", "OperationOutcome", "Organization", "OrganizationAffiliation", "Parameters", "Patient", "PaymentNotice", "PaymentReconciliation", "Person", "PlanDefinition", "Practitioner", "PractitionerRole", "Procedure", "Provenance", "Questionnaire", "QuestionnaireResponse", "RelatedPerson", "RequestGroup", "ResearchDefinition", "ResearchElementDefinition", "ResearchStudy", "ResearchSubject", "Resource", "RiskAssessment", "RiskEvidenceSynthesis", "Schedule", "SearchParameter", "ServiceRequest", "Slot", "Specimen", "SpecimenDefinition", "StructureDefinition", "StructureMap", "Subscription", "Substance", "SubstanceNucleicAcid", "SubstancePolymer", "SubstanceProtein", "SubstanceReferenceInformation", "SubstanceSourceMaterial", "SubstanceSpecification", "SupplyDelivery", "SupplyRequest", "Task", "TerminologyCapabilities", "TestReport", "TestScript", "ValueSet", "VerificationResult", "VisionPrescription"]>;
+export declare const AUDIT_EVENT_I_D: {
+    readonly _110100: "110100";
+    readonly _110101: "110101";
+    readonly _110102: "110102";
+    readonly _110103: "110103";
+    readonly _110104: "110104";
+    readonly _110105: "110105";
+    readonly _110106: "110106";
+    readonly _110107: "110107";
+    readonly _110108: "110108";
+    readonly _110109: "110109";
+    readonly _110110: "110110";
+    readonly _110111: "110111";
+    readonly _110112: "110112";
+    readonly _110113: "110113";
+    readonly _110114: "110114";
+    readonly ACCESS: "access";
+    readonly AMEND: "amend";
+    readonly ARCHIVE: "archive";
+    readonly ATTEST: "attest";
+    readonly DECRYPT: "decrypt";
+    readonly DEIDENTIFY: "deidentify";
+    readonly DEPRECATE: "deprecate";
+    readonly DESTROY: "destroy";
+    readonly DISCLOSE: "disclose";
+    readonly ENCRYPT: "encrypt";
+    readonly EXTRACT: "extract";
+    readonly HOLD: "hold";
+    readonly LINK: "link";
+    readonly MERGE: "merge";
+    readonly ORIGINATE: "originate";
+    readonly PSEUDONYMIZE: "pseudonymize";
+    readonly REACTIVATE: "reactivate";
+    readonly RECEIVE: "receive";
+    readonly REIDENTIFY: "reidentify";
+    readonly REPORT: "report";
+    readonly REST: "rest";
+    readonly RESTORE: "restore";
+    readonly TRANSFORM: "transform";
+    readonly TRANSMIT: "transmit";
+    readonly UNHOLD: "unhold";
+    readonly UNLINK: "unlink";
+    readonly UNMERGE: "unmerge";
+    readonly VERIFY: "verify";
+};
+export type AuditEventID = (typeof AUDIT_EVENT_I_D)[keyof typeof AUDIT_EVENT_I_D];
+export declare const auditEventIDSchema: z.ZodEnum<["110100", "110101", "110102", "110103", "110104", "110105", "110106", "110107", "110108", "110109", "110110", "110111", "110112", "110113", "110114", "access", "amend", "archive", "attest", "decrypt", "deidentify", "deprecate", "destroy", "disclose", "encrypt", "extract", "hold", "link", "merge", "originate", "pseudonymize", "reactivate", "receive", "reidentify", "report", "rest", "restore", "transform", "transmit", "unhold", "unlink", "unmerge", "verify"]>;
+export declare const AUDIT_EVENT_OUTCOME: {
+    readonly _0: "0";
+    readonly _12: "12";
+    readonly _4: "4";
+    readonly _8: "8";
+};
+export type AuditEventOutcome = (typeof AUDIT_EVENT_OUTCOME)[keyof typeof AUDIT_EVENT_OUTCOME];
+export declare const auditEventOutcomeSchema: z.ZodEnum<["0", "12", "4", "8"]>;
+export declare const AUDIT_EVENT_SOURCE_TYPE: {
+    readonly _1: "1";
+    readonly _2: "2";
+    readonly _3: "3";
+    readonly _4: "4";
+    readonly _5: "5";
+    readonly _6: "6";
+    readonly _7: "7";
+    readonly _8: "8";
+    readonly _9: "9";
+};
+export type AuditEventSourceType = (typeof AUDIT_EVENT_SOURCE_TYPE)[keyof typeof AUDIT_EVENT_SOURCE_TYPE];
+export declare const auditEventSourceTypeSchema: z.ZodEnum<["1", "2", "3", "4", "5", "6", "7", "8", "9"]>;
+export declare const AUDIT_EVENT_SUB_TYPE: {
+    readonly _110120: "110120";
+    readonly _110121: "110121";
+    readonly _110122: "110122";
+    readonly _110123: "110123";
+    readonly _110124: "110124";
+    readonly _110125: "110125";
+    readonly _110126: "110126";
+    readonly _110127: "110127";
+    readonly _110128: "110128";
+    readonly _110129: "110129";
+    readonly _110130: "110130";
+    readonly _110131: "110131";
+    readonly _110132: "110132";
+    readonly _110133: "110133";
+    readonly _110134: "110134";
+    readonly _110135: "110135";
+    readonly _110136: "110136";
+    readonly _110137: "110137";
+    readonly _110138: "110138";
+    readonly _110139: "110139";
+    readonly _110140: "110140";
+    readonly _110141: "110141";
+    readonly _110142: "110142";
+    readonly BATCH: "batch";
+    readonly CAPABILITIES: "capabilities";
+    readonly CREATE: "create";
+    readonly DELETE: "delete";
+    readonly HISTORY: "history";
+    readonly HISTORY_INSTANCE: "history-instance";
+    readonly HISTORY_SYSTEM: "history-system";
+    readonly HISTORY_TYPE: "history-type";
+    readonly OPERATION: "operation";
+    readonly PATCH: "patch";
+    readonly READ: "read";
+    readonly SEARCH: "search";
+    readonly SEARCH_SYSTEM: "search-system";
+    readonly SEARCH_TYPE: "search-type";
+    readonly TRANSACTION: "transaction";
+    readonly UPDATE: "update";
+    readonly VREAD: "vread";
+};
+export type AuditEventSubType = (typeof AUDIT_EVENT_SUB_TYPE)[keyof typeof AUDIT_EVENT_SUB_TYPE];
+export declare const auditEventSubTypeSchema: z.ZodEnum<["110120", "110121", "110122", "110123", "110124", "110125", "110126", "110127", "110128", "110129", "110130", "110131", "110132", "110133", "110134", "110135", "110136", "110137", "110138", "110139", "110140", "110141", "110142", "batch", "capabilities", "create", "delete", "history", "history-instance", "history-system", "history-type", "operation", "patch", "read", "search", "search-system", "search-type", "transaction", "update", "vread"]>;
+export declare const BENEFIT_COST_APPLICABILITY: {
+    readonly IN_NETWORK: "in-network";
+    readonly OTHER: "other";
+    readonly OUT_OF_NETWORK: "out-of-network";
+};
+export type BenefitCostApplicability = (typeof BENEFIT_COST_APPLICABILITY)[keyof typeof BENEFIT_COST_APPLICABILITY];
+export declare const benefitCostApplicabilitySchema: z.ZodEnum<["in-network", "other", "out-of-network"]>;
+export declare const BINDING_STRENGTH: {
+    readonly EXAMPLE: "example";
+    readonly EXTENSIBLE: "extensible";
+    readonly PREFERRED: "preferred";
+    readonly REQUIRED: "required";
+};
+export type BindingStrength = (typeof BINDING_STRENGTH)[keyof typeof BINDING_STRENGTH];
+export declare const bindingStrengthSchema: z.ZodEnum<["example", "extensible", "preferred", "required"]>;
+export declare const BIOLOGICALLY_DERIVED_PRODUCT_CATEGORY: {
+    readonly BIOLOGICALAGENT: "biologicalAgent";
+    readonly CELLS: "cells";
+    readonly FLUID: "fluid";
+    readonly ORGAN: "organ";
+    readonly TISSUE: "tissue";
+};
+export type BiologicallyDerivedProductCategory = (typeof BIOLOGICALLY_DERIVED_PRODUCT_CATEGORY)[keyof typeof BIOLOGICALLY_DERIVED_PRODUCT_CATEGORY];
+export declare const biologicallyDerivedProductCategorySchema: z.ZodEnum<["biologicalAgent", "cells", "fluid", "organ", "tissue"]>;
+export declare const BIOLOGICALLY_DERIVED_PRODUCT_STATUS: {
+    readonly AVAILABLE: "available";
+    readonly UNAVAILABLE: "unavailable";
+};
+export type BiologicallyDerivedProductStatus = (typeof BIOLOGICALLY_DERIVED_PRODUCT_STATUS)[keyof typeof BIOLOGICALLY_DERIVED_PRODUCT_STATUS];
+export declare const biologicallyDerivedProductStatusSchema: z.ZodEnum<["available", "unavailable"]>;
+export declare const BIOLOGICALLY_DERIVED_PRODUCT_STORAGE_SCALE: {
+    readonly CELSIUS: "celsius";
+    readonly FARENHEIT: "farenheit";
+    readonly KELVIN: "kelvin";
+};
+export type BiologicallyDerivedProductStorageScale = (typeof BIOLOGICALLY_DERIVED_PRODUCT_STORAGE_SCALE)[keyof typeof BIOLOGICALLY_DERIVED_PRODUCT_STORAGE_SCALE];
+export declare const biologicallyDerivedProductStorageScaleSchema: z.ZodEnum<["celsius", "farenheit", "kelvin"]>;
+export declare const BUNDLE_TYPE: {
+    readonly BATCH: "batch";
+    readonly BATCH_RESPONSE: "batch-response";
+    readonly COLLECTION: "collection";
+    readonly DOCUMENT: "document";
+    readonly HISTORY: "history";
+    readonly MESSAGE: "message";
+    readonly SEARCHSET: "searchset";
+    readonly TRANSACTION: "transaction";
+    readonly TRANSACTION_RESPONSE: "transaction-response";
+};
+export type BundleType = (typeof BUNDLE_TYPE)[keyof typeof BUNDLE_TYPE];
+export declare const bundleTypeSchema: z.ZodEnum<["batch", "batch-response", "collection", "document", "history", "message", "searchset", "transaction", "transaction-response"]>;
+export declare const CANONICAL_STATUS_CODES_FOR_F_H_I_R_RESOURCES: {
+    readonly ABANDONED: "abandoned";
+    readonly ACCEPTED: "accepted";
+    readonly ACTIVE: "active";
+    readonly AHEAD_OF_TARGET: "ahead-of-target";
+    readonly ARRIVED: "arrived";
+    readonly BEHIND_TARGET: "behind-target";
+    readonly BUSY_UNAVAILABLE: "busy-unavailable";
+    readonly COMPLETE: "complete";
+    readonly CONFIRMED: "confirmed";
+    readonly DECLINED: "declined";
+    readonly DIFFERENTIAL: "differential";
+    readonly DRAFT: "draft";
     readonly ERROR: "error";
+    readonly FAILED: "failed";
+    readonly FREE: "free";
+    readonly HW_DISCON: "hw-discon";
+    readonly INACTIVE: "inactive";
+    readonly NOT_READY: "not-ready";
+    readonly ON_TARGET: "on-target";
+    readonly PARTIAL: "partial";
+    readonly PLANNED: "planned";
+    readonly PROPOSED: "proposed";
+    readonly RECEIVED: "received";
+    readonly REFUTED: "refuted";
+    readonly REPLACED: "replaced";
+    readonly REQUESTED: "requested";
+    readonly RESOLVED: "resolved";
+    readonly SUSPENDED: "suspended";
+    readonly TRANSDUC_DISCON: "transduc-discon";
+    readonly UNCONFIRMED: "unconfirmed";
+    readonly UNKNOWN: "unknown";
+};
+export type CanonicalStatusCodesForFHIRResources = (typeof CANONICAL_STATUS_CODES_FOR_F_H_I_R_RESOURCES)[keyof typeof CANONICAL_STATUS_CODES_FOR_F_H_I_R_RESOURCES];
+export declare const canonicalStatusCodesForFHIRResourcesSchema: z.ZodEnum<["abandoned", "accepted", "active", "ahead-of-target", "arrived", "behind-target", "busy-unavailable", "complete", "confirmed", "declined", "differential", "draft", "error", "failed", "free", "hw-discon", "inactive", "not-ready", "on-target", "partial", "planned", "proposed", "received", "refuted", "replaced", "requested", "resolved", "suspended", "transduc-discon", "unconfirmed", "unknown"]>;
+export declare const CAPABILITY_STATEMENT_KIND: {
+    readonly CAPABILITY: "capability";
+    readonly INSTANCE: "instance";
+    readonly REQUIREMENTS: "requirements";
 };
-export type TestReportResultDetail = (typeof TESTREPORT_RESULT_DETAIL)[keyof typeof TESTREPORT_RESULT_DETAIL];
-/** Device status: active | inactive | entered-in-error | unknown */
-export declare const DEVICE_STATUS: {
+export type CapabilityStatementKind = (typeof CAPABILITY_STATEMENT_KIND)[keyof typeof CAPABILITY_STATEMENT_KIND];
+export declare const capabilityStatementKindSchema: z.ZodEnum<["capability", "instance", "requirements"]>;
+export declare const CARE_PLAN_ACTIVITY_KIND: {
+    readonly APPOINTMENT: "Appointment";
+    readonly COMMUNICATIONREQUEST: "CommunicationRequest";
+    readonly DEVICEREQUEST: "DeviceRequest";
+    readonly MEDICATIONREQUEST: "MedicationRequest";
+    readonly NUTRITIONORDER: "NutritionOrder";
+    readonly SERVICEREQUEST: "ServiceRequest";
+    readonly TASK: "Task";
+    readonly VISIONPRESCRIPTION: "VisionPrescription";
+};
+export type CarePlanActivityKind = (typeof CARE_PLAN_ACTIVITY_KIND)[keyof typeof CARE_PLAN_ACTIVITY_KIND];
+export declare const carePlanActivityKindSchema: z.ZodEnum<["Appointment", "CommunicationRequest", "DeviceRequest", "MedicationRequest", "NutritionOrder", "ServiceRequest", "Task", "VisionPrescription"]>;
+export declare const CARE_PLAN_ACTIVITY_STATUS: {
+    readonly CANCELLED: "cancelled";
+    readonly COMPLETED: "completed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly IN_PROGRESS: "in-progress";
+    readonly NOT_STARTED: "not-started";
+    readonly ON_HOLD: "on-hold";
+    readonly SCHEDULED: "scheduled";
+    readonly STOPPED: "stopped";
+    readonly UNKNOWN: "unknown";
+};
+export type CarePlanActivityStatus = (typeof CARE_PLAN_ACTIVITY_STATUS)[keyof typeof CARE_PLAN_ACTIVITY_STATUS];
+export declare const carePlanActivityStatusSchema: z.ZodEnum<["cancelled", "completed", "entered-in-error", "in-progress", "not-started", "on-hold", "scheduled", "stopped", "unknown"]>;
+export declare const CARE_PLAN_INTENT: {
+    readonly OPTION: "option";
+    readonly ORDER: "order";
+    readonly PLAN: "plan";
+    readonly PROPOSAL: "proposal";
+};
+export type CarePlanIntent = (typeof CARE_PLAN_INTENT)[keyof typeof CARE_PLAN_INTENT];
+export declare const carePlanIntentSchema: z.ZodEnum<["option", "order", "plan", "proposal"]>;
+export declare const CARE_TEAM_STATUS: {
     readonly ACTIVE: "active";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
     readonly INACTIVE: "inactive";
+    readonly PROPOSED: "proposed";
+    readonly SUSPENDED: "suspended";
+};
+export type CareTeamStatus = (typeof CARE_TEAM_STATUS)[keyof typeof CARE_TEAM_STATUS];
+export declare const careTeamStatusSchema: z.ZodEnum<["active", "entered-in-error", "inactive", "proposed", "suspended"]>;
+export declare const CATALOG_ENTRY_RELATION_TYPE: {
+    readonly IS_REPLACED_BY: "is-replaced-by";
+    readonly TRIGGERS: "triggers";
+};
+export type CatalogEntryRelationType = (typeof CATALOG_ENTRY_RELATION_TYPE)[keyof typeof CATALOG_ENTRY_RELATION_TYPE];
+export declare const catalogEntryRelationTypeSchema: z.ZodEnum<["is-replaced-by", "triggers"]>;
+export declare const CERTAINTY_SUBCOMPONENT_RATING: {
+    readonly ABSENT: "absent";
+    readonly CRITICAL_CONCERN: "critical-concern";
+    readonly DOWNCODE1: "downcode1";
+    readonly DOWNCODE2: "downcode2";
+    readonly DOWNCODE3: "downcode3";
+    readonly NO_CHANGE: "no-change";
+    readonly NO_CONCERN: "no-concern";
+    readonly PRESENT: "present";
+    readonly SERIOUS_CONCERN: "serious-concern";
+    readonly UPCODE1: "upcode1";
+    readonly UPCODE2: "upcode2";
+};
+export type CertaintySubcomponentRating = (typeof CERTAINTY_SUBCOMPONENT_RATING)[keyof typeof CERTAINTY_SUBCOMPONENT_RATING];
+export declare const certaintySubcomponentRatingSchema: z.ZodEnum<["absent", "critical-concern", "downcode1", "downcode2", "downcode3", "no-change", "no-concern", "present", "serious-concern", "upcode1", "upcode2"]>;
+export declare const CERTAINTY_SUBCOMPONENT_TYPE: {
+    readonly DOSERESPONSEGRADIENT: "DoseResponseGradient";
+    readonly IMPRECISION: "Imprecision";
+    readonly INCONSISTENCY: "Inconsistency";
+    readonly INDIRECTNESS: "Indirectness";
+    readonly LARGEEFFECT: "LargeEffect";
+    readonly PLAUSIBLECONFOUNDING: "PlausibleConfounding";
+    readonly PUBLICATIONBIAS: "PublicationBias";
+    readonly RISKOFBIAS: "RiskOfBias";
+};
+export type CertaintySubcomponentType = (typeof CERTAINTY_SUBCOMPONENT_TYPE)[keyof typeof CERTAINTY_SUBCOMPONENT_TYPE];
+export declare const certaintySubcomponentTypeSchema: z.ZodEnum<["DoseResponseGradient", "Imprecision", "Inconsistency", "Indirectness", "LargeEffect", "PlausibleConfounding", "PublicationBias", "RiskOfBias"]>;
+export declare const CHARGE_ITEM_STATUS: {
+    readonly ABORTED: "aborted";
+    readonly BILLABLE: "billable";
+    readonly BILLED: "billed";
     readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly NOT_BILLABLE: "not-billable";
+    readonly PLANNED: "planned";
     readonly UNKNOWN: "unknown";
 };
-export type DeviceStatus = (typeof DEVICE_STATUS)[keyof typeof DEVICE_STATUS];
-/** UCUM time units: s | min | h | d | wk | mo | a */
-export declare const UCUM_UNITS: {
-    readonly SECOND: "s";
-    readonly MINUTE: "min";
-    readonly HOUR: "h";
-    readonly DAY: "d";
-    readonly WEEK: "wk";
-    readonly MONTH: "mo";
-    readonly YEAR: "a";
-};
-export type UcumUnits = (typeof UCUM_UNITS)[keyof typeof UCUM_UNITS];
-/** ImagingStudy/Series availability: ONLINE | OFFLINE | NEARLINE | UNAVAILABLE */
-export declare const IMAGING_STUDY_AVAILABILITY: {
-    readonly ONLINE: "ONLINE";
-    readonly OFFLINE: "OFFLINE";
-    readonly NEARLINE: "NEARLINE";
-    readonly UNAVAILABLE: "UNAVAILABLE";
-};
-export type ImagingStudyAvailability = (typeof IMAGING_STUDY_AVAILABILITY)[keyof typeof IMAGING_STUDY_AVAILABILITY];
-/** ImagingStudy status: registered | available | cancelled | entered-in-error | unknown (required). */
-export declare const IMAGING_STUDY_STATUS: {
+export type ChargeItemStatus = (typeof CHARGE_ITEM_STATUS)[keyof typeof CHARGE_ITEM_STATUS];
+export declare const chargeItemStatusSchema: z.ZodEnum<["aborted", "billable", "billed", "entered-in-error", "not-billable", "planned", "unknown"]>;
+export declare const CLAIM_PROCESSING_CODES: {
+    readonly COMPLETE: "complete";
+    readonly ERROR: "error";
+    readonly PARTIAL: "partial";
+    readonly QUEUED: "queued";
+};
+export type ClaimProcessingCodes = (typeof CLAIM_PROCESSING_CODES)[keyof typeof CLAIM_PROCESSING_CODES];
+export declare const claimProcessingCodesSchema: z.ZodEnum<["complete", "error", "partial", "queued"]>;
+export declare const CLAIM_TYPE_CODES: {
+    readonly INSTITUTIONAL: "institutional";
+    readonly ORAL: "oral";
+    readonly PHARMACY: "pharmacy";
+    readonly PROFESSIONAL: "professional";
+    readonly VISION: "vision";
+};
+export type ClaimTypeCodes = (typeof CLAIM_TYPE_CODES)[keyof typeof CLAIM_TYPE_CODES];
+export declare const claimTypeCodesSchema: z.ZodEnum<["institutional", "oral", "pharmacy", "professional", "vision"]>;
+export declare const CLINICAL_IMPRESSION_STATUS: {
+    readonly COMPLETED: "completed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly IN_PROGRESS: "in-progress";
+};
+export type ClinicalImpressionStatus = (typeof CLINICAL_IMPRESSION_STATUS)[keyof typeof CLINICAL_IMPRESSION_STATUS];
+export declare const clinicalImpressionStatusSchema: z.ZodEnum<["completed", "entered-in-error", "in-progress"]>;
+export declare const CODE_SEARCH_SUPPORT: {
+    readonly ALL: "all";
+    readonly EXPLICIT: "explicit";
+};
+export type CodeSearchSupport = (typeof CODE_SEARCH_SUPPORT)[keyof typeof CODE_SEARCH_SUPPORT];
+export declare const codeSearchSupportSchema: z.ZodEnum<["all", "explicit"]>;
+export declare const CODE_SYSTEM_CONTENT_MODE: {
+    readonly COMPLETE: "complete";
+    readonly EXAMPLE: "example";
+    readonly FRAGMENT: "fragment";
+    readonly NOT_PRESENT: "not-present";
+    readonly SUPPLEMENT: "supplement";
+};
+export type CodeSystemContentMode = (typeof CODE_SYSTEM_CONTENT_MODE)[keyof typeof CODE_SYSTEM_CONTENT_MODE];
+export declare const codeSystemContentModeSchema: z.ZodEnum<["complete", "example", "fragment", "not-present", "supplement"]>;
+export declare const CODE_SYSTEM_HIERARCHY_MEANING: {
+    readonly CLASSIFIED_WITH: "classified-with";
+    readonly GROUPED_BY: "grouped-by";
+    readonly IS_A: "is-a";
+    readonly PART_OF: "part-of";
+};
+export type CodeSystemHierarchyMeaning = (typeof CODE_SYSTEM_HIERARCHY_MEANING)[keyof typeof CODE_SYSTEM_HIERARCHY_MEANING];
+export declare const codeSystemHierarchyMeaningSchema: z.ZodEnum<["classified-with", "grouped-by", "is-a", "part-of"]>;
+export declare const COMPARTMENT_TYPE: {
+    readonly DEVICE: "Device";
+    readonly ENCOUNTER: "Encounter";
+    readonly PATIENT: "Patient";
+    readonly PRACTITIONER: "Practitioner";
+    readonly RELATEDPERSON: "RelatedPerson";
+};
+export type CompartmentType = (typeof COMPARTMENT_TYPE)[keyof typeof COMPARTMENT_TYPE];
+export declare const compartmentTypeSchema: z.ZodEnum<["Device", "Encounter", "Patient", "Practitioner", "RelatedPerson"]>;
+export declare const COMPOSITE_MEASURE_SCORING: {
+    readonly ALL_OR_NOTHING: "all-or-nothing";
+    readonly LINEAR: "linear";
+    readonly OPPORTUNITY: "opportunity";
+    readonly WEIGHTED: "weighted";
+};
+export type CompositeMeasureScoring = (typeof COMPOSITE_MEASURE_SCORING)[keyof typeof COMPOSITE_MEASURE_SCORING];
+export declare const compositeMeasureScoringSchema: z.ZodEnum<["all-or-nothing", "linear", "opportunity", "weighted"]>;
+export declare const COMPOSITION_ATTESTATION_MODE: {
+    readonly LEGAL: "legal";
+    readonly OFFICIAL: "official";
+    readonly PERSONAL: "personal";
+    readonly PROFESSIONAL: "professional";
+};
+export type CompositionAttestationMode = (typeof COMPOSITION_ATTESTATION_MODE)[keyof typeof COMPOSITION_ATTESTATION_MODE];
+export declare const compositionAttestationModeSchema: z.ZodEnum<["legal", "official", "personal", "professional"]>;
+export declare const COMPOSITION_STATUS: {
+    readonly AMENDED: "amended";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly FINAL: "final";
+    readonly PRELIMINARY: "preliminary";
+};
+export type CompositionStatus = (typeof COMPOSITION_STATUS)[keyof typeof COMPOSITION_STATUS];
+export declare const compositionStatusSchema: z.ZodEnum<["amended", "entered-in-error", "final", "preliminary"]>;
+export declare const CONCEPT_MAP_EQUIVALENCE: {
+    readonly DISJOINT: "disjoint";
+    readonly EQUAL: "equal";
+    readonly EQUIVALENT: "equivalent";
+    readonly INEXACT: "inexact";
+    readonly NARROWER: "narrower";
+    readonly RELATEDTO: "relatedto";
+    readonly SPECIALIZES: "specializes";
+    readonly SUBSUMES: "subsumes";
+    readonly UNMATCHED: "unmatched";
+    readonly WIDER: "wider";
+};
+export type ConceptMapEquivalence = (typeof CONCEPT_MAP_EQUIVALENCE)[keyof typeof CONCEPT_MAP_EQUIVALENCE];
+export declare const conceptMapEquivalenceSchema: z.ZodEnum<["disjoint", "equal", "equivalent", "inexact", "narrower", "relatedto", "specializes", "subsumes", "unmatched", "wider"]>;
+export declare const CONCEPT_MAP_GROUP_UNMAPPED_MODE: {
+    readonly FIXED: "fixed";
+    readonly OTHER_MAP: "other-map";
+    readonly PROVIDED: "provided";
+};
+export type ConceptMapGroupUnmappedMode = (typeof CONCEPT_MAP_GROUP_UNMAPPED_MODE)[keyof typeof CONCEPT_MAP_GROUP_UNMAPPED_MODE];
+export declare const conceptMapGroupUnmappedModeSchema: z.ZodEnum<["fixed", "other-map", "provided"]>;
+export declare const CONDITION_CATEGORY_CODES: {
+    readonly ENCOUNTER_DIAGNOSIS: "encounter-diagnosis";
+    readonly PROBLEM_LIST_ITEM: "problem-list-item";
+};
+export type ConditionCategoryCodes = (typeof CONDITION_CATEGORY_CODES)[keyof typeof CONDITION_CATEGORY_CODES];
+export declare const conditionCategoryCodesSchema: z.ZodEnum<["encounter-diagnosis", "problem-list-item"]>;
+export declare const CONDITION_CLINICAL_STATUS_CODES: {
+    readonly ACTIVE: "active";
+    readonly INACTIVE: "inactive";
+    readonly RECURRENCE: "recurrence";
+    readonly RELAPSE: "relapse";
+    readonly REMISSION: "remission";
+    readonly RESOLVED: "resolved";
+};
+export type ConditionClinicalStatusCodes = (typeof CONDITION_CLINICAL_STATUS_CODES)[keyof typeof CONDITION_CLINICAL_STATUS_CODES];
+export declare const conditionClinicalStatusCodesSchema: z.ZodEnum<["active", "inactive", "recurrence", "relapse", "remission", "resolved"]>;
+export declare const CONDITION_VERIFICATION_STATUS: {
+    readonly CONFIRMED: "confirmed";
+    readonly DIFFERENTIAL: "differential";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly PROVISIONAL: "provisional";
+    readonly REFUTED: "refuted";
+    readonly UNCONFIRMED: "unconfirmed";
+};
+export type ConditionVerificationStatus = (typeof CONDITION_VERIFICATION_STATUS)[keyof typeof CONDITION_VERIFICATION_STATUS];
+export declare const conditionVerificationStatusSchema: z.ZodEnum<["confirmed", "differential", "entered-in-error", "provisional", "refuted", "unconfirmed"]>;
+export declare const CONDITIONAL_DELETE_STATUS: {
+    readonly MULTIPLE: "multiple";
+    readonly NOT_SUPPORTED: "not-supported";
+    readonly SINGLE: "single";
+};
+export type ConditionalDeleteStatus = (typeof CONDITIONAL_DELETE_STATUS)[keyof typeof CONDITIONAL_DELETE_STATUS];
+export declare const conditionalDeleteStatusSchema: z.ZodEnum<["multiple", "not-supported", "single"]>;
+export declare const CONDITIONAL_READ_STATUS: {
+    readonly FULL_SUPPORT: "full-support";
+    readonly MODIFIED_SINCE: "modified-since";
+    readonly NOT_MATCH: "not-match";
+    readonly NOT_SUPPORTED: "not-supported";
+};
+export type ConditionalReadStatus = (typeof CONDITIONAL_READ_STATUS)[keyof typeof CONDITIONAL_READ_STATUS];
+export declare const conditionalReadStatusSchema: z.ZodEnum<["full-support", "modified-since", "not-match", "not-supported"]>;
+export declare const CONSENT_DATA_MEANING: {
+    readonly AUTHOREDBY: "authoredby";
+    readonly DEPENDENTS: "dependents";
+    readonly INSTANCE: "instance";
+    readonly RELATED: "related";
+};
+export type ConsentDataMeaning = (typeof CONSENT_DATA_MEANING)[keyof typeof CONSENT_DATA_MEANING];
+export declare const consentDataMeaningSchema: z.ZodEnum<["authoredby", "dependents", "instance", "related"]>;
+export declare const CONSENT_POLICY_RULE_CODES: {
+    readonly AT_ELGA: "at-elga";
+    readonly CRIC: "cric";
+    readonly DCH_3927: "dch-3927";
+    readonly GA4GH: "ga4gh";
+    readonly HIPAA_AUTH: "hipaa-auth";
+    readonly HIPAA_NPP: "hipaa-npp";
+    readonly HIPAA_RESEARCH: "hipaa-research";
+    readonly HIPAA_RESTRICTIONS: "hipaa-restrictions";
+    readonly HIPAA_SELF_PAY: "hipaa-self-pay";
+    readonly ILLINOIS_MINOR_PROCEDURE: "illinois-minor-procedure";
+    readonly MDHHS_5515: "mdhhs-5515";
+    readonly NCI: "nci";
+    readonly NIH_527: "nih-527";
+    readonly NIH_GRDR: "nih-grdr";
+    readonly NIH_HIPAA: "nih-hipaa";
+    readonly NL_LSP: "nl-lsp";
+    readonly NYSSIPP: "nyssipp";
+    readonly SQUAXIN: "squaxin";
+    readonly SSA_827: "ssa-827";
+    readonly VA_10_0484: "va-10-0484";
+    readonly VA_10_0485: "va-10-0485";
+    readonly VA_10_10116: "va-10-10116";
+    readonly VA_10_5345: "va-10-5345";
+    readonly VA_10_5345A: "va-10-5345a";
+    readonly VA_10_5345A_MHV: "va-10-5345a-mhv";
+    readonly VA_21_4142: "va-21-4142";
+};
+export type ConsentPolicyRuleCodes = (typeof CONSENT_POLICY_RULE_CODES)[keyof typeof CONSENT_POLICY_RULE_CODES];
+export declare const consentPolicyRuleCodesSchema: z.ZodEnum<["at-elga", "cric", "dch-3927", "ga4gh", "hipaa-auth", "hipaa-npp", "hipaa-research", "hipaa-restrictions", "hipaa-self-pay", "illinois-minor-procedure", "mdhhs-5515", "nci", "nih-527", "nih-grdr", "nih-hipaa", "nl-lsp", "nyssipp", "squaxin", "ssa-827", "va-10-0484", "va-10-0485", "va-10-10116", "va-10-5345", "va-10-5345a", "va-10-5345a-mhv", "va-21-4142"]>;
+export declare const CONSENT_PROVISION_TYPE: {
+    readonly DENY: "deny";
+    readonly PERMIT: "permit";
+};
+export type ConsentProvisionType = (typeof CONSENT_PROVISION_TYPE)[keyof typeof CONSENT_PROVISION_TYPE];
+export declare const consentProvisionTypeSchema: z.ZodEnum<["deny", "permit"]>;
+export declare const CONSENT_SCOPE_CODES: {
+    readonly ADR: "adr";
+    readonly PATIENT_PRIVACY: "patient-privacy";
+    readonly RESEARCH: "research";
+    readonly TREATMENT: "treatment";
+};
+export type ConsentScopeCodes = (typeof CONSENT_SCOPE_CODES)[keyof typeof CONSENT_SCOPE_CODES];
+export declare const consentScopeCodesSchema: z.ZodEnum<["adr", "patient-privacy", "research", "treatment"]>;
+export declare const CONSENT_STATE: {
+    readonly ACTIVE: "active";
+    readonly DRAFT: "draft";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly INACTIVE: "inactive";
+    readonly PROPOSED: "proposed";
+    readonly REJECTED: "rejected";
+};
+export type ConsentState = (typeof CONSENT_STATE)[keyof typeof CONSENT_STATE];
+export declare const consentStateSchema: z.ZodEnum<["active", "draft", "entered-in-error", "inactive", "proposed", "rejected"]>;
+export declare const CONSTRAINT_SEVERITY: {
+    readonly ERROR: "error";
+    readonly WARNING: "warning";
+};
+export type ConstraintSeverity = (typeof CONSTRAINT_SEVERITY)[keyof typeof CONSTRAINT_SEVERITY];
+export declare const constraintSeveritySchema: z.ZodEnum<["error", "warning"]>;
+export declare const CONTACT_ENTITY_TYPE: {
+    readonly ADMIN: "ADMIN";
+    readonly BILL: "BILL";
+    readonly HR: "HR";
+    readonly PATINF: "PATINF";
+    readonly PAYOR: "PAYOR";
+    readonly PRESS: "PRESS";
+};
+export type ContactEntityType = (typeof CONTACT_ENTITY_TYPE)[keyof typeof CONTACT_ENTITY_TYPE];
+export declare const contactEntityTypeSchema: z.ZodEnum<["ADMIN", "BILL", "HR", "PATINF", "PAYOR", "PRESS"]>;
+export declare const CONTACT_POINT_SYSTEM: {
+    readonly EMAIL: "email";
+    readonly FAX: "fax";
+    readonly OTHER: "other";
+    readonly PAGER: "pager";
+    readonly PHONE: "phone";
+    readonly SMS: "sms";
+    readonly URL: "url";
+};
+export type ContactPointSystem = (typeof CONTACT_POINT_SYSTEM)[keyof typeof CONTACT_POINT_SYSTEM];
+export declare const contactPointSystemSchema: z.ZodEnum<["email", "fax", "other", "pager", "phone", "sms", "url"]>;
+export declare const CONTACT_POINT_USE: {
+    readonly HOME: "home";
+    readonly MOBILE: "mobile";
+    readonly OLD: "old";
+    readonly TEMP: "temp";
+    readonly WORK: "work";
+};
+export type ContactPointUse = (typeof CONTACT_POINT_USE)[keyof typeof CONTACT_POINT_USE];
+export declare const contactPointUseSchema: z.ZodEnum<["home", "mobile", "old", "temp", "work"]>;
+export declare const CONTRACT_RESOURCE_LEGAL_STATE_CODES: {
+    readonly AMENDED: "amended";
+    readonly APPENDED: "appended";
+    readonly CANCELLED: "cancelled";
+    readonly DISPUTED: "disputed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly EXECUTABLE: "executable";
+    readonly EXECUTED: "executed";
+    readonly NEGOTIABLE: "negotiable";
+    readonly OFFERED: "offered";
+    readonly POLICY: "policy";
+    readonly REJECTED: "rejected";
+    readonly RENEWED: "renewed";
+    readonly RESOLVED: "resolved";
+    readonly REVOKED: "revoked";
+    readonly TERMINATED: "terminated";
+};
+export type ContractResourceLegalStateCodes = (typeof CONTRACT_RESOURCE_LEGAL_STATE_CODES)[keyof typeof CONTRACT_RESOURCE_LEGAL_STATE_CODES];
+export declare const contractResourceLegalStateCodesSchema: z.ZodEnum<["amended", "appended", "cancelled", "disputed", "entered-in-error", "executable", "executed", "negotiable", "offered", "policy", "rejected", "renewed", "resolved", "revoked", "terminated"]>;
+export declare const CONTRACT_RESOURCE_PUBLICATION_STATUS_CODES: {
+    readonly AMENDED: "amended";
+    readonly APPENDED: "appended";
+    readonly CANCELLED: "cancelled";
+    readonly DISPUTED: "disputed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly EXECUTABLE: "executable";
+    readonly EXECUTED: "executed";
+    readonly NEGOTIABLE: "negotiable";
+    readonly OFFERED: "offered";
+    readonly POLICY: "policy";
+    readonly REJECTED: "rejected";
+    readonly RENEWED: "renewed";
+    readonly RESOLVED: "resolved";
+    readonly REVOKED: "revoked";
+    readonly TERMINATED: "terminated";
+};
+export type ContractResourcePublicationStatusCodes = (typeof CONTRACT_RESOURCE_PUBLICATION_STATUS_CODES)[keyof typeof CONTRACT_RESOURCE_PUBLICATION_STATUS_CODES];
+export declare const contractResourcePublicationStatusCodesSchema: z.ZodEnum<["amended", "appended", "cancelled", "disputed", "entered-in-error", "executable", "executed", "negotiable", "offered", "policy", "rejected", "renewed", "resolved", "revoked", "terminated"]>;
+export declare const CONTRACT_RESOURCE_STATUS_CODES: {
+    readonly AMENDED: "amended";
+    readonly APPENDED: "appended";
+    readonly CANCELLED: "cancelled";
+    readonly DISPUTED: "disputed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly EXECUTABLE: "executable";
+    readonly EXECUTED: "executed";
+    readonly NEGOTIABLE: "negotiable";
+    readonly OFFERED: "offered";
+    readonly POLICY: "policy";
+    readonly REJECTED: "rejected";
+    readonly RENEWED: "renewed";
+    readonly RESOLVED: "resolved";
+    readonly REVOKED: "revoked";
+    readonly TERMINATED: "terminated";
+};
+export type ContractResourceStatusCodes = (typeof CONTRACT_RESOURCE_STATUS_CODES)[keyof typeof CONTRACT_RESOURCE_STATUS_CODES];
+export declare const contractResourceStatusCodesSchema: z.ZodEnum<["amended", "appended", "cancelled", "disputed", "entered-in-error", "executable", "executed", "negotiable", "offered", "policy", "rejected", "renewed", "resolved", "revoked", "terminated"]>;
+export declare const CONTRIBUTOR_TYPE: {
+    readonly AUTHOR: "author";
+    readonly EDITOR: "editor";
+    readonly ENDORSER: "endorser";
+    readonly REVIEWER: "reviewer";
+};
+export type ContributorType = (typeof CONTRIBUTOR_TYPE)[keyof typeof CONTRIBUTOR_TYPE];
+export declare const contributorTypeSchema: z.ZodEnum<["author", "editor", "endorser", "reviewer"]>;
+export declare const COVERAGE_CLASS_CODES: {
+    readonly CLASS: "class";
+    readonly GROUP: "group";
+    readonly PLAN: "plan";
+    readonly RXBIN: "rxbin";
+    readonly RXGROUP: "rxgroup";
+    readonly RXID: "rxid";
+    readonly RXPCN: "rxpcn";
+    readonly SEQUENCE: "sequence";
+    readonly SUBCLASS: "subclass";
+    readonly SUBGROUP: "subgroup";
+    readonly SUBPLAN: "subplan";
+};
+export type CoverageClassCodes = (typeof COVERAGE_CLASS_CODES)[keyof typeof COVERAGE_CLASS_CODES];
+export declare const coverageClassCodesSchema: z.ZodEnum<["class", "group", "plan", "rxbin", "rxgroup", "rxid", "rxpcn", "sequence", "subclass", "subgroup", "subplan"]>;
+export declare const COVERAGE_COPAY_TYPE_CODES: {
+    readonly COPAY: "copay";
+    readonly COPAYPCT: "copaypct";
+    readonly DEDUCTIBLE: "deductible";
+    readonly EMERGENCY: "emergency";
+    readonly GPVISIT: "gpvisit";
+    readonly INPTHOSP: "inpthosp";
+    readonly MAXOUTOFPOCKET: "maxoutofpocket";
+    readonly SPVISIT: "spvisit";
+    readonly TELEVISIT: "televisit";
+    readonly URGENTCARE: "urgentcare";
+};
+export type CoverageCopayTypeCodes = (typeof COVERAGE_COPAY_TYPE_CODES)[keyof typeof COVERAGE_COPAY_TYPE_CODES];
+export declare const coverageCopayTypeCodesSchema: z.ZodEnum<["copay", "copaypct", "deductible", "emergency", "gpvisit", "inpthosp", "maxoutofpocket", "spvisit", "televisit", "urgentcare"]>;
+export declare const DATA_ABSENT_REASON: {
+    readonly AS_TEXT: "as-text";
+    readonly ASKED_DECLINED: "asked-declined";
+    readonly ASKED_UNKNOWN: "asked-unknown";
+    readonly ERROR: "error";
+    readonly MASKED: "masked";
+    readonly NEGATIVE_INFINITY: "negative-infinity";
+    readonly NOT_A_NUMBER: "not-a-number";
+    readonly NOT_APPLICABLE: "not-applicable";
+    readonly NOT_ASKED: "not-asked";
+    readonly NOT_PERFORMED: "not-performed";
+    readonly NOT_PERMITTED: "not-permitted";
+    readonly POSITIVE_INFINITY: "positive-infinity";
+    readonly TEMP_UNKNOWN: "temp-unknown";
+    readonly UNKNOWN: "unknown";
+    readonly UNSUPPORTED: "unsupported";
+};
+export type DataAbsentReason = (typeof DATA_ABSENT_REASON)[keyof typeof DATA_ABSENT_REASON];
+export declare const dataAbsentReasonSchema: z.ZodEnum<["as-text", "asked-declined", "asked-unknown", "error", "masked", "negative-infinity", "not-a-number", "not-applicable", "not-asked", "not-performed", "not-permitted", "positive-infinity", "temp-unknown", "unknown", "unsupported"]>;
+export declare const DAYS_OF_WEEK: {
+    readonly FRI: "fri";
+    readonly MON: "mon";
+    readonly SAT: "sat";
+    readonly SUN: "sun";
+    readonly THU: "thu";
+    readonly TUE: "tue";
+    readonly WED: "wed";
+};
+export type DaysOfWeek = (typeof DAYS_OF_WEEK)[keyof typeof DAYS_OF_WEEK];
+export declare const daysOfWeekSchema: z.ZodEnum<["fri", "mon", "sat", "sun", "thu", "tue", "wed"]>;
+export declare const DEFINITION_USE_CODES: {
+    readonly ARCHETYPE: "archetype";
+    readonly CUSTOM_RESOURCE: "custom-resource";
+    readonly DAM: "dam";
+    readonly FHIR_STRUCTURE: "fhir-structure";
+    readonly TEMPLATE: "template";
+    readonly WIRE_FORMAT: "wire-format";
+};
+export type DefinitionUseCodes = (typeof DEFINITION_USE_CODES)[keyof typeof DEFINITION_USE_CODES];
+export declare const definitionUseCodesSchema: z.ZodEnum<["archetype", "custom-resource", "dam", "fhir-structure", "template", "wire-format"]>;
+export declare const DESIGNATION_USE: {
+    readonly _900000000000003001: "900000000000003001";
+    readonly _900000000000013009: "900000000000013009";
+};
+export type DesignationUse = (typeof DESIGNATION_USE)[keyof typeof DESIGNATION_USE];
+export declare const designationUseSchema: z.ZodEnum<["900000000000003001", "900000000000013009"]>;
+export declare const DETECTED_ISSUE_SEVERITY: {
+    readonly HIGH: "high";
+    readonly LOW: "low";
+    readonly MODERATE: "moderate";
+};
+export type DetectedIssueSeverity = (typeof DETECTED_ISSUE_SEVERITY)[keyof typeof DETECTED_ISSUE_SEVERITY];
+export declare const detectedIssueSeveritySchema: z.ZodEnum<["high", "low", "moderate"]>;
+export declare const DEVICE_METRIC_CALIBRATION_STATE: {
+    readonly CALIBRATED: "calibrated";
+    readonly CALIBRATION_REQUIRED: "calibration-required";
+    readonly NOT_CALIBRATED: "not-calibrated";
+    readonly UNSPECIFIED: "unspecified";
+};
+export type DeviceMetricCalibrationState = (typeof DEVICE_METRIC_CALIBRATION_STATE)[keyof typeof DEVICE_METRIC_CALIBRATION_STATE];
+export declare const deviceMetricCalibrationStateSchema: z.ZodEnum<["calibrated", "calibration-required", "not-calibrated", "unspecified"]>;
+export declare const DEVICE_METRIC_CALIBRATION_TYPE: {
+    readonly GAIN: "gain";
+    readonly OFFSET: "offset";
+    readonly TWO_POINT: "two-point";
+    readonly UNSPECIFIED: "unspecified";
+};
+export type DeviceMetricCalibrationType = (typeof DEVICE_METRIC_CALIBRATION_TYPE)[keyof typeof DEVICE_METRIC_CALIBRATION_TYPE];
+export declare const deviceMetricCalibrationTypeSchema: z.ZodEnum<["gain", "offset", "two-point", "unspecified"]>;
+export declare const DEVICE_METRIC_CATEGORY: {
+    readonly CALCULATION: "calculation";
+    readonly MEASUREMENT: "measurement";
+    readonly SETTING: "setting";
+    readonly UNSPECIFIED: "unspecified";
+};
+export type DeviceMetricCategory = (typeof DEVICE_METRIC_CATEGORY)[keyof typeof DEVICE_METRIC_CATEGORY];
+export declare const deviceMetricCategorySchema: z.ZodEnum<["calculation", "measurement", "setting", "unspecified"]>;
+export declare const DEVICE_METRIC_COLOR: {
+    readonly BLACK: "black";
+    readonly BLUE: "blue";
+    readonly CYAN: "cyan";
+    readonly GREEN: "green";
+    readonly MAGENTA: "magenta";
+    readonly RED: "red";
+    readonly WHITE: "white";
+    readonly YELLOW: "yellow";
+};
+export type DeviceMetricColor = (typeof DEVICE_METRIC_COLOR)[keyof typeof DEVICE_METRIC_COLOR];
+export declare const deviceMetricColorSchema: z.ZodEnum<["black", "blue", "cyan", "green", "magenta", "red", "white", "yellow"]>;
+export declare const DEVICE_METRIC_OPERATIONAL_STATUS: {
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly OFF: "off";
+    readonly ON: "on";
+    readonly STANDBY: "standby";
+};
+export type DeviceMetricOperationalStatus = (typeof DEVICE_METRIC_OPERATIONAL_STATUS)[keyof typeof DEVICE_METRIC_OPERATIONAL_STATUS];
+export declare const deviceMetricOperationalStatusSchema: z.ZodEnum<["entered-in-error", "off", "on", "standby"]>;
+export declare const DEVICE_NAME_TYPE: {
+    readonly MANUFACTURER_NAME: "manufacturer-name";
+    readonly MODEL_NAME: "model-name";
+    readonly OTHER: "other";
+    readonly PATIENT_REPORTED_NAME: "patient-reported-name";
+    readonly UDI_LABEL_NAME: "udi-label-name";
+    readonly USER_FRIENDLY_NAME: "user-friendly-name";
+};
+export type DeviceNameType = (typeof DEVICE_NAME_TYPE)[keyof typeof DEVICE_NAME_TYPE];
+export declare const deviceNameTypeSchema: z.ZodEnum<["manufacturer-name", "model-name", "other", "patient-reported-name", "udi-label-name", "user-friendly-name"]>;
+export declare const DEVICE_USE_STATEMENT_STATUS: {
+    readonly ACTIVE: "active";
+    readonly COMPLETED: "completed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly INTENDED: "intended";
+    readonly ON_HOLD: "on-hold";
+    readonly STOPPED: "stopped";
+};
+export type DeviceUseStatementStatus = (typeof DEVICE_USE_STATEMENT_STATUS)[keyof typeof DEVICE_USE_STATEMENT_STATUS];
+export declare const deviceUseStatementStatusSchema: z.ZodEnum<["active", "completed", "entered-in-error", "intended", "on-hold", "stopped"]>;
+export declare const DIAGNOSTIC_REPORT_STATUS: {
+    readonly AMENDED: "amended";
+    readonly APPENDED: "appended";
+    readonly CANCELLED: "cancelled";
+    readonly CORRECTED: "corrected";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly FINAL: "final";
+    readonly PARTIAL: "partial";
+    readonly PRELIMINARY: "preliminary";
     readonly REGISTERED: "registered";
+    readonly UNKNOWN: "unknown";
+};
+export type DiagnosticReportStatus = (typeof DIAGNOSTIC_REPORT_STATUS)[keyof typeof DIAGNOSTIC_REPORT_STATUS];
+export declare const diagnosticReportStatusSchema: z.ZodEnum<["amended", "appended", "cancelled", "corrected", "entered-in-error", "final", "partial", "preliminary", "registered", "unknown"]>;
+export declare const DISCRIMINATOR_TYPE: {
+    readonly EXISTS: "exists";
+    readonly PATTERN: "pattern";
+    readonly PROFILE: "profile";
+    readonly TYPE: "type";
+    readonly VALUE: "value";
+};
+export type DiscriminatorType = (typeof DISCRIMINATOR_TYPE)[keyof typeof DISCRIMINATOR_TYPE];
+export declare const discriminatorTypeSchema: z.ZodEnum<["exists", "pattern", "profile", "type", "value"]>;
+export declare const DOCUMENT_MODE: {
+    readonly CONSUMER: "consumer";
+    readonly PRODUCER: "producer";
+};
+export type DocumentMode = (typeof DOCUMENT_MODE)[keyof typeof DOCUMENT_MODE];
+export declare const documentModeSchema: z.ZodEnum<["consumer", "producer"]>;
+export declare const DOCUMENT_REFERENCE_STATUS: {
+    readonly CURRENT: "current";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly SUPERSEDED: "superseded";
+};
+export type DocumentReferenceStatus = (typeof DOCUMENT_REFERENCE_STATUS)[keyof typeof DOCUMENT_REFERENCE_STATUS];
+export declare const documentReferenceStatusSchema: z.ZodEnum<["current", "entered-in-error", "superseded"]>;
+export declare const DOCUMENT_RELATIONSHIP_TYPE: {
+    readonly APPENDS: "appends";
+    readonly REPLACES: "replaces";
+    readonly SIGNS: "signs";
+    readonly TRANSFORMS: "transforms";
+};
+export type DocumentRelationshipType = (typeof DOCUMENT_RELATIONSHIP_TYPE)[keyof typeof DOCUMENT_RELATIONSHIP_TYPE];
+export declare const documentRelationshipTypeSchema: z.ZodEnum<["appends", "replaces", "signs", "transforms"]>;
+export declare const EFFECT_ESTIMATE_TYPE: {
+    readonly ABSOLUTE_ARD: "absolute-ARD";
+    readonly ABSOLUTE_MEANDIFF: "absolute-MeanDiff";
+    readonly ABSOLUTE_MEDIANDIFF: "absolute-MedianDiff";
+    readonly ABSOLUTE_SMD: "absolute-SMD";
+    readonly RELATIVE_HR: "relative-HR";
+    readonly RELATIVE_OR: "relative-OR";
+    readonly RELATIVE_RR: "relative-RR";
+};
+export type EffectEstimateType = (typeof EFFECT_ESTIMATE_TYPE)[keyof typeof EFFECT_ESTIMATE_TYPE];
+export declare const effectEstimateTypeSchema: z.ZodEnum<["absolute-ARD", "absolute-MeanDiff", "absolute-MedianDiff", "absolute-SMD", "relative-HR", "relative-OR", "relative-RR"]>;
+export declare const ELIGIBILITY_REQUEST_PURPOSE: {
+    readonly AUTH_REQUIREMENTS: "auth-requirements";
+    readonly BENEFITS: "benefits";
+    readonly DISCOVERY: "discovery";
+    readonly VALIDATION: "validation";
+};
+export type EligibilityRequestPurpose = (typeof ELIGIBILITY_REQUEST_PURPOSE)[keyof typeof ELIGIBILITY_REQUEST_PURPOSE];
+export declare const eligibilityRequestPurposeSchema: z.ZodEnum<["auth-requirements", "benefits", "discovery", "validation"]>;
+export declare const ELIGIBILITY_RESPONSE_PURPOSE: {
+    readonly AUTH_REQUIREMENTS: "auth-requirements";
+    readonly BENEFITS: "benefits";
+    readonly DISCOVERY: "discovery";
+    readonly VALIDATION: "validation";
+};
+export type EligibilityResponsePurpose = (typeof ELIGIBILITY_RESPONSE_PURPOSE)[keyof typeof ELIGIBILITY_RESPONSE_PURPOSE];
+export declare const eligibilityResponsePurposeSchema: z.ZodEnum<["auth-requirements", "benefits", "discovery", "validation"]>;
+export declare const ENABLE_WHEN_BEHAVIOR: {
+    readonly ALL: "all";
+    readonly ANY: "any";
+};
+export type EnableWhenBehavior = (typeof ENABLE_WHEN_BEHAVIOR)[keyof typeof ENABLE_WHEN_BEHAVIOR];
+export declare const enableWhenBehaviorSchema: z.ZodEnum<["all", "any"]>;
+export declare const ENCOUNTER_LOCATION_STATUS: {
+    readonly ACTIVE: "active";
+    readonly COMPLETED: "completed";
+    readonly PLANNED: "planned";
+    readonly RESERVED: "reserved";
+};
+export type EncounterLocationStatus = (typeof ENCOUNTER_LOCATION_STATUS)[keyof typeof ENCOUNTER_LOCATION_STATUS];
+export declare const encounterLocationStatusSchema: z.ZodEnum<["active", "completed", "planned", "reserved"]>;
+export declare const ENCOUNTER_STATUS: {
+    readonly ARRIVED: "arrived";
+    readonly CANCELLED: "cancelled";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly FINISHED: "finished";
+    readonly IN_PROGRESS: "in-progress";
+    readonly ONLEAVE: "onleave";
+    readonly PLANNED: "planned";
+    readonly TRIAGED: "triaged";
+    readonly UNKNOWN: "unknown";
+};
+export type EncounterStatus = (typeof ENCOUNTER_STATUS)[keyof typeof ENCOUNTER_STATUS];
+export declare const encounterStatusSchema: z.ZodEnum<["arrived", "cancelled", "entered-in-error", "finished", "in-progress", "onleave", "planned", "triaged", "unknown"]>;
+export declare const ENDPOINT_CONNECTION_TYPE: {
+    readonly DICOM_QIDO_RS: "dicom-qido-rs";
+    readonly DICOM_STOW_RS: "dicom-stow-rs";
+    readonly DICOM_WADO_RS: "dicom-wado-rs";
+    readonly DICOM_WADO_URI: "dicom-wado-uri";
+    readonly DIRECT_PROJECT: "direct-project";
+    readonly HL7_FHIR_MSG: "hl7-fhir-msg";
+    readonly HL7_FHIR_REST: "hl7-fhir-rest";
+    readonly HL7V2_MLLP: "hl7v2-mllp";
+    readonly IHE_IID: "ihe-iid";
+    readonly IHE_XCA: "ihe-xca";
+    readonly IHE_XCPD: "ihe-xcpd";
+    readonly IHE_XDR: "ihe-xdr";
+    readonly IHE_XDS: "ihe-xds";
+    readonly SECURE_EMAIL: "secure-email";
+};
+export type EndpointConnectionType = (typeof ENDPOINT_CONNECTION_TYPE)[keyof typeof ENDPOINT_CONNECTION_TYPE];
+export declare const endpointConnectionTypeSchema: z.ZodEnum<["dicom-qido-rs", "dicom-stow-rs", "dicom-wado-rs", "dicom-wado-uri", "direct-project", "hl7-fhir-msg", "hl7-fhir-rest", "hl7v2-mllp", "ihe-iid", "ihe-xca", "ihe-xcpd", "ihe-xdr", "ihe-xds", "secure-email"]>;
+export declare const ENDPOINT_STATUS: {
+    readonly ACTIVE: "active";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly ERROR: "error";
+    readonly OFF: "off";
+    readonly SUSPENDED: "suspended";
+    readonly TEST: "test";
+};
+export type EndpointStatus = (typeof ENDPOINT_STATUS)[keyof typeof ENDPOINT_STATUS];
+export declare const endpointStatusSchema: z.ZodEnum<["active", "entered-in-error", "error", "off", "suspended", "test"]>;
+export declare const ENTERAL_ROUTE_CODES: {
+    readonly EFT: "EFT";
+    readonly ENTINSTL: "ENTINSTL";
+    readonly GJT: "GJT";
+    readonly GT: "GT";
+    readonly JJTINSTL: "JJTINSTL";
+    readonly NGT: "NGT";
+    readonly OGT: "OGT";
+    readonly OJJ: "OJJ";
+    readonly PO: "PO";
+};
+export type EnteralRouteCodes = (typeof ENTERAL_ROUTE_CODES)[keyof typeof ENTERAL_ROUTE_CODES];
+export declare const enteralRouteCodesSchema: z.ZodEnum<["EFT", "ENTINSTL", "GJT", "GT", "JJTINSTL", "NGT", "OGT", "OJJ", "PO"]>;
+export declare const EPISODE_OF_CARE_STATUS: {
+    readonly ACTIVE: "active";
+    readonly CANCELLED: "cancelled";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly FINISHED: "finished";
+    readonly ONHOLD: "onhold";
+    readonly PLANNED: "planned";
+    readonly WAITLIST: "waitlist";
+};
+export type EpisodeOfCareStatus = (typeof EPISODE_OF_CARE_STATUS)[keyof typeof EPISODE_OF_CARE_STATUS];
+export declare const episodeOfCareStatusSchema: z.ZodEnum<["active", "cancelled", "entered-in-error", "finished", "onhold", "planned", "waitlist"]>;
+export declare const EVENT_CAPABILITY_MODE: {
+    readonly RECEIVER: "receiver";
+    readonly SENDER: "sender";
+};
+export type EventCapabilityMode = (typeof EVENT_CAPABILITY_MODE)[keyof typeof EVENT_CAPABILITY_MODE];
+export declare const eventCapabilityModeSchema: z.ZodEnum<["receiver", "sender"]>;
+export declare const EVENT_STATUS: {
+    readonly COMPLETED: "completed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly IN_PROGRESS: "in-progress";
+    readonly NOT_DONE: "not-done";
+    readonly ON_HOLD: "on-hold";
+    readonly PREPARATION: "preparation";
+    readonly STOPPED: "stopped";
+    readonly UNKNOWN: "unknown";
+};
+export type EventStatus = (typeof EVENT_STATUS)[keyof typeof EVENT_STATUS];
+export declare const eventStatusSchema: z.ZodEnum<["completed", "entered-in-error", "in-progress", "not-done", "on-hold", "preparation", "stopped", "unknown"]>;
+export declare const EVENT_TIMING: {
+    readonly AC: "AC";
+    readonly ACD: "ACD";
+    readonly ACM: "ACM";
+    readonly ACV: "ACV";
+    readonly AFT: "AFT";
+    readonly AFT_EARLY: "AFT.early";
+    readonly AFT_LATE: "AFT.late";
+    readonly C: "C";
+    readonly CD: "CD";
+    readonly CM: "CM";
+    readonly CV: "CV";
+    readonly EVE: "EVE";
+    readonly EVE_EARLY: "EVE.early";
+    readonly EVE_LATE: "EVE.late";
+    readonly HS: "HS";
+    readonly MORN: "MORN";
+    readonly MORN_EARLY: "MORN.early";
+    readonly MORN_LATE: "MORN.late";
+    readonly NIGHT: "NIGHT";
+    readonly NOON: "NOON";
+    readonly PC: "PC";
+    readonly PCD: "PCD";
+    readonly PCM: "PCM";
+    readonly PCV: "PCV";
+    readonly PHS: "PHS";
+    readonly WAKE: "WAKE";
+};
+export type EventTiming = (typeof EVENT_TIMING)[keyof typeof EVENT_TIMING];
+export declare const eventTimingSchema: z.ZodEnum<["AC", "ACD", "ACM", "ACV", "AFT", "AFT.early", "AFT.late", "C", "CD", "CM", "CV", "EVE", "EVE.early", "EVE.late", "HS", "MORN", "MORN.early", "MORN.late", "NIGHT", "NOON", "PC", "PCD", "PCM", "PCV", "PHS", "WAKE"]>;
+export declare const EVIDENCE_VARIABLE_TYPE: {
+    readonly CONTINUOUS: "continuous";
+    readonly DESCRIPTIVE: "descriptive";
+    readonly DICHOTOMOUS: "dichotomous";
+};
+export type EvidenceVariableType = (typeof EVIDENCE_VARIABLE_TYPE)[keyof typeof EVIDENCE_VARIABLE_TYPE];
+export declare const evidenceVariableTypeSchema: z.ZodEnum<["continuous", "descriptive", "dichotomous"]>;
+export declare const EVIDENCE_VARIANT_STATE: {
+    readonly HIGH_RISK: "high-risk";
+    readonly LOW_RISK: "low-risk";
+    readonly MEDIUM_RISK: "medium-risk";
+};
+export type EvidenceVariantState = (typeof EVIDENCE_VARIANT_STATE)[keyof typeof EVIDENCE_VARIANT_STATE];
+export declare const evidenceVariantStateSchema: z.ZodEnum<["high-risk", "low-risk", "medium-risk"]>;
+export declare const EXAMPLE_SCENARIO_ACTOR_TYPE: {
+    readonly ENTITY: "entity";
+    readonly PERSON: "person";
+};
+export type ExampleScenarioActorType = (typeof EXAMPLE_SCENARIO_ACTOR_TYPE)[keyof typeof EXAMPLE_SCENARIO_ACTOR_TYPE];
+export declare const exampleScenarioActorTypeSchema: z.ZodEnum<["entity", "person"]>;
+export declare const EXPLANATION_OF_BENEFIT_STATUS: {
+    readonly ACTIVE: "active";
+    readonly CANCELLED: "cancelled";
+    readonly DRAFT: "draft";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+};
+export type ExplanationOfBenefitStatus = (typeof EXPLANATION_OF_BENEFIT_STATUS)[keyof typeof EXPLANATION_OF_BENEFIT_STATUS];
+export declare const explanationOfBenefitStatusSchema: z.ZodEnum<["active", "cancelled", "draft", "entered-in-error"]>;
+export declare const EXPOSURE_STATE: {
+    readonly EXPOSURE: "exposure";
+    readonly EXPOSURE_ALTERNATIVE: "exposure-alternative";
+};
+export type ExposureState = (typeof EXPOSURE_STATE)[keyof typeof EXPOSURE_STATE];
+export declare const exposureStateSchema: z.ZodEnum<["exposure", "exposure-alternative"]>;
+export declare const EXPRESSION_LANGUAGE: {
+    readonly APPLICATION_X_FHIR_QUERY: "application/x-fhir-query";
+    readonly TEXT_CQL: "text/cql";
+    readonly TEXT_FHIRPATH: "text/fhirpath";
+};
+export type ExpressionLanguage = (typeof EXPRESSION_LANGUAGE)[keyof typeof EXPRESSION_LANGUAGE];
+export declare const expressionLanguageSchema: z.ZodEnum<["application/x-fhir-query", "text/cql", "text/fhirpath"]>;
+export declare const EXTENSION_CONTEXT_TYPE: {
+    readonly ELEMENT: "element";
+    readonly EXTENSION: "extension";
+    readonly FHIRPATH: "fhirpath";
+};
+export type ExtensionContextType = (typeof EXTENSION_CONTEXT_TYPE)[keyof typeof EXTENSION_CONTEXT_TYPE];
+export declare const extensionContextTypeSchema: z.ZodEnum<["element", "extension", "fhirpath"]>;
+export declare const F_H_I_R_ALL_TYPES: {
+    readonly ACCOUNT: "Account";
+    readonly ACTIVITYDEFINITION: "ActivityDefinition";
+    readonly ADDRESS: "Address";
+    readonly ADVERSEEVENT: "AdverseEvent";
+    readonly AGE: "Age";
+    readonly ALLERGYINTOLERANCE: "AllergyIntolerance";
+    readonly ANNOTATION: "Annotation";
+    readonly ANY: "Any";
+    readonly APPOINTMENT: "Appointment";
+    readonly APPOINTMENTRESPONSE: "AppointmentResponse";
+    readonly ATTACHMENT: "Attachment";
+    readonly AUDITEVENT: "AuditEvent";
+    readonly BACKBONEELEMENT: "BackboneElement";
+    readonly BASIC: "Basic";
+    readonly BINARY: "Binary";
+    readonly BIOLOGICALLYDERIVEDPRODUCT: "BiologicallyDerivedProduct";
+    readonly BODYSTRUCTURE: "BodyStructure";
+    readonly BUNDLE: "Bundle";
+    readonly CAPABILITYSTATEMENT: "CapabilityStatement";
+    readonly CAREPLAN: "CarePlan";
+    readonly CARETEAM: "CareTeam";
+    readonly CATALOGENTRY: "CatalogEntry";
+    readonly CHARGEITEM: "ChargeItem";
+    readonly CHARGEITEMDEFINITION: "ChargeItemDefinition";
+    readonly CLAIM: "Claim";
+    readonly CLAIMRESPONSE: "ClaimResponse";
+    readonly CLINICALIMPRESSION: "ClinicalImpression";
+    readonly CODESYSTEM: "CodeSystem";
+    readonly CODEABLECONCEPT: "CodeableConcept";
+    readonly CODING: "Coding";
+    readonly COMMUNICATION: "Communication";
+    readonly COMMUNICATIONREQUEST: "CommunicationRequest";
+    readonly COMPARTMENTDEFINITION: "CompartmentDefinition";
+    readonly COMPOSITION: "Composition";
+    readonly CONCEPTMAP: "ConceptMap";
+    readonly CONDITION: "Condition";
+    readonly CONSENT: "Consent";
+    readonly CONTACTDETAIL: "ContactDetail";
+    readonly CONTACTPOINT: "ContactPoint";
+    readonly CONTRACT: "Contract";
+    readonly CONTRIBUTOR: "Contributor";
+    readonly COUNT: "Count";
+    readonly COVERAGE: "Coverage";
+    readonly COVERAGEELIGIBILITYREQUEST: "CoverageEligibilityRequest";
+    readonly COVERAGEELIGIBILITYRESPONSE: "CoverageEligibilityResponse";
+    readonly DATAREQUIREMENT: "DataRequirement";
+    readonly DETECTEDISSUE: "DetectedIssue";
+    readonly DEVICE: "Device";
+    readonly DEVICEDEFINITION: "DeviceDefinition";
+    readonly DEVICEMETRIC: "DeviceMetric";
+    readonly DEVICEREQUEST: "DeviceRequest";
+    readonly DEVICEUSESTATEMENT: "DeviceUseStatement";
+    readonly DIAGNOSTICREPORT: "DiagnosticReport";
+    readonly DISTANCE: "Distance";
+    readonly DOCUMENTMANIFEST: "DocumentManifest";
+    readonly DOCUMENTREFERENCE: "DocumentReference";
+    readonly DOMAINRESOURCE: "DomainResource";
+    readonly DOSAGE: "Dosage";
+    readonly DURATION: "Duration";
+    readonly EFFECTEVIDENCESYNTHESIS: "EffectEvidenceSynthesis";
+    readonly ELEMENT: "Element";
+    readonly ELEMENTDEFINITION: "ElementDefinition";
+    readonly ENCOUNTER: "Encounter";
+    readonly ENDPOINT: "Endpoint";
+    readonly ENROLLMENTREQUEST: "EnrollmentRequest";
+    readonly ENROLLMENTRESPONSE: "EnrollmentResponse";
+    readonly EPISODEOFCARE: "EpisodeOfCare";
+    readonly EVENTDEFINITION: "EventDefinition";
+    readonly EVIDENCE: "Evidence";
+    readonly EVIDENCEVARIABLE: "EvidenceVariable";
+    readonly EXAMPLESCENARIO: "ExampleScenario";
+    readonly EXPLANATIONOFBENEFIT: "ExplanationOfBenefit";
+    readonly EXPRESSION: "Expression";
+    readonly EXTENSION: "Extension";
+    readonly FAMILYMEMBERHISTORY: "FamilyMemberHistory";
+    readonly FLAG: "Flag";
+    readonly GOAL: "Goal";
+    readonly GRAPHDEFINITION: "GraphDefinition";
+    readonly GROUP: "Group";
+    readonly GUIDANCERESPONSE: "GuidanceResponse";
+    readonly HEALTHCARESERVICE: "HealthcareService";
+    readonly HUMANNAME: "HumanName";
+    readonly IDENTIFIER: "Identifier";
+    readonly IMAGINGSTUDY: "ImagingStudy";
+    readonly IMMUNIZATION: "Immunization";
+    readonly IMMUNIZATIONEVALUATION: "ImmunizationEvaluation";
+    readonly IMMUNIZATIONRECOMMENDATION: "ImmunizationRecommendation";
+    readonly IMPLEMENTATIONGUIDE: "ImplementationGuide";
+    readonly INSURANCEPLAN: "InsurancePlan";
+    readonly INVOICE: "Invoice";
+    readonly LIBRARY: "Library";
+    readonly LINKAGE: "Linkage";
+    readonly LIST: "List";
+    readonly LOCATION: "Location";
+    readonly MARKETINGSTATUS: "MarketingStatus";
+    readonly MEASURE: "Measure";
+    readonly MEASUREREPORT: "MeasureReport";
+    readonly MEDIA: "Media";
+    readonly MEDICATION: "Medication";
+    readonly MEDICATIONADMINISTRATION: "MedicationAdministration";
+    readonly MEDICATIONDISPENSE: "MedicationDispense";
+    readonly MEDICATIONKNOWLEDGE: "MedicationKnowledge";
+    readonly MEDICATIONREQUEST: "MedicationRequest";
+    readonly MEDICATIONSTATEMENT: "MedicationStatement";
+    readonly MEDICINALPRODUCT: "MedicinalProduct";
+    readonly MEDICINALPRODUCTAUTHORIZATION: "MedicinalProductAuthorization";
+    readonly MEDICINALPRODUCTCONTRAINDICATION: "MedicinalProductContraindication";
+    readonly MEDICINALPRODUCTINDICATION: "MedicinalProductIndication";
+    readonly MEDICINALPRODUCTINGREDIENT: "MedicinalProductIngredient";
+    readonly MEDICINALPRODUCTINTERACTION: "MedicinalProductInteraction";
+    readonly MEDICINALPRODUCTMANUFACTURED: "MedicinalProductManufactured";
+    readonly MEDICINALPRODUCTPACKAGED: "MedicinalProductPackaged";
+    readonly MEDICINALPRODUCTPHARMACEUTICAL: "MedicinalProductPharmaceutical";
+    readonly MEDICINALPRODUCTUNDESIRABLEEFFECT: "MedicinalProductUndesirableEffect";
+    readonly MESSAGEDEFINITION: "MessageDefinition";
+    readonly MESSAGEHEADER: "MessageHeader";
+    readonly META: "Meta";
+    readonly MOLECULARSEQUENCE: "MolecularSequence";
+    readonly MONEY: "Money";
+    readonly MONEYQUANTITY: "MoneyQuantity";
+    readonly NAMINGSYSTEM: "NamingSystem";
+    readonly NARRATIVE: "Narrative";
+    readonly NUTRITIONORDER: "NutritionOrder";
+    readonly OBSERVATION: "Observation";
+    readonly OBSERVATIONDEFINITION: "ObservationDefinition";
+    readonly OPERATIONDEFINITION: "OperationDefinition";
+    readonly OPERATIONOUTCOME: "OperationOutcome";
+    readonly ORGANIZATION: "Organization";
+    readonly ORGANIZATIONAFFILIATION: "OrganizationAffiliation";
+    readonly PARAMETERDEFINITION: "ParameterDefinition";
+    readonly PARAMETERS: "Parameters";
+    readonly PATIENT: "Patient";
+    readonly PAYMENTNOTICE: "PaymentNotice";
+    readonly PAYMENTRECONCILIATION: "PaymentReconciliation";
+    readonly PERIOD: "Period";
+    readonly PERSON: "Person";
+    readonly PLANDEFINITION: "PlanDefinition";
+    readonly POPULATION: "Population";
+    readonly PRACTITIONER: "Practitioner";
+    readonly PRACTITIONERROLE: "PractitionerRole";
+    readonly PROCEDURE: "Procedure";
+    readonly PRODCHARACTERISTIC: "ProdCharacteristic";
+    readonly PRODUCTSHELFLIFE: "ProductShelfLife";
+    readonly PROVENANCE: "Provenance";
+    readonly QUANTITY: "Quantity";
+    readonly QUESTIONNAIRE: "Questionnaire";
+    readonly QUESTIONNAIRERESPONSE: "QuestionnaireResponse";
+    readonly RANGE: "Range";
+    readonly RATIO: "Ratio";
+    readonly REFERENCE: "Reference";
+    readonly RELATEDARTIFACT: "RelatedArtifact";
+    readonly RELATEDPERSON: "RelatedPerson";
+    readonly REQUESTGROUP: "RequestGroup";
+    readonly RESEARCHDEFINITION: "ResearchDefinition";
+    readonly RESEARCHELEMENTDEFINITION: "ResearchElementDefinition";
+    readonly RESEARCHSTUDY: "ResearchStudy";
+    readonly RESEARCHSUBJECT: "ResearchSubject";
+    readonly RESOURCE: "Resource";
+    readonly RISKASSESSMENT: "RiskAssessment";
+    readonly RISKEVIDENCESYNTHESIS: "RiskEvidenceSynthesis";
+    readonly SAMPLEDDATA: "SampledData";
+    readonly SCHEDULE: "Schedule";
+    readonly SEARCHPARAMETER: "SearchParameter";
+    readonly SERVICEREQUEST: "ServiceRequest";
+    readonly SIGNATURE: "Signature";
+    readonly SIMPLEQUANTITY: "SimpleQuantity";
+    readonly SLOT: "Slot";
+    readonly SPECIMEN: "Specimen";
+    readonly SPECIMENDEFINITION: "SpecimenDefinition";
+    readonly STRUCTUREDEFINITION: "StructureDefinition";
+    readonly STRUCTUREMAP: "StructureMap";
+    readonly SUBSCRIPTION: "Subscription";
+    readonly SUBSTANCE: "Substance";
+    readonly SUBSTANCEAMOUNT: "SubstanceAmount";
+    readonly SUBSTANCENUCLEICACID: "SubstanceNucleicAcid";
+    readonly SUBSTANCEPOLYMER: "SubstancePolymer";
+    readonly SUBSTANCEPROTEIN: "SubstanceProtein";
+    readonly SUBSTANCEREFERENCEINFORMATION: "SubstanceReferenceInformation";
+    readonly SUBSTANCESOURCEMATERIAL: "SubstanceSourceMaterial";
+    readonly SUBSTANCESPECIFICATION: "SubstanceSpecification";
+    readonly SUPPLYDELIVERY: "SupplyDelivery";
+    readonly SUPPLYREQUEST: "SupplyRequest";
+    readonly TASK: "Task";
+    readonly TERMINOLOGYCAPABILITIES: "TerminologyCapabilities";
+    readonly TESTREPORT: "TestReport";
+    readonly TESTSCRIPT: "TestScript";
+    readonly TIMING: "Timing";
+    readonly TRIGGERDEFINITION: "TriggerDefinition";
+    readonly TYPE: "Type";
+    readonly USAGECONTEXT: "UsageContext";
+    readonly VALUESET: "ValueSet";
+    readonly VERIFICATIONRESULT: "VerificationResult";
+    readonly VISIONPRESCRIPTION: "VisionPrescription";
+    readonly BASE64BINARY: "base64Binary";
+    readonly BOOLEAN: "boolean";
+    readonly CANONICAL: "canonical";
+    readonly CODE: "code";
+    readonly DATE: "date";
+    readonly DATETIME: "dateTime";
+    readonly DECIMAL: "decimal";
+    readonly ID: "id";
+    readonly INSTANT: "instant";
+    readonly INTEGER: "integer";
+    readonly MARKDOWN: "markdown";
+    readonly OID: "oid";
+    readonly POSITIVEINT: "positiveInt";
+    readonly STRING: "string";
+    readonly TIME: "time";
+    readonly UNSIGNEDINT: "unsignedInt";
+    readonly URI: "uri";
+    readonly URL: "url";
+    readonly UUID: "uuid";
+    readonly XHTML: "xhtml";
+};
+export type FHIRAllTypes = (typeof F_H_I_R_ALL_TYPES)[keyof typeof F_H_I_R_ALL_TYPES];
+export declare const fHIRAllTypesSchema: z.ZodEnum<["Account", "ActivityDefinition", "Address", "AdverseEvent", "Age", "AllergyIntolerance", "Annotation", "Any", "Appointment", "AppointmentResponse", "Attachment", "AuditEvent", "BackboneElement", "Basic", "Binary", "BiologicallyDerivedProduct", "BodyStructure", "Bundle", "CapabilityStatement", "CarePlan", "CareTeam", "CatalogEntry", "ChargeItem", "ChargeItemDefinition", "Claim", "ClaimResponse", "ClinicalImpression", "CodeSystem", "CodeableConcept", "Coding", "Communication", "CommunicationRequest", "CompartmentDefinition", "Composition", "ConceptMap", "Condition", "Consent", "ContactDetail", "ContactPoint", "Contract", "Contributor", "Count", "Coverage", "CoverageEligibilityRequest", "CoverageEligibilityResponse", "DataRequirement", "DetectedIssue", "Device", "DeviceDefinition", "DeviceMetric", "DeviceRequest", "DeviceUseStatement", "DiagnosticReport", "Distance", "DocumentManifest", "DocumentReference", "DomainResource", "Dosage", "Duration", "EffectEvidenceSynthesis", "Element", "ElementDefinition", "Encounter", "Endpoint", "EnrollmentRequest", "EnrollmentResponse", "EpisodeOfCare", "EventDefinition", "Evidence", "EvidenceVariable", "ExampleScenario", "ExplanationOfBenefit", "Expression", "Extension", "FamilyMemberHistory", "Flag", "Goal", "GraphDefinition", "Group", "GuidanceResponse", "HealthcareService", "HumanName", "Identifier", "ImagingStudy", "Immunization", "ImmunizationEvaluation", "ImmunizationRecommendation", "ImplementationGuide", "InsurancePlan", "Invoice", "Library", "Linkage", "List", "Location", "MarketingStatus", "Measure", "MeasureReport", "Media", "Medication", "MedicationAdministration", "MedicationDispense", "MedicationKnowledge", "MedicationRequest", "MedicationStatement", "MedicinalProduct", "MedicinalProductAuthorization", "MedicinalProductContraindication", "MedicinalProductIndication", "MedicinalProductIngredient", "MedicinalProductInteraction", "MedicinalProductManufactured", "MedicinalProductPackaged", "MedicinalProductPharmaceutical", "MedicinalProductUndesirableEffect", "MessageDefinition", "MessageHeader", "Meta", "MolecularSequence", "Money", "MoneyQuantity", "NamingSystem", "Narrative", "NutritionOrder", "Observation", "ObservationDefinition", "OperationDefinition", "OperationOutcome", "Organization", "OrganizationAffiliation", "ParameterDefinition", "Parameters", "Patient", "PaymentNotice", "PaymentReconciliation", "Period", "Person", "PlanDefinition", "Population", "Practitioner", "PractitionerRole", "Procedure", "ProdCharacteristic", "ProductShelfLife", "Provenance", "Quantity", "Questionnaire", "QuestionnaireResponse", "Range", "Ratio", "Reference", "RelatedArtifact", "RelatedPerson", "RequestGroup", "ResearchDefinition", "ResearchElementDefinition", "ResearchStudy", "ResearchSubject", "Resource", "RiskAssessment", "RiskEvidenceSynthesis", "SampledData", "Schedule", "SearchParameter", "ServiceRequest", "Signature", "SimpleQuantity", "Slot", "Specimen", "SpecimenDefinition", "StructureDefinition", "StructureMap", "Subscription", "Substance", "SubstanceAmount", "SubstanceNucleicAcid", "SubstancePolymer", "SubstanceProtein", "SubstanceReferenceInformation", "SubstanceSourceMaterial", "SubstanceSpecification", "SupplyDelivery", "SupplyRequest", "Task", "TerminologyCapabilities", "TestReport", "TestScript", "Timing", "TriggerDefinition", "Type", "UsageContext", "ValueSet", "VerificationResult", "VisionPrescription", "base64Binary", "boolean", "canonical", "code", "date", "dateTime", "decimal", "id", "instant", "integer", "markdown", "oid", "positiveInt", "string", "time", "unsignedInt", "uri", "url", "uuid", "xhtml"]>;
+export declare const F_H_I_R_DEFINED_TYPE: {
+    readonly ACCOUNT: "Account";
+    readonly ACTIVITYDEFINITION: "ActivityDefinition";
+    readonly ADDRESS: "Address";
+    readonly ADVERSEEVENT: "AdverseEvent";
+    readonly AGE: "Age";
+    readonly ALLERGYINTOLERANCE: "AllergyIntolerance";
+    readonly ANNOTATION: "Annotation";
+    readonly APPOINTMENT: "Appointment";
+    readonly APPOINTMENTRESPONSE: "AppointmentResponse";
+    readonly ATTACHMENT: "Attachment";
+    readonly AUDITEVENT: "AuditEvent";
+    readonly BACKBONEELEMENT: "BackboneElement";
+    readonly BASIC: "Basic";
+    readonly BINARY: "Binary";
+    readonly BIOLOGICALLYDERIVEDPRODUCT: "BiologicallyDerivedProduct";
+    readonly BODYSTRUCTURE: "BodyStructure";
+    readonly BUNDLE: "Bundle";
+    readonly CAPABILITYSTATEMENT: "CapabilityStatement";
+    readonly CAREPLAN: "CarePlan";
+    readonly CARETEAM: "CareTeam";
+    readonly CATALOGENTRY: "CatalogEntry";
+    readonly CHARGEITEM: "ChargeItem";
+    readonly CHARGEITEMDEFINITION: "ChargeItemDefinition";
+    readonly CLAIM: "Claim";
+    readonly CLAIMRESPONSE: "ClaimResponse";
+    readonly CLINICALIMPRESSION: "ClinicalImpression";
+    readonly CODESYSTEM: "CodeSystem";
+    readonly CODEABLECONCEPT: "CodeableConcept";
+    readonly CODING: "Coding";
+    readonly COMMUNICATION: "Communication";
+    readonly COMMUNICATIONREQUEST: "CommunicationRequest";
+    readonly COMPARTMENTDEFINITION: "CompartmentDefinition";
+    readonly COMPOSITION: "Composition";
+    readonly CONCEPTMAP: "ConceptMap";
+    readonly CONDITION: "Condition";
+    readonly CONSENT: "Consent";
+    readonly CONTACTDETAIL: "ContactDetail";
+    readonly CONTACTPOINT: "ContactPoint";
+    readonly CONTRACT: "Contract";
+    readonly CONTRIBUTOR: "Contributor";
+    readonly COUNT: "Count";
+    readonly COVERAGE: "Coverage";
+    readonly COVERAGEELIGIBILITYREQUEST: "CoverageEligibilityRequest";
+    readonly COVERAGEELIGIBILITYRESPONSE: "CoverageEligibilityResponse";
+    readonly DATAREQUIREMENT: "DataRequirement";
+    readonly DETECTEDISSUE: "DetectedIssue";
+    readonly DEVICE: "Device";
+    readonly DEVICEDEFINITION: "DeviceDefinition";
+    readonly DEVICEMETRIC: "DeviceMetric";
+    readonly DEVICEREQUEST: "DeviceRequest";
+    readonly DEVICEUSESTATEMENT: "DeviceUseStatement";
+    readonly DIAGNOSTICREPORT: "DiagnosticReport";
+    readonly DISTANCE: "Distance";
+    readonly DOCUMENTMANIFEST: "DocumentManifest";
+    readonly DOCUMENTREFERENCE: "DocumentReference";
+    readonly DOMAINRESOURCE: "DomainResource";
+    readonly DOSAGE: "Dosage";
+    readonly DURATION: "Duration";
+    readonly EFFECTEVIDENCESYNTHESIS: "EffectEvidenceSynthesis";
+    readonly ELEMENT: "Element";
+    readonly ELEMENTDEFINITION: "ElementDefinition";
+    readonly ENCOUNTER: "Encounter";
+    readonly ENDPOINT: "Endpoint";
+    readonly ENROLLMENTREQUEST: "EnrollmentRequest";
+    readonly ENROLLMENTRESPONSE: "EnrollmentResponse";
+    readonly EPISODEOFCARE: "EpisodeOfCare";
+    readonly EVENTDEFINITION: "EventDefinition";
+    readonly EVIDENCE: "Evidence";
+    readonly EVIDENCEVARIABLE: "EvidenceVariable";
+    readonly EXAMPLESCENARIO: "ExampleScenario";
+    readonly EXPLANATIONOFBENEFIT: "ExplanationOfBenefit";
+    readonly EXPRESSION: "Expression";
+    readonly EXTENSION: "Extension";
+    readonly FAMILYMEMBERHISTORY: "FamilyMemberHistory";
+    readonly FLAG: "Flag";
+    readonly GOAL: "Goal";
+    readonly GRAPHDEFINITION: "GraphDefinition";
+    readonly GROUP: "Group";
+    readonly GUIDANCERESPONSE: "GuidanceResponse";
+    readonly HEALTHCARESERVICE: "HealthcareService";
+    readonly HUMANNAME: "HumanName";
+    readonly IDENTIFIER: "Identifier";
+    readonly IMAGINGSTUDY: "ImagingStudy";
+    readonly IMMUNIZATION: "Immunization";
+    readonly IMMUNIZATIONEVALUATION: "ImmunizationEvaluation";
+    readonly IMMUNIZATIONRECOMMENDATION: "ImmunizationRecommendation";
+    readonly IMPLEMENTATIONGUIDE: "ImplementationGuide";
+    readonly INSURANCEPLAN: "InsurancePlan";
+    readonly INVOICE: "Invoice";
+    readonly LIBRARY: "Library";
+    readonly LINKAGE: "Linkage";
+    readonly LIST: "List";
+    readonly LOCATION: "Location";
+    readonly MARKETINGSTATUS: "MarketingStatus";
+    readonly MEASURE: "Measure";
+    readonly MEASUREREPORT: "MeasureReport";
+    readonly MEDIA: "Media";
+    readonly MEDICATION: "Medication";
+    readonly MEDICATIONADMINISTRATION: "MedicationAdministration";
+    readonly MEDICATIONDISPENSE: "MedicationDispense";
+    readonly MEDICATIONKNOWLEDGE: "MedicationKnowledge";
+    readonly MEDICATIONREQUEST: "MedicationRequest";
+    readonly MEDICATIONSTATEMENT: "MedicationStatement";
+    readonly MEDICINALPRODUCT: "MedicinalProduct";
+    readonly MEDICINALPRODUCTAUTHORIZATION: "MedicinalProductAuthorization";
+    readonly MEDICINALPRODUCTCONTRAINDICATION: "MedicinalProductContraindication";
+    readonly MEDICINALPRODUCTINDICATION: "MedicinalProductIndication";
+    readonly MEDICINALPRODUCTINGREDIENT: "MedicinalProductIngredient";
+    readonly MEDICINALPRODUCTINTERACTION: "MedicinalProductInteraction";
+    readonly MEDICINALPRODUCTMANUFACTURED: "MedicinalProductManufactured";
+    readonly MEDICINALPRODUCTPACKAGED: "MedicinalProductPackaged";
+    readonly MEDICINALPRODUCTPHARMACEUTICAL: "MedicinalProductPharmaceutical";
+    readonly MEDICINALPRODUCTUNDESIRABLEEFFECT: "MedicinalProductUndesirableEffect";
+    readonly MESSAGEDEFINITION: "MessageDefinition";
+    readonly MESSAGEHEADER: "MessageHeader";
+    readonly META: "Meta";
+    readonly MOLECULARSEQUENCE: "MolecularSequence";
+    readonly MONEY: "Money";
+    readonly MONEYQUANTITY: "MoneyQuantity";
+    readonly NAMINGSYSTEM: "NamingSystem";
+    readonly NARRATIVE: "Narrative";
+    readonly NUTRITIONORDER: "NutritionOrder";
+    readonly OBSERVATION: "Observation";
+    readonly OBSERVATIONDEFINITION: "ObservationDefinition";
+    readonly OPERATIONDEFINITION: "OperationDefinition";
+    readonly OPERATIONOUTCOME: "OperationOutcome";
+    readonly ORGANIZATION: "Organization";
+    readonly ORGANIZATIONAFFILIATION: "OrganizationAffiliation";
+    readonly PARAMETERDEFINITION: "ParameterDefinition";
+    readonly PARAMETERS: "Parameters";
+    readonly PATIENT: "Patient";
+    readonly PAYMENTNOTICE: "PaymentNotice";
+    readonly PAYMENTRECONCILIATION: "PaymentReconciliation";
+    readonly PERIOD: "Period";
+    readonly PERSON: "Person";
+    readonly PLANDEFINITION: "PlanDefinition";
+    readonly POPULATION: "Population";
+    readonly PRACTITIONER: "Practitioner";
+    readonly PRACTITIONERROLE: "PractitionerRole";
+    readonly PROCEDURE: "Procedure";
+    readonly PRODCHARACTERISTIC: "ProdCharacteristic";
+    readonly PRODUCTSHELFLIFE: "ProductShelfLife";
+    readonly PROVENANCE: "Provenance";
+    readonly QUANTITY: "Quantity";
+    readonly QUESTIONNAIRE: "Questionnaire";
+    readonly QUESTIONNAIRERESPONSE: "QuestionnaireResponse";
+    readonly RANGE: "Range";
+    readonly RATIO: "Ratio";
+    readonly REFERENCE: "Reference";
+    readonly RELATEDARTIFACT: "RelatedArtifact";
+    readonly RELATEDPERSON: "RelatedPerson";
+    readonly REQUESTGROUP: "RequestGroup";
+    readonly RESEARCHDEFINITION: "ResearchDefinition";
+    readonly RESEARCHELEMENTDEFINITION: "ResearchElementDefinition";
+    readonly RESEARCHSTUDY: "ResearchStudy";
+    readonly RESEARCHSUBJECT: "ResearchSubject";
+    readonly RESOURCE: "Resource";
+    readonly RISKASSESSMENT: "RiskAssessment";
+    readonly RISKEVIDENCESYNTHESIS: "RiskEvidenceSynthesis";
+    readonly SAMPLEDDATA: "SampledData";
+    readonly SCHEDULE: "Schedule";
+    readonly SEARCHPARAMETER: "SearchParameter";
+    readonly SERVICEREQUEST: "ServiceRequest";
+    readonly SIGNATURE: "Signature";
+    readonly SIMPLEQUANTITY: "SimpleQuantity";
+    readonly SLOT: "Slot";
+    readonly SPECIMEN: "Specimen";
+    readonly SPECIMENDEFINITION: "SpecimenDefinition";
+    readonly STRUCTUREDEFINITION: "StructureDefinition";
+    readonly STRUCTUREMAP: "StructureMap";
+    readonly SUBSCRIPTION: "Subscription";
+    readonly SUBSTANCE: "Substance";
+    readonly SUBSTANCEAMOUNT: "SubstanceAmount";
+    readonly SUBSTANCENUCLEICACID: "SubstanceNucleicAcid";
+    readonly SUBSTANCEPOLYMER: "SubstancePolymer";
+    readonly SUBSTANCEPROTEIN: "SubstanceProtein";
+    readonly SUBSTANCEREFERENCEINFORMATION: "SubstanceReferenceInformation";
+    readonly SUBSTANCESOURCEMATERIAL: "SubstanceSourceMaterial";
+    readonly SUBSTANCESPECIFICATION: "SubstanceSpecification";
+    readonly SUPPLYDELIVERY: "SupplyDelivery";
+    readonly SUPPLYREQUEST: "SupplyRequest";
+    readonly TASK: "Task";
+    readonly TERMINOLOGYCAPABILITIES: "TerminologyCapabilities";
+    readonly TESTREPORT: "TestReport";
+    readonly TESTSCRIPT: "TestScript";
+    readonly TIMING: "Timing";
+    readonly TRIGGERDEFINITION: "TriggerDefinition";
+    readonly USAGECONTEXT: "UsageContext";
+    readonly VALUESET: "ValueSet";
+    readonly VERIFICATIONRESULT: "VerificationResult";
+    readonly VISIONPRESCRIPTION: "VisionPrescription";
+    readonly BASE64BINARY: "base64Binary";
+    readonly BOOLEAN: "boolean";
+    readonly CANONICAL: "canonical";
+    readonly CODE: "code";
+    readonly DATE: "date";
+    readonly DATETIME: "dateTime";
+    readonly DECIMAL: "decimal";
+    readonly ID: "id";
+    readonly INSTANT: "instant";
+    readonly INTEGER: "integer";
+    readonly MARKDOWN: "markdown";
+    readonly OID: "oid";
+    readonly POSITIVEINT: "positiveInt";
+    readonly STRING: "string";
+    readonly TIME: "time";
+    readonly UNSIGNEDINT: "unsignedInt";
+    readonly URI: "uri";
+    readonly URL: "url";
+    readonly UUID: "uuid";
+    readonly XHTML: "xhtml";
+};
+export type FHIRDefinedType = (typeof F_H_I_R_DEFINED_TYPE)[keyof typeof F_H_I_R_DEFINED_TYPE];
+export declare const fHIRDefinedTypeSchema: z.ZodEnum<["Account", "ActivityDefinition", "Address", "AdverseEvent", "Age", "AllergyIntolerance", "Annotation", "Appointment", "AppointmentResponse", "Attachment", "AuditEvent", "BackboneElement", "Basic", "Binary", "BiologicallyDerivedProduct", "BodyStructure", "Bundle", "CapabilityStatement", "CarePlan", "CareTeam", "CatalogEntry", "ChargeItem", "ChargeItemDefinition", "Claim", "ClaimResponse", "ClinicalImpression", "CodeSystem", "CodeableConcept", "Coding", "Communication", "CommunicationRequest", "CompartmentDefinition", "Composition", "ConceptMap", "Condition", "Consent", "ContactDetail", "ContactPoint", "Contract", "Contributor", "Count", "Coverage", "CoverageEligibilityRequest", "CoverageEligibilityResponse", "DataRequirement", "DetectedIssue", "Device", "DeviceDefinition", "DeviceMetric", "DeviceRequest", "DeviceUseStatement", "DiagnosticReport", "Distance", "DocumentManifest", "DocumentReference", "DomainResource", "Dosage", "Duration", "EffectEvidenceSynthesis", "Element", "ElementDefinition", "Encounter", "Endpoint", "EnrollmentRequest", "EnrollmentResponse", "EpisodeOfCare", "EventDefinition", "Evidence", "EvidenceVariable", "ExampleScenario", "ExplanationOfBenefit", "Expression", "Extension", "FamilyMemberHistory", "Flag", "Goal", "GraphDefinition", "Group", "GuidanceResponse", "HealthcareService", "HumanName", "Identifier", "ImagingStudy", "Immunization", "ImmunizationEvaluation", "ImmunizationRecommendation", "ImplementationGuide", "InsurancePlan", "Invoice", "Library", "Linkage", "List", "Location", "MarketingStatus", "Measure", "MeasureReport", "Media", "Medication", "MedicationAdministration", "MedicationDispense", "MedicationKnowledge", "MedicationRequest", "MedicationStatement", "MedicinalProduct", "MedicinalProductAuthorization", "MedicinalProductContraindication", "MedicinalProductIndication", "MedicinalProductIngredient", "MedicinalProductInteraction", "MedicinalProductManufactured", "MedicinalProductPackaged", "MedicinalProductPharmaceutical", "MedicinalProductUndesirableEffect", "MessageDefinition", "MessageHeader", "Meta", "MolecularSequence", "Money", "MoneyQuantity", "NamingSystem", "Narrative", "NutritionOrder", "Observation", "ObservationDefinition", "OperationDefinition", "OperationOutcome", "Organization", "OrganizationAffiliation", "ParameterDefinition", "Parameters", "Patient", "PaymentNotice", "PaymentReconciliation", "Period", "Person", "PlanDefinition", "Population", "Practitioner", "PractitionerRole", "Procedure", "ProdCharacteristic", "ProductShelfLife", "Provenance", "Quantity", "Questionnaire", "QuestionnaireResponse", "Range", "Ratio", "Reference", "RelatedArtifact", "RelatedPerson", "RequestGroup", "ResearchDefinition", "ResearchElementDefinition", "ResearchStudy", "ResearchSubject", "Resource", "RiskAssessment", "RiskEvidenceSynthesis", "SampledData", "Schedule", "SearchParameter", "ServiceRequest", "Signature", "SimpleQuantity", "Slot", "Specimen", "SpecimenDefinition", "StructureDefinition", "StructureMap", "Subscription", "Substance", "SubstanceAmount", "SubstanceNucleicAcid", "SubstancePolymer", "SubstanceProtein", "SubstanceReferenceInformation", "SubstanceSourceMaterial", "SubstanceSpecification", "SupplyDelivery", "SupplyRequest", "Task", "TerminologyCapabilities", "TestReport", "TestScript", "Timing", "TriggerDefinition", "UsageContext", "ValueSet", "VerificationResult", "VisionPrescription", "base64Binary", "boolean", "canonical", "code", "date", "dateTime", "decimal", "id", "instant", "integer", "markdown", "oid", "positiveInt", "string", "time", "unsignedInt", "uri", "url", "uuid", "xhtml"]>;
+export declare const F_H_I_R_DEVICE_STATUS: {
+    readonly ACTIVE: "active";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly INACTIVE: "inactive";
+    readonly UNKNOWN: "unknown";
+};
+export type FHIRDeviceStatus = (typeof F_H_I_R_DEVICE_STATUS)[keyof typeof F_H_I_R_DEVICE_STATUS];
+export declare const fHIRDeviceStatusSchema: z.ZodEnum<["active", "entered-in-error", "inactive", "unknown"]>;
+export declare const F_H_I_R_DEVICE_STATUS_REASON: {
+    readonly HW_DISCON: "hw-discon";
+    readonly NOT_READY: "not-ready";
+    readonly OFF: "off";
+    readonly OFFLINE: "offline";
+    readonly ONLINE: "online";
+    readonly PAUSED: "paused";
+    readonly STANDBY: "standby";
+    readonly TRANSDUC_DISCON: "transduc-discon";
+};
+export type FHIRDeviceStatusReason = (typeof F_H_I_R_DEVICE_STATUS_REASON)[keyof typeof F_H_I_R_DEVICE_STATUS_REASON];
+export declare const fHIRDeviceStatusReasonSchema: z.ZodEnum<["hw-discon", "not-ready", "off", "offline", "online", "paused", "standby", "transduc-discon"]>;
+export declare const F_H_I_R_SUBSTANCE_STATUS: {
+    readonly ACTIVE: "active";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly INACTIVE: "inactive";
+};
+export type FHIRSubstanceStatus = (typeof F_H_I_R_SUBSTANCE_STATUS)[keyof typeof F_H_I_R_SUBSTANCE_STATUS];
+export declare const fHIRSubstanceStatusSchema: z.ZodEnum<["active", "entered-in-error", "inactive"]>;
+export declare const F_H_I_R_VERSION: {
+    readonly _0_0_80: "0.0.80";
+    readonly _0_0_81: "0.0.81";
+    readonly _0_0_82: "0.0.82";
+    readonly _0_01: "0.01";
+    readonly _0_05: "0.05";
+    readonly _0_06: "0.06";
+    readonly _0_11: "0.11";
+    readonly _0_4_0: "0.4.0";
+    readonly _0_5_0: "0.5.0";
+    readonly _1_0_0: "1.0.0";
+    readonly _1_0_1: "1.0.1";
+    readonly _1_0_2: "1.0.2";
+    readonly _1_1_0: "1.1.0";
+    readonly _1_4_0: "1.4.0";
+    readonly _1_6_0: "1.6.0";
+    readonly _1_8_0: "1.8.0";
+    readonly _3_0_0: "3.0.0";
+    readonly _3_0_1: "3.0.1";
+    readonly _3_3_0: "3.3.0";
+    readonly _3_5_0: "3.5.0";
+    readonly _4_0_0: "4.0.0";
+    readonly _4_0_1: "4.0.1";
+};
+export type FHIRVersion = (typeof F_H_I_R_VERSION)[keyof typeof F_H_I_R_VERSION];
+export declare const fHIRVersionSchema: z.ZodEnum<["0.0.80", "0.0.81", "0.0.82", "0.01", "0.05", "0.06", "0.11", "0.4.0", "0.5.0", "1.0.0", "1.0.1", "1.0.2", "1.1.0", "1.4.0", "1.6.0", "1.8.0", "3.0.0", "3.0.1", "3.3.0", "3.5.0", "4.0.0", "4.0.1"]>;
+export declare const FAMILY_HISTORY_STATUS: {
+    readonly COMPLETED: "completed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly HEALTH_UNKNOWN: "health-unknown";
+    readonly PARTIAL: "partial";
+};
+export type FamilyHistoryStatus = (typeof FAMILY_HISTORY_STATUS)[keyof typeof FAMILY_HISTORY_STATUS];
+export declare const familyHistoryStatusSchema: z.ZodEnum<["completed", "entered-in-error", "health-unknown", "partial"]>;
+export declare const FILTER_OPERATOR: {
+    readonly _EMPTY: "=";
+    readonly DESCENDENT_OF: "descendent-of";
+    readonly EXISTS: "exists";
+    readonly GENERALIZES: "generalizes";
+    readonly IN: "in";
+    readonly IS_A: "is-a";
+    readonly IS_NOT_A: "is-not-a";
+    readonly NOT_IN: "not-in";
+    readonly REGEX: "regex";
+};
+export type FilterOperator = (typeof FILTER_OPERATOR)[keyof typeof FILTER_OPERATOR];
+export declare const filterOperatorSchema: z.ZodEnum<["=", "descendent-of", "exists", "generalizes", "in", "is-a", "is-not-a", "not-in", "regex"]>;
+export declare const FINANCIAL_RESOURCE_STATUS_CODES: {
+    readonly ACTIVE: "active";
+    readonly CANCELLED: "cancelled";
+    readonly DRAFT: "draft";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+};
+export type FinancialResourceStatusCodes = (typeof FINANCIAL_RESOURCE_STATUS_CODES)[keyof typeof FINANCIAL_RESOURCE_STATUS_CODES];
+export declare const financialResourceStatusCodesSchema: z.ZodEnum<["active", "cancelled", "draft", "entered-in-error"]>;
+export declare const FLAG_STATUS: {
+    readonly ACTIVE: "active";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly INACTIVE: "inactive";
+};
+export type FlagStatus = (typeof FLAG_STATUS)[keyof typeof FLAG_STATUS];
+export declare const flagStatusSchema: z.ZodEnum<["active", "entered-in-error", "inactive"]>;
+export declare const GOAL_LIFECYCLE_STATUS: {
+    readonly ACCEPTED: "accepted";
+    readonly ACTIVE: "active";
+    readonly CANCELLED: "cancelled";
+    readonly COMPLETED: "completed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly ON_HOLD: "on-hold";
+    readonly PLANNED: "planned";
+    readonly PROPOSED: "proposed";
+    readonly REJECTED: "rejected";
+};
+export type GoalLifecycleStatus = (typeof GOAL_LIFECYCLE_STATUS)[keyof typeof GOAL_LIFECYCLE_STATUS];
+export declare const goalLifecycleStatusSchema: z.ZodEnum<["accepted", "active", "cancelled", "completed", "entered-in-error", "on-hold", "planned", "proposed", "rejected"]>;
+export declare const GRAPH_COMPARTMENT_RULE: {
+    readonly CUSTOM: "custom";
+    readonly DIFFERENT: "different";
+    readonly IDENTICAL: "identical";
+    readonly MATCHING: "matching";
+};
+export type GraphCompartmentRule = (typeof GRAPH_COMPARTMENT_RULE)[keyof typeof GRAPH_COMPARTMENT_RULE];
+export declare const graphCompartmentRuleSchema: z.ZodEnum<["custom", "different", "identical", "matching"]>;
+export declare const GRAPH_COMPARTMENT_USE: {
+    readonly CONDITION: "condition";
+    readonly REQUIREMENT: "requirement";
+};
+export type GraphCompartmentUse = (typeof GRAPH_COMPARTMENT_USE)[keyof typeof GRAPH_COMPARTMENT_USE];
+export declare const graphCompartmentUseSchema: z.ZodEnum<["condition", "requirement"]>;
+export declare const GROUP_MEASURE: {
+    readonly MEAN: "mean";
+    readonly MEAN_OF_MEAN: "mean-of-mean";
+    readonly MEAN_OF_MEDIAN: "mean-of-median";
+    readonly MEDIAN: "median";
+    readonly MEDIAN_OF_MEAN: "median-of-mean";
+    readonly MEDIAN_OF_MEDIAN: "median-of-median";
+};
+export type GroupMeasure = (typeof GROUP_MEASURE)[keyof typeof GROUP_MEASURE];
+export declare const groupMeasureSchema: z.ZodEnum<["mean", "mean-of-mean", "mean-of-median", "median", "median-of-mean", "median-of-median"]>;
+export declare const GROUP_TYPE: {
+    readonly ANIMAL: "animal";
+    readonly DEVICE: "device";
+    readonly MEDICATION: "medication";
+    readonly PERSON: "person";
+    readonly PRACTITIONER: "practitioner";
+    readonly SUBSTANCE: "substance";
+};
+export type GroupType = (typeof GROUP_TYPE)[keyof typeof GROUP_TYPE];
+export declare const groupTypeSchema: z.ZodEnum<["animal", "device", "medication", "person", "practitioner", "substance"]>;
+export declare const GUIDANCE_RESPONSE_STATUS: {
+    readonly DATA_REQUESTED: "data-requested";
+    readonly DATA_REQUIRED: "data-required";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly FAILURE: "failure";
+    readonly IN_PROGRESS: "in-progress";
+    readonly SUCCESS: "success";
+};
+export type GuidanceResponseStatus = (typeof GUIDANCE_RESPONSE_STATUS)[keyof typeof GUIDANCE_RESPONSE_STATUS];
+export declare const guidanceResponseStatusSchema: z.ZodEnum<["data-requested", "data-required", "entered-in-error", "failure", "in-progress", "success"]>;
+export declare const GUIDE_PAGE_GENERATION: {
+    readonly GENERATED: "generated";
+    readonly HTML: "html";
+    readonly MARKDOWN: "markdown";
+    readonly XML: "xml";
+};
+export type GuidePageGeneration = (typeof GUIDE_PAGE_GENERATION)[keyof typeof GUIDE_PAGE_GENERATION];
+export declare const guidePageGenerationSchema: z.ZodEnum<["generated", "html", "markdown", "xml"]>;
+export declare const GUIDE_PARAMETER_CODE: {
+    readonly APPLY: "apply";
+    readonly EXPANSION_PARAMETER: "expansion-parameter";
+    readonly GENERATE_JSON: "generate-json";
+    readonly GENERATE_TURTLE: "generate-turtle";
+    readonly GENERATE_XML: "generate-xml";
+    readonly HTML_TEMPLATE: "html-template";
+    readonly PATH_PAGES: "path-pages";
+    readonly PATH_RESOURCE: "path-resource";
+    readonly PATH_TX_CACHE: "path-tx-cache";
+    readonly RULE_BROKEN_LINKS: "rule-broken-links";
+};
+export type GuideParameterCode = (typeof GUIDE_PARAMETER_CODE)[keyof typeof GUIDE_PARAMETER_CODE];
+export declare const guideParameterCodeSchema: z.ZodEnum<["apply", "expansion-parameter", "generate-json", "generate-turtle", "generate-xml", "html-template", "path-pages", "path-resource", "path-tx-cache", "rule-broken-links"]>;
+export declare const H_T_T_P_VERB: {
+    readonly DELETE: "DELETE";
+    readonly GET: "GET";
+    readonly HEAD: "HEAD";
+    readonly PATCH: "PATCH";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+};
+export type HTTPVerb = (typeof H_T_T_P_VERB)[keyof typeof H_T_T_P_VERB];
+export declare const hTTPVerbSchema: z.ZodEnum<["DELETE", "GET", "HEAD", "PATCH", "POST", "PUT"]>;
+export declare const IDENTIFIER_TYPE_CODES: {
+    readonly ACSN: "ACSN";
+    readonly BRN: "BRN";
+    readonly DL: "DL";
+    readonly DR: "DR";
+    readonly EN: "EN";
+    readonly FILL: "FILL";
+    readonly JHN: "JHN";
+    readonly MCN: "MCN";
+    readonly MD: "MD";
+    readonly MR: "MR";
+    readonly NIIP: "NIIP";
+    readonly PLAC: "PLAC";
+    readonly PPN: "PPN";
+    readonly PRN: "PRN";
+    readonly SB: "SB";
+    readonly SNO: "SNO";
+    readonly TAX: "TAX";
+    readonly UDI: "UDI";
+};
+export type IdentifierTypeCodes = (typeof IDENTIFIER_TYPE_CODES)[keyof typeof IDENTIFIER_TYPE_CODES];
+export declare const identifierTypeCodesSchema: z.ZodEnum<["ACSN", "BRN", "DL", "DR", "EN", "FILL", "JHN", "MCN", "MD", "MR", "NIIP", "PLAC", "PPN", "PRN", "SB", "SNO", "TAX", "UDI"]>;
+export declare const IDENTIFIER_USE: {
+    readonly OFFICIAL: "official";
+    readonly OLD: "old";
+    readonly SECONDARY: "secondary";
+    readonly TEMP: "temp";
+    readonly USUAL: "usual";
+};
+export type IdentifierUse = (typeof IDENTIFIER_USE)[keyof typeof IDENTIFIER_USE];
+export declare const identifierUseSchema: z.ZodEnum<["official", "old", "secondary", "temp", "usual"]>;
+export declare const IDENTITY_ASSURANCE_LEVEL: {
+    readonly LEVEL1: "level1";
+    readonly LEVEL2: "level2";
+    readonly LEVEL3: "level3";
+    readonly LEVEL4: "level4";
+};
+export type IdentityAssuranceLevel = (typeof IDENTITY_ASSURANCE_LEVEL)[keyof typeof IDENTITY_ASSURANCE_LEVEL];
+export declare const identityAssuranceLevelSchema: z.ZodEnum<["level1", "level2", "level3", "level4"]>;
+export declare const IMAGING_STUDY_SERIES_PERFORMER_FUNCTION: {
+    readonly CON: "CON";
+    readonly PRF: "PRF";
+    readonly REF: "REF";
+    readonly SPRF: "SPRF";
+    readonly VRF: "VRF";
+};
+export type ImagingStudySeriesPerformerFunction = (typeof IMAGING_STUDY_SERIES_PERFORMER_FUNCTION)[keyof typeof IMAGING_STUDY_SERIES_PERFORMER_FUNCTION];
+export declare const imagingStudySeriesPerformerFunctionSchema: z.ZodEnum<["CON", "PRF", "REF", "SPRF", "VRF"]>;
+export declare const IMAGING_STUDY_STATUS: {
     readonly AVAILABLE: "available";
     readonly CANCELLED: "cancelled";
     readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly REGISTERED: "registered";
     readonly UNKNOWN: "unknown";
 };
 export type ImagingStudyStatus = (typeof IMAGING_STUDY_STATUS)[keyof typeof IMAGING_STUDY_STATUS];
-/** DocumentReference/DocumentManifest status: current | superseded | entered-in-error */
-export declare const DOCUMENT_LIST_STATUS: {
+export declare const imagingStudyStatusSchema: z.ZodEnum<["available", "cancelled", "entered-in-error", "registered", "unknown"]>;
+export declare const IMMUNIZATION_EVALUATION_STATUS_CODES: {
+    readonly COMPLETED: "completed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+};
+export type ImmunizationEvaluationStatusCodes = (typeof IMMUNIZATION_EVALUATION_STATUS_CODES)[keyof typeof IMMUNIZATION_EVALUATION_STATUS_CODES];
+export declare const immunizationEvaluationStatusCodesSchema: z.ZodEnum<["completed", "entered-in-error"]>;
+export declare const IMMUNIZATION_FUNCTION_CODES: {
+    readonly AP: "AP";
+    readonly OP: "OP";
+};
+export type ImmunizationFunctionCodes = (typeof IMMUNIZATION_FUNCTION_CODES)[keyof typeof IMMUNIZATION_FUNCTION_CODES];
+export declare const immunizationFunctionCodesSchema: z.ZodEnum<["AP", "OP"]>;
+export declare const IMMUNIZATION_STATUS_CODES: {
+    readonly COMPLETED: "completed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly NOT_DONE: "not-done";
+};
+export type ImmunizationStatusCodes = (typeof IMMUNIZATION_STATUS_CODES)[keyof typeof IMMUNIZATION_STATUS_CODES];
+export declare const immunizationStatusCodesSchema: z.ZodEnum<["completed", "entered-in-error", "not-done"]>;
+export declare const INVOICE_PRICE_COMPONENT_TYPE: {
+    readonly BASE: "base";
+    readonly DEDUCTION: "deduction";
+    readonly DISCOUNT: "discount";
+    readonly INFORMATIONAL: "informational";
+    readonly SURCHARGE: "surcharge";
+    readonly TAX: "tax";
+};
+export type InvoicePriceComponentType = (typeof INVOICE_PRICE_COMPONENT_TYPE)[keyof typeof INVOICE_PRICE_COMPONENT_TYPE];
+export declare const invoicePriceComponentTypeSchema: z.ZodEnum<["base", "deduction", "discount", "informational", "surcharge", "tax"]>;
+export declare const INVOICE_STATUS: {
+    readonly BALANCED: "balanced";
+    readonly CANCELLED: "cancelled";
+    readonly DRAFT: "draft";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly ISSUED: "issued";
+};
+export type InvoiceStatus = (typeof INVOICE_STATUS)[keyof typeof INVOICE_STATUS];
+export declare const invoiceStatusSchema: z.ZodEnum<["balanced", "cancelled", "draft", "entered-in-error", "issued"]>;
+export declare const ISSUE_SEVERITY: {
+    readonly ERROR: "error";
+    readonly FATAL: "fatal";
+    readonly INFORMATION: "information";
+    readonly WARNING: "warning";
+};
+export type IssueSeverity = (typeof ISSUE_SEVERITY)[keyof typeof ISSUE_SEVERITY];
+export declare const issueSeveritySchema: z.ZodEnum<["error", "fatal", "information", "warning"]>;
+export declare const ISSUE_TYPE: {
+    readonly BUSINESS_RULE: "business-rule";
+    readonly CODE_INVALID: "code-invalid";
+    readonly CONFLICT: "conflict";
+    readonly DELETED: "deleted";
+    readonly DUPLICATE: "duplicate";
+    readonly EXCEPTION: "exception";
+    readonly EXPIRED: "expired";
+    readonly EXTENSION: "extension";
+    readonly FORBIDDEN: "forbidden";
+    readonly INCOMPLETE: "incomplete";
+    readonly INFORMATIONAL: "informational";
+    readonly INVALID: "invalid";
+    readonly INVARIANT: "invariant";
+    readonly LOCK_ERROR: "lock-error";
+    readonly LOGIN: "login";
+    readonly MULTIPLE_MATCHES: "multiple-matches";
+    readonly NO_STORE: "no-store";
+    readonly NOT_FOUND: "not-found";
+    readonly NOT_SUPPORTED: "not-supported";
+    readonly PROCESSING: "processing";
+    readonly REQUIRED: "required";
+    readonly SECURITY: "security";
+    readonly STRUCTURE: "structure";
+    readonly SUPPRESSED: "suppressed";
+    readonly THROTTLED: "throttled";
+    readonly TIMEOUT: "timeout";
+    readonly TOO_COSTLY: "too-costly";
+    readonly TOO_LONG: "too-long";
+    readonly TRANSIENT: "transient";
+    readonly UNKNOWN: "unknown";
+    readonly VALUE: "value";
+};
+export type IssueType = (typeof ISSUE_TYPE)[keyof typeof ISSUE_TYPE];
+export declare const issueTypeSchema: z.ZodEnum<["business-rule", "code-invalid", "conflict", "deleted", "duplicate", "exception", "expired", "extension", "forbidden", "incomplete", "informational", "invalid", "invariant", "lock-error", "login", "multiple-matches", "no-store", "not-found", "not-supported", "processing", "required", "security", "structure", "suppressed", "throttled", "timeout", "too-costly", "too-long", "transient", "unknown", "value"]>;
+export declare const LIBRARY_TYPE: {
+    readonly ASSET_COLLECTION: "asset-collection";
+    readonly LOGIC_LIBRARY: "logic-library";
+    readonly MODEL_DEFINITION: "model-definition";
+    readonly MODULE_DEFINITION: "module-definition";
+};
+export type LibraryType = (typeof LIBRARY_TYPE)[keyof typeof LIBRARY_TYPE];
+export declare const libraryTypeSchema: z.ZodEnum<["asset-collection", "logic-library", "model-definition", "module-definition"]>;
+export declare const LINK_TYPE: {
+    readonly REFER: "refer";
+    readonly REPLACED_BY: "replaced-by";
+    readonly REPLACES: "replaces";
+    readonly SEEALSO: "seealso";
+};
+export type LinkType = (typeof LINK_TYPE)[keyof typeof LINK_TYPE];
+export declare const linkTypeSchema: z.ZodEnum<["refer", "replaced-by", "replaces", "seealso"]>;
+export declare const LINKAGE_TYPE: {
+    readonly ALTERNATE: "alternate";
+    readonly HISTORICAL: "historical";
+    readonly SOURCE: "source";
+};
+export type LinkageType = (typeof LINKAGE_TYPE)[keyof typeof LINKAGE_TYPE];
+export declare const linkageTypeSchema: z.ZodEnum<["alternate", "historical", "source"]>;
+export declare const LIST_MODE: {
+    readonly CHANGES: "changes";
+    readonly SNAPSHOT: "snapshot";
+    readonly WORKING: "working";
+};
+export type ListMode = (typeof LIST_MODE)[keyof typeof LIST_MODE];
+export declare const listModeSchema: z.ZodEnum<["changes", "snapshot", "working"]>;
+export declare const LIST_STATUS: {
     readonly CURRENT: "current";
-    readonly SUPERSEDED: "superseded";
     readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly RETIRED: "retired";
 };
-export type DocumentListStatus = (typeof DOCUMENT_LIST_STATUS)[keyof typeof DOCUMENT_LIST_STATUS];
-/** Consent Data meaning: instance | related | dependents | authoredby */
-export declare const CONSENT_DATA_MEANING: {
+export type ListStatus = (typeof LIST_STATUS)[keyof typeof LIST_STATUS];
+export declare const listStatusSchema: z.ZodEnum<["current", "entered-in-error", "retired"]>;
+export declare const LOCATION_MODE: {
     readonly INSTANCE: "instance";
-    readonly RELATED: "related";
-    readonly DEPENDENTS: "dependents";
-    readonly AUTHORED_BY: "authoredby";
+    readonly KIND: "kind";
 };
-export type ConsentDataMeaning = (typeof CONSENT_DATA_MEANING)[keyof typeof CONSENT_DATA_MEANING];
+export type LocationMode = (typeof LOCATION_MODE)[keyof typeof LOCATION_MODE];
+export declare const locationModeSchema: z.ZodEnum<["instance", "kind"]>;
+export declare const LOCATION_STATUS: {
+    readonly ACTIVE: "active";
+    readonly INACTIVE: "inactive";
+    readonly SUSPENDED: "suspended";
+};
+export type LocationStatus = (typeof LOCATION_STATUS)[keyof typeof LOCATION_STATUS];
+export declare const locationStatusSchema: z.ZodEnum<["active", "inactive", "suspended"]>;
+export declare const MARITAL_STATUS_CODES: {
+    readonly A: "A";
+    readonly D: "D";
+    readonly I: "I";
+    readonly L: "L";
+    readonly M: "M";
+    readonly P: "P";
+    readonly S: "S";
+    readonly T: "T";
+    readonly U: "U";
+    readonly UNK: "UNK";
+    readonly W: "W";
+};
+export type MaritalStatusCodes = (typeof MARITAL_STATUS_CODES)[keyof typeof MARITAL_STATUS_CODES];
+export declare const maritalStatusCodesSchema: z.ZodEnum<["A", "D", "I", "L", "M", "P", "S", "T", "U", "UNK", "W"]>;
+export declare const MEASURE_DATA_USAGE: {
+    readonly RISK_ADJUSTMENT_FACTOR: "risk-adjustment-factor";
+    readonly SUPPLEMENTAL_DATA: "supplemental-data";
+};
+export type MeasureDataUsage = (typeof MEASURE_DATA_USAGE)[keyof typeof MEASURE_DATA_USAGE];
+export declare const measureDataUsageSchema: z.ZodEnum<["risk-adjustment-factor", "supplemental-data"]>;
+export declare const MEASURE_IMPROVEMENT_NOTATION: {
+    readonly DECREASE: "decrease";
+    readonly INCREASE: "increase";
+};
+export type MeasureImprovementNotation = (typeof MEASURE_IMPROVEMENT_NOTATION)[keyof typeof MEASURE_IMPROVEMENT_NOTATION];
+export declare const measureImprovementNotationSchema: z.ZodEnum<["decrease", "increase"]>;
+export declare const MEASURE_POPULATION_TYPE: {
+    readonly DENOMINATOR: "denominator";
+    readonly DENOMINATOR_EXCEPTION: "denominator-exception";
+    readonly DENOMINATOR_EXCLUSION: "denominator-exclusion";
+    readonly INITIAL_POPULATION: "initial-population";
+    readonly MEASURE_OBSERVATION: "measure-observation";
+    readonly MEASURE_POPULATION: "measure-population";
+    readonly MEASURE_POPULATION_EXCLUSION: "measure-population-exclusion";
+    readonly NUMERATOR: "numerator";
+    readonly NUMERATOR_EXCLUSION: "numerator-exclusion";
+};
+export type MeasurePopulationType = (typeof MEASURE_POPULATION_TYPE)[keyof typeof MEASURE_POPULATION_TYPE];
+export declare const measurePopulationTypeSchema: z.ZodEnum<["denominator", "denominator-exception", "denominator-exclusion", "initial-population", "measure-observation", "measure-population", "measure-population-exclusion", "numerator", "numerator-exclusion"]>;
+export declare const MEASURE_REPORT_STATUS: {
+    readonly COMPLETE: "complete";
+    readonly ERROR: "error";
+    readonly PENDING: "pending";
+};
+export type MeasureReportStatus = (typeof MEASURE_REPORT_STATUS)[keyof typeof MEASURE_REPORT_STATUS];
+export declare const measureReportStatusSchema: z.ZodEnum<["complete", "error", "pending"]>;
+export declare const MEASURE_REPORT_TYPE: {
+    readonly DATA_COLLECTION: "data-collection";
+    readonly INDIVIDUAL: "individual";
+    readonly SUBJECT_LIST: "subject-list";
+    readonly SUMMARY: "summary";
+};
+export type MeasureReportType = (typeof MEASURE_REPORT_TYPE)[keyof typeof MEASURE_REPORT_TYPE];
+export declare const measureReportTypeSchema: z.ZodEnum<["data-collection", "individual", "subject-list", "summary"]>;
+export declare const MEASURE_SCORING: {
+    readonly COHORT: "cohort";
+    readonly CONTINUOUS_VARIABLE: "continuous-variable";
+    readonly PROPORTION: "proportion";
+    readonly RATIO: "ratio";
+};
+export type MeasureScoring = (typeof MEASURE_SCORING)[keyof typeof MEASURE_SCORING];
+export declare const measureScoringSchema: z.ZodEnum<["cohort", "continuous-variable", "proportion", "ratio"]>;
+export declare const MEASURE_TYPE: {
+    readonly COMPOSITE: "composite";
+    readonly OUTCOME: "outcome";
+    readonly PATIENT_REPORTED_OUTCOME: "patient-reported-outcome";
+    readonly PROCESS: "process";
+    readonly STRUCTURE: "structure";
+};
+export type MeasureType = (typeof MEASURE_TYPE)[keyof typeof MEASURE_TYPE];
+export declare const measureTypeSchema: z.ZodEnum<["composite", "outcome", "patient-reported-outcome", "process", "structure"]>;
+export declare const MEDIA_TYPE: {
+    readonly AUDIO: "audio";
+    readonly IMAGE: "image";
+    readonly VIDEO: "video";
+};
+export type MediaType = (typeof MEDIA_TYPE)[keyof typeof MEDIA_TYPE];
+export declare const mediaTypeSchema: z.ZodEnum<["audio", "image", "video"]>;
+export declare const MEDIA_TYPE_CODE: {
+    readonly _110010: "110010";
+    readonly _110030: "110030";
+    readonly _110031: "110031";
+    readonly _110032: "110032";
+    readonly _110033: "110033";
+    readonly _110034: "110034";
+    readonly _110035: "110035";
+    readonly _110036: "110036";
+    readonly _110037: "110037";
+    readonly _110038: "110038";
+};
+export type MediaTypeCode = (typeof MEDIA_TYPE_CODE)[keyof typeof MEDIA_TYPE_CODE];
+export declare const mediaTypeCodeSchema: z.ZodEnum<["110010", "110030", "110031", "110032", "110033", "110034", "110035", "110036", "110037", "110038"]>;
+export declare const MEDICATION_ADMINISTRATION_STATUS_CODES: {
+    readonly COMPLETED: "completed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly IN_PROGRESS: "in-progress";
+    readonly NOT_DONE: "not-done";
+    readonly ON_HOLD: "on-hold";
+    readonly STOPPED: "stopped";
+    readonly UNKNOWN: "unknown";
+};
+export type MedicationAdministrationStatusCodes = (typeof MEDICATION_ADMINISTRATION_STATUS_CODES)[keyof typeof MEDICATION_ADMINISTRATION_STATUS_CODES];
+export declare const medicationAdministrationStatusCodesSchema: z.ZodEnum<["completed", "entered-in-error", "in-progress", "not-done", "on-hold", "stopped", "unknown"]>;
+export declare const MEDICATION_DISPENSE_STATUS_CODES: {
+    readonly CANCELLED: "cancelled";
+    readonly COMPLETED: "completed";
+    readonly DECLINED: "declined";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly IN_PROGRESS: "in-progress";
+    readonly ON_HOLD: "on-hold";
+    readonly PREPARATION: "preparation";
+    readonly STOPPED: "stopped";
+    readonly UNKNOWN: "unknown";
+};
+export type MedicationDispenseStatusCodes = (typeof MEDICATION_DISPENSE_STATUS_CODES)[keyof typeof MEDICATION_DISPENSE_STATUS_CODES];
+export declare const medicationDispenseStatusCodesSchema: z.ZodEnum<["cancelled", "completed", "declined", "entered-in-error", "in-progress", "on-hold", "preparation", "stopped", "unknown"]>;
+export declare const MEDICATION_KNOWLEDGE_STATUS_CODES: {
+    readonly ACTIVE: "active";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly INACTIVE: "inactive";
+};
+export type MedicationKnowledgeStatusCodes = (typeof MEDICATION_KNOWLEDGE_STATUS_CODES)[keyof typeof MEDICATION_KNOWLEDGE_STATUS_CODES];
+export declare const medicationKnowledgeStatusCodesSchema: z.ZodEnum<["active", "entered-in-error", "inactive"]>;
+export declare const MEDICATION_REQUEST_INTENT: {
+    readonly FILLER_ORDER: "filler-order";
+    readonly INSTANCE_ORDER: "instance-order";
+    readonly OPTION: "option";
+    readonly ORDER: "order";
+    readonly ORIGINAL_ORDER: "original-order";
+    readonly PLAN: "plan";
+    readonly PROPOSAL: "proposal";
+    readonly REFLEX_ORDER: "reflex-order";
+};
+export type MedicationRequestIntent = (typeof MEDICATION_REQUEST_INTENT)[keyof typeof MEDICATION_REQUEST_INTENT];
+export declare const medicationRequestIntentSchema: z.ZodEnum<["filler-order", "instance-order", "option", "order", "original-order", "plan", "proposal", "reflex-order"]>;
+export declare const MEDICATION_STATUS_CODES: {
+    readonly ACTIVE: "active";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly INACTIVE: "inactive";
+};
+export type MedicationStatusCodes = (typeof MEDICATION_STATUS_CODES)[keyof typeof MEDICATION_STATUS_CODES];
+export declare const medicationStatusCodesSchema: z.ZodEnum<["active", "entered-in-error", "inactive"]>;
+export declare const MEDICATIONREQUEST_STATUS: {
+    readonly ACTIVE: "active";
+    readonly CANCELLED: "cancelled";
+    readonly COMPLETED: "completed";
+    readonly DRAFT: "draft";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly ON_HOLD: "on-hold";
+    readonly STOPPED: "stopped";
+    readonly UNKNOWN: "unknown";
+};
+export type MedicationrequestStatus = (typeof MEDICATIONREQUEST_STATUS)[keyof typeof MEDICATIONREQUEST_STATUS];
+export declare const medicationrequestStatusSchema: z.ZodEnum<["active", "cancelled", "completed", "draft", "entered-in-error", "on-hold", "stopped", "unknown"]>;
+export declare const MESSAGE_SIGNIFICANCE_CATEGORY: {
+    readonly CONSEQUENCE: "consequence";
+    readonly CURRENCY: "currency";
+    readonly NOTIFICATION: "notification";
+};
+export type MessageSignificanceCategory = (typeof MESSAGE_SIGNIFICANCE_CATEGORY)[keyof typeof MESSAGE_SIGNIFICANCE_CATEGORY];
+export declare const messageSignificanceCategorySchema: z.ZodEnum<["consequence", "currency", "notification"]>;
+export declare const MESSAGE_TRANSPORT: {
+    readonly FTP: "ftp";
+    readonly HTTP: "http";
+    readonly MLLP: "mllp";
+};
+export type MessageTransport = (typeof MESSAGE_TRANSPORT)[keyof typeof MESSAGE_TRANSPORT];
+export declare const messageTransportSchema: z.ZodEnum<["ftp", "http", "mllp"]>;
+export declare const MESSAGEHEADER_RESPONSE_REQUEST: {
+    readonly ALWAYS: "always";
+    readonly NEVER: "never";
+    readonly ON_ERROR: "on-error";
+    readonly ON_SUCCESS: "on-success";
+};
+export type MessageheaderResponseRequest = (typeof MESSAGEHEADER_RESPONSE_REQUEST)[keyof typeof MESSAGEHEADER_RESPONSE_REQUEST];
+export declare const messageheaderResponseRequestSchema: z.ZodEnum<["always", "never", "on-error", "on-success"]>;
+export declare const NAME_USE: {
+    readonly ANONYMOUS: "anonymous";
+    readonly MAIDEN: "maiden";
+    readonly NICKNAME: "nickname";
+    readonly OFFICIAL: "official";
+    readonly OLD: "old";
+    readonly TEMP: "temp";
+    readonly USUAL: "usual";
+};
+export type NameUse = (typeof NAME_USE)[keyof typeof NAME_USE];
+export declare const nameUseSchema: z.ZodEnum<["anonymous", "maiden", "nickname", "official", "old", "temp", "usual"]>;
+export declare const NAMING_SYSTEM_IDENTIFIER_TYPE: {
+    readonly OID: "oid";
+    readonly OTHER: "other";
+    readonly URI: "uri";
+    readonly UUID: "uuid";
+};
+export type NamingSystemIdentifierType = (typeof NAMING_SYSTEM_IDENTIFIER_TYPE)[keyof typeof NAMING_SYSTEM_IDENTIFIER_TYPE];
+export declare const namingSystemIdentifierTypeSchema: z.ZodEnum<["oid", "other", "uri", "uuid"]>;
+export declare const NAMING_SYSTEM_TYPE: {
+    readonly CODESYSTEM: "codesystem";
+    readonly IDENTIFIER: "identifier";
+    readonly ROOT: "root";
+};
+export type NamingSystemType = (typeof NAMING_SYSTEM_TYPE)[keyof typeof NAMING_SYSTEM_TYPE];
+export declare const namingSystemTypeSchema: z.ZodEnum<["codesystem", "identifier", "root"]>;
+export declare const NARRATIVE_STATUS: {
+    readonly ADDITIONAL: "additional";
+    readonly EMPTY: "empty";
+    readonly EXTENSIONS: "extensions";
+    readonly GENERATED: "generated";
+};
+export type NarrativeStatus = (typeof NARRATIVE_STATUS)[keyof typeof NARRATIVE_STATUS];
+export declare const narrativeStatusSchema: z.ZodEnum<["additional", "empty", "extensions", "generated"]>;
+export declare const NOTE_TYPE: {
+    readonly DISPLAY: "display";
+    readonly PRINT: "print";
+    readonly PRINTOPER: "printoper";
+};
+export type NoteType = (typeof NOTE_TYPE)[keyof typeof NOTE_TYPE];
+export declare const noteTypeSchema: z.ZodEnum<["display", "print", "printoper"]>;
+export declare const OBJECT_LIFECYCLE_EVENTS: {
+    readonly _1: "1";
+    readonly _10: "10";
+    readonly _11: "11";
+    readonly _12: "12";
+    readonly _13: "13";
+    readonly _14: "14";
+    readonly _15: "15";
+    readonly _2: "2";
+    readonly _3: "3";
+    readonly _4: "4";
+    readonly _5: "5";
+    readonly _6: "6";
+    readonly _7: "7";
+    readonly _8: "8";
+    readonly _9: "9";
+    readonly ACCESS: "access";
+    readonly AMEND: "amend";
+    readonly ARCHIVE: "archive";
+    readonly ATTEST: "attest";
+    readonly DECRYPT: "decrypt";
+    readonly DEIDENTIFY: "deidentify";
+    readonly DEPRECATE: "deprecate";
+    readonly DESTROY: "destroy";
+    readonly DISCLOSE: "disclose";
+    readonly ENCRYPT: "encrypt";
+    readonly EXTRACT: "extract";
+    readonly HOLD: "hold";
+    readonly LINK: "link";
+    readonly MERGE: "merge";
+    readonly ORIGINATE: "originate";
+    readonly PSEUDONYMIZE: "pseudonymize";
+    readonly REACTIVATE: "reactivate";
+    readonly RECEIVE: "receive";
+    readonly REIDENTIFY: "reidentify";
+    readonly REPORT: "report";
+    readonly RESTORE: "restore";
+    readonly TRANSFORM: "transform";
+    readonly TRANSMIT: "transmit";
+    readonly UNHOLD: "unhold";
+    readonly UNLINK: "unlink";
+    readonly UNMERGE: "unmerge";
+    readonly VERIFY: "verify";
+};
+export type ObjectLifecycleEvents = (typeof OBJECT_LIFECYCLE_EVENTS)[keyof typeof OBJECT_LIFECYCLE_EVENTS];
+export declare const objectLifecycleEventsSchema: z.ZodEnum<["1", "10", "11", "12", "13", "14", "15", "2", "3", "4", "5", "6", "7", "8", "9", "access", "amend", "archive", "attest", "decrypt", "deidentify", "deprecate", "destroy", "disclose", "encrypt", "extract", "hold", "link", "merge", "originate", "pseudonymize", "reactivate", "receive", "reidentify", "report", "restore", "transform", "transmit", "unhold", "unlink", "unmerge", "verify"]>;
+export declare const OBSERVATION_DATA_TYPE: {
+    readonly CODEABLECONCEPT: "CodeableConcept";
+    readonly PERIOD: "Period";
+    readonly QUANTITY: "Quantity";
+    readonly RANGE: "Range";
+    readonly RATIO: "Ratio";
+    readonly SAMPLEDDATA: "SampledData";
+    readonly BOOLEAN: "boolean";
+    readonly DATETIME: "dateTime";
+    readonly INTEGER: "integer";
+    readonly STRING: "string";
+    readonly TIME: "time";
+};
+export type ObservationDataType = (typeof OBSERVATION_DATA_TYPE)[keyof typeof OBSERVATION_DATA_TYPE];
+export declare const observationDataTypeSchema: z.ZodEnum<["CodeableConcept", "Period", "Quantity", "Range", "Ratio", "SampledData", "boolean", "dateTime", "integer", "string", "time"]>;
+export declare const OBSERVATION_INTERPRETATION_CODES: {
+    readonly _EMPTY: "<";
+    readonly _EMPTY_2: ">";
+    readonly A: "A";
+    readonly AA: "AA";
+    readonly AC: "AC";
+    readonly B: "B";
+    readonly CAR: "CAR";
+    readonly CARRIER: "Carrier";
+    readonly D: "D";
+    readonly DET: "DET";
+    readonly E: "E";
+    readonly EX: "EX";
+    readonly EXP: "EXP";
+    readonly H: "H";
+    readonly H_2: "H>";
+    readonly HH: "HH";
+    readonly HM: "HM";
+    readonly HU: "HU";
+    readonly HX: "HX";
+    readonly I: "I";
+    readonly IE: "IE";
+    readonly IND: "IND";
+    readonly L: "L";
+    readonly L_2: "L<";
+    readonly LL: "LL";
+    readonly LU: "LU";
+    readonly LX: "LX";
+    readonly MS: "MS";
+    readonly N: "N";
+    readonly NCL: "NCL";
+    readonly ND: "ND";
+    readonly NEG: "NEG";
+    readonly NR: "NR";
+    readonly NS: "NS";
+    readonly OBX: "OBX";
+    readonly OBSERVATIONINTERPRETATIONDETECTION: "ObservationInterpretationDetection";
+    readonly OBSERVATIONINTERPRETATIONEXPECTATION: "ObservationInterpretationExpectation";
+    readonly POS: "POS";
+    readonly QCF: "QCF";
+    readonly R: "R";
+    readonly RR: "RR";
+    readonly REACTIVITYOBSERVATIONINTERPRETATION: "ReactivityObservationInterpretation";
+    readonly S: "S";
+    readonly SDD: "SDD";
+    readonly SYN_R: "SYN-R";
+    readonly SYN_S: "SYN-S";
+    readonly TOX: "TOX";
+    readonly U: "U";
+    readonly UNE: "UNE";
+    readonly VS: "VS";
+    readonly W: "W";
+    readonly WR: "WR";
+    readonly GENETICOBSERVATIONINTERPRETATION: "_GeneticObservationInterpretation";
+    readonly OBSERVATIONINTERPRETATIONCHANGE: "_ObservationInterpretationChange";
+    readonly OBSERVATIONINTERPRETATIONEXCEPTIONS: "_ObservationInterpretationExceptions";
+    readonly OBSERVATIONINTERPRETATIONNORMALITY: "_ObservationInterpretationNormality";
+    readonly OBSERVATIONINTERPRETATIONSUSCEPTIBILITY: "_ObservationInterpretationSusceptibility";
+};
+export type ObservationInterpretationCodes = (typeof OBSERVATION_INTERPRETATION_CODES)[keyof typeof OBSERVATION_INTERPRETATION_CODES];
+export declare const observationInterpretationCodesSchema: z.ZodEnum<["<", ">", "A", "AA", "AC", "B", "CAR", "Carrier", "D", "DET", "E", "EX", "EXP", "H", "H>", "HH", "HM", "HU", "HX", "I", "IE", "IND", "L", "L<", "LL", "LU", "LX", "MS", "N", "NCL", "ND", "NEG", "NR", "NS", "OBX", "ObservationInterpretationDetection", "ObservationInterpretationExpectation", "POS", "QCF", "R", "RR", "ReactivityObservationInterpretation", "S", "SDD", "SYN-R", "SYN-S", "TOX", "U", "UNE", "VS", "W", "WR", "_GeneticObservationInterpretation", "_ObservationInterpretationChange", "_ObservationInterpretationExceptions", "_ObservationInterpretationNormality", "_ObservationInterpretationSusceptibility"]>;
+export declare const OBSERVATION_RANGE_CATEGORY: {
+    readonly ABSOLUTE: "absolute";
+    readonly CRITICAL: "critical";
+    readonly REFERENCE: "reference";
+};
+export type ObservationRangeCategory = (typeof OBSERVATION_RANGE_CATEGORY)[keyof typeof OBSERVATION_RANGE_CATEGORY];
+export declare const observationRangeCategorySchema: z.ZodEnum<["absolute", "critical", "reference"]>;
+export declare const OBSERVATION_REFERENCE_RANGE_MEANING_CODES: {
+    readonly ENDOCRINE: "endocrine";
+    readonly FOLLICULAR: "follicular";
+    readonly LUTEAL: "luteal";
+    readonly MIDCYCLE: "midcycle";
+    readonly NORMAL: "normal";
+    readonly POST: "post";
+    readonly POSTMENOPAUSAL: "postmenopausal";
+    readonly PRE: "pre";
+    readonly PRE_PUBERTY: "pre-puberty";
+    readonly RECOMMENDED: "recommended";
+    readonly THERAPEUTIC: "therapeutic";
+    readonly TREATMENT: "treatment";
+    readonly TYPE: "type";
+};
+export type ObservationReferenceRangeMeaningCodes = (typeof OBSERVATION_REFERENCE_RANGE_MEANING_CODES)[keyof typeof OBSERVATION_REFERENCE_RANGE_MEANING_CODES];
+export declare const observationReferenceRangeMeaningCodesSchema: z.ZodEnum<["endocrine", "follicular", "luteal", "midcycle", "normal", "post", "postmenopausal", "pre", "pre-puberty", "recommended", "therapeutic", "treatment", "type"]>;
+export declare const OBSERVATION_STATUS: {
+    readonly AMENDED: "amended";
+    readonly CANCELLED: "cancelled";
+    readonly CORRECTED: "corrected";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly FINAL: "final";
+    readonly PRELIMINARY: "preliminary";
+    readonly REGISTERED: "registered";
+    readonly UNKNOWN: "unknown";
+};
+export type ObservationStatus = (typeof OBSERVATION_STATUS)[keyof typeof OBSERVATION_STATUS];
+export declare const observationStatusSchema: z.ZodEnum<["amended", "cancelled", "corrected", "entered-in-error", "final", "preliminary", "registered", "unknown"]>;
+export declare const OPERATION_KIND: {
+    readonly OPERATION: "operation";
+    readonly QUERY: "query";
+};
+export type OperationKind = (typeof OPERATION_KIND)[keyof typeof OPERATION_KIND];
+export declare const operationKindSchema: z.ZodEnum<["operation", "query"]>;
+export declare const OPERATION_PARAMETER_USE: {
+    readonly IN: "in";
+    readonly OUT: "out";
+};
+export type OperationParameterUse = (typeof OPERATION_PARAMETER_USE)[keyof typeof OPERATION_PARAMETER_USE];
+export declare const operationParameterUseSchema: z.ZodEnum<["in", "out"]>;
+export declare const ORIENTATION_TYPE: {
+    readonly ANTISENSE: "antisense";
+    readonly SENSE: "sense";
+};
+export type OrientationType = (typeof ORIENTATION_TYPE)[keyof typeof ORIENTATION_TYPE];
+export declare const orientationTypeSchema: z.ZodEnum<["antisense", "sense"]>;
+export declare const PARTICIPANT_REQUIRED: {
+    readonly INFORMATION_ONLY: "information-only";
+    readonly OPTIONAL: "optional";
+    readonly REQUIRED: "required";
+};
+export type ParticipantRequired = (typeof PARTICIPANT_REQUIRED)[keyof typeof PARTICIPANT_REQUIRED];
+export declare const participantRequiredSchema: z.ZodEnum<["information-only", "optional", "required"]>;
+export declare const PARTICIPATION_STATUS: {
+    readonly ACCEPTED: "accepted";
+    readonly DECLINED: "declined";
+    readonly NEEDS_ACTION: "needs-action";
+    readonly TENTATIVE: "tentative";
+};
+export type ParticipationStatus = (typeof PARTICIPATION_STATUS)[keyof typeof PARTICIPATION_STATUS];
+export declare const participationStatusSchema: z.ZodEnum<["accepted", "declined", "needs-action", "tentative"]>;
+export declare const PLAN_DEFINITION_TYPE: {
+    readonly CLINICAL_PROTOCOL: "clinical-protocol";
+    readonly ECA_RULE: "eca-rule";
+    readonly ORDER_SET: "order-set";
+    readonly WORKFLOW_DEFINITION: "workflow-definition";
+};
+export type PlanDefinitionType = (typeof PLAN_DEFINITION_TYPE)[keyof typeof PLAN_DEFINITION_TYPE];
+export declare const planDefinitionTypeSchema: z.ZodEnum<["clinical-protocol", "eca-rule", "order-set", "workflow-definition"]>;
+export declare const PRECISION_ESTIMATE_TYPE: {
+    readonly CI: "CI";
+    readonly IQR: "IQR";
+    readonly SD: "SD";
+    readonly SE: "SE";
+};
+export type PrecisionEstimateType = (typeof PRECISION_ESTIMATE_TYPE)[keyof typeof PRECISION_ESTIMATE_TYPE];
+export declare const precisionEstimateTypeSchema: z.ZodEnum<["CI", "IQR", "SD", "SE"]>;
+export declare const PROPERTY_REPRESENTATION: {
+    readonly CDATEXT: "cdaText";
+    readonly TYPEATTR: "typeAttr";
+    readonly XHTML: "xhtml";
+    readonly XMLATTR: "xmlAttr";
+    readonly XMLTEXT: "xmlText";
+};
+export type PropertyRepresentation = (typeof PROPERTY_REPRESENTATION)[keyof typeof PROPERTY_REPRESENTATION];
+export declare const propertyRepresentationSchema: z.ZodEnum<["cdaText", "typeAttr", "xhtml", "xmlAttr", "xmlText"]>;
+export declare const PROPERTY_TYPE: {
+    readonly CODING: "Coding";
+    readonly BOOLEAN: "boolean";
+    readonly CODE: "code";
+    readonly DATETIME: "dateTime";
+    readonly DECIMAL: "decimal";
+    readonly INTEGER: "integer";
+    readonly STRING: "string";
+};
+export type PropertyType = (typeof PROPERTY_TYPE)[keyof typeof PROPERTY_TYPE];
+export declare const propertyTypeSchema: z.ZodEnum<["Coding", "boolean", "code", "dateTime", "decimal", "integer", "string"]>;
+export declare const PROVENANCE_ACTIVITY_TYPE: {
+    readonly ADM: "ADM";
+    readonly ALY: "ALY";
+    readonly ANONY: "ANONY";
+    readonly APPEND: "APPEND";
+    readonly ATND: "ATND";
+    readonly AUT: "AUT";
+    readonly AUTHEN: "AUTHEN";
+    readonly BBY: "BBY";
+    readonly BEN: "BEN";
+    readonly CAGNT: "CAGNT";
+    readonly CALLBCK: "CALLBCK";
+    readonly CAT: "CAT";
+    readonly CON: "CON";
+    readonly COV: "COV";
+    readonly CREATE: "CREATE";
+    readonly CSM: "CSM";
+    readonly CST: "CST";
+    readonly DEID: "DEID";
+    readonly DELETE: "DELETE";
+    readonly DEV: "DEV";
+    readonly DIR: "DIR";
+    readonly DIS: "DIS";
+    readonly DIST: "DIST";
+    readonly DON: "DON";
+    readonly DST: "DST";
+    readonly ELOC: "ELOC";
+    readonly ENT: "ENT";
+    readonly ESC: "ESC";
+    readonly EXPAGNT: "EXPAGNT";
+    readonly EXPART: "EXPART";
+    readonly EXPTRGT: "EXPTRGT";
+    readonly EXSRC: "EXSRC";
+    readonly GUAR: "GUAR";
+    readonly HLD: "HLD";
+    readonly IND: "IND";
+    readonly INF: "INF";
+    readonly IRCP: "IRCP";
+    readonly LA: "LA";
+    readonly LABEL: "LABEL";
+    readonly LOC: "LOC";
+    readonly MASK: "MASK";
+    readonly NOT: "NOT";
+    readonly NRD: "NRD";
+    readonly NULLIFY: "NULLIFY";
+    readonly ORG: "ORG";
+    readonly PART: "PART";
+    readonly PPRF: "PPRF";
+    readonly PRCP: "PRCP";
+    readonly PRD: "PRD";
+    readonly PRF: "PRF";
+    readonly PSEUD: "PSEUD";
+    readonly RCT: "RCT";
+    readonly RCV: "RCV";
+    readonly RDV: "RDV";
+    readonly REF: "REF";
+    readonly REFB: "REFB";
+    readonly REFT: "REFT";
+    readonly RESP: "RESP";
+    readonly RML: "RML";
+    readonly SBJ: "SBJ";
+    readonly SPC: "SPC";
+    readonly SPRF: "SPRF";
+    readonly TPA: "TPA";
+    readonly TRANS: "TRANS";
+    readonly TRC: "TRC";
+    readonly UPDATE: "UPDATE";
+    readonly VIA: "VIA";
+    readonly VRF: "VRF";
+    readonly WIT: "WIT";
+    readonly PARTICIPATIONANCILLARY: "_ParticipationAncillary";
+    readonly PARTICIPATIONINFORMATIONGENERATOR: "_ParticipationInformationGenerator";
+};
+export type ProvenanceActivityType = (typeof PROVENANCE_ACTIVITY_TYPE)[keyof typeof PROVENANCE_ACTIVITY_TYPE];
+export declare const provenanceActivityTypeSchema: z.ZodEnum<["ADM", "ALY", "ANONY", "APPEND", "ATND", "AUT", "AUTHEN", "BBY", "BEN", "CAGNT", "CALLBCK", "CAT", "CON", "COV", "CREATE", "CSM", "CST", "DEID", "DELETE", "DEV", "DIR", "DIS", "DIST", "DON", "DST", "ELOC", "ENT", "ESC", "EXPAGNT", "EXPART", "EXPTRGT", "EXSRC", "GUAR", "HLD", "IND", "INF", "IRCP", "LA", "LABEL", "LOC", "MASK", "NOT", "NRD", "NULLIFY", "ORG", "PART", "PPRF", "PRCP", "PRD", "PRF", "PSEUD", "RCT", "RCV", "RDV", "REF", "REFB", "REFT", "RESP", "RML", "SBJ", "SPC", "SPRF", "TPA", "TRANS", "TRC", "UPDATE", "VIA", "VRF", "WIT", "_ParticipationAncillary", "_ParticipationInformationGenerator"]>;
+export declare const PROVENANCE_ENTITY_ROLE: {
+    readonly DERIVATION: "derivation";
+    readonly QUOTATION: "quotation";
+    readonly REMOVAL: "removal";
+    readonly REVISION: "revision";
+    readonly SOURCE: "source";
+};
+export type ProvenanceEntityRole = (typeof PROVENANCE_ENTITY_ROLE)[keyof typeof PROVENANCE_ENTITY_ROLE];
+export declare const provenanceEntityRoleSchema: z.ZodEnum<["derivation", "quotation", "removal", "revision", "source"]>;
+export declare const PROVENANCE_PARTICIPANT_TYPE: {
+    readonly ASSEMBLER: "assembler";
+    readonly ATTESTER: "attester";
+    readonly AUTHOR: "author";
+    readonly COMPOSER: "composer";
+    readonly CUSTODIAN: "custodian";
+    readonly ENTERER: "enterer";
+    readonly INFORMANT: "informant";
+    readonly LEGAL: "legal";
+    readonly PERFORMER: "performer";
+    readonly VERIFIER: "verifier";
+};
+export type ProvenanceParticipantType = (typeof PROVENANCE_PARTICIPANT_TYPE)[keyof typeof PROVENANCE_PARTICIPANT_TYPE];
+export declare const provenanceParticipantTypeSchema: z.ZodEnum<["assembler", "attester", "author", "composer", "custodian", "enterer", "informant", "legal", "performer", "verifier"]>;
+export declare const PUBLICATION_STATUS: {
+    readonly ACTIVE: "active";
+    readonly DRAFT: "draft";
+    readonly RETIRED: "retired";
+    readonly UNKNOWN: "unknown";
+};
+export type PublicationStatus = (typeof PUBLICATION_STATUS)[keyof typeof PUBLICATION_STATUS];
+export declare const publicationStatusSchema: z.ZodEnum<["active", "draft", "retired", "unknown"]>;
+export declare const QUALITY_OF_EVIDENCE_RATING: {
+    readonly HIGH: "high";
+    readonly LOW: "low";
+    readonly MODERATE: "moderate";
+    readonly VERY_LOW: "very-low";
+};
+export type QualityOfEvidenceRating = (typeof QUALITY_OF_EVIDENCE_RATING)[keyof typeof QUALITY_OF_EVIDENCE_RATING];
+export declare const qualityOfEvidenceRatingSchema: z.ZodEnum<["high", "low", "moderate", "very-low"]>;
+export declare const QUALITY_TYPE: {
+    readonly INDEL: "indel";
+    readonly SNP: "snp";
+    readonly UNKNOWN: "unknown";
+};
+export type QualityType = (typeof QUALITY_TYPE)[keyof typeof QUALITY_TYPE];
+export declare const qualityTypeSchema: z.ZodEnum<["indel", "snp", "unknown"]>;
+export declare const QUANTITY_COMPARATOR: {
+    readonly _EMPTY: "<";
+    readonly _EMPTY_2: "<=";
+    readonly _EMPTY_3: ">";
+    readonly _EMPTY_4: ">=";
+};
+export type QuantityComparator = (typeof QUANTITY_COMPARATOR)[keyof typeof QUANTITY_COMPARATOR];
+export declare const quantityComparatorSchema: z.ZodEnum<["<", "<=", ">", ">="]>;
+export declare const QUESTIONNAIRE_ITEM_OPERATOR: {
+    readonly _EMPTY: "!=";
+    readonly _EMPTY_2: "<";
+    readonly _EMPTY_3: "<=";
+    readonly _EMPTY_4: "=";
+    readonly _EMPTY_5: ">";
+    readonly _EMPTY_6: ">=";
+    readonly EXISTS: "exists";
+};
+export type QuestionnaireItemOperator = (typeof QUESTIONNAIRE_ITEM_OPERATOR)[keyof typeof QUESTIONNAIRE_ITEM_OPERATOR];
+export declare const questionnaireItemOperatorSchema: z.ZodEnum<["!=", "<", "<=", "=", ">", ">=", "exists"]>;
+export declare const QUESTIONNAIRE_ITEM_TYPE: {
+    readonly ATTACHMENT: "attachment";
+    readonly BOOLEAN: "boolean";
+    readonly CHOICE: "choice";
+    readonly DATE: "date";
+    readonly DATETIME: "dateTime";
+    readonly DECIMAL: "decimal";
+    readonly DISPLAY: "display";
+    readonly GROUP: "group";
+    readonly INTEGER: "integer";
+    readonly OPEN_CHOICE: "open-choice";
+    readonly QUANTITY: "quantity";
+    readonly QUESTION: "question";
+    readonly REFERENCE: "reference";
+    readonly STRING: "string";
+    readonly TEXT: "text";
+    readonly TIME: "time";
+    readonly URL: "url";
+};
+export type QuestionnaireItemType = (typeof QUESTIONNAIRE_ITEM_TYPE)[keyof typeof QUESTIONNAIRE_ITEM_TYPE];
+export declare const questionnaireItemTypeSchema: z.ZodEnum<["attachment", "boolean", "choice", "date", "dateTime", "decimal", "display", "group", "integer", "open-choice", "quantity", "question", "reference", "string", "text", "time", "url"]>;
+export declare const QUESTIONNAIRE_RESPONSE_STATUS: {
+    readonly AMENDED: "amended";
+    readonly COMPLETED: "completed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly IN_PROGRESS: "in-progress";
+    readonly STOPPED: "stopped";
+};
+export type QuestionnaireResponseStatus = (typeof QUESTIONNAIRE_RESPONSE_STATUS)[keyof typeof QUESTIONNAIRE_RESPONSE_STATUS];
+export declare const questionnaireResponseStatusSchema: z.ZodEnum<["amended", "completed", "entered-in-error", "in-progress", "stopped"]>;
+export declare const REFERENCE_HANDLING_POLICY: {
+    readonly ENFORCED: "enforced";
+    readonly LITERAL: "literal";
+    readonly LOCAL: "local";
+    readonly LOGICAL: "logical";
+    readonly RESOLVES: "resolves";
+};
+export type ReferenceHandlingPolicy = (typeof REFERENCE_HANDLING_POLICY)[keyof typeof REFERENCE_HANDLING_POLICY];
+export declare const referenceHandlingPolicySchema: z.ZodEnum<["enforced", "literal", "local", "logical", "resolves"]>;
+export declare const REFERENCE_VERSION_RULES: {
+    readonly EITHER: "either";
+    readonly INDEPENDENT: "independent";
+    readonly SPECIFIC: "specific";
+};
+export type ReferenceVersionRules = (typeof REFERENCE_VERSION_RULES)[keyof typeof REFERENCE_VERSION_RULES];
+export declare const referenceVersionRulesSchema: z.ZodEnum<["either", "independent", "specific"]>;
+export declare const RELATED_ARTIFACT_TYPE: {
+    readonly CITATION: "citation";
+    readonly COMPOSED_OF: "composed-of";
+    readonly DEPENDS_ON: "depends-on";
+    readonly DERIVED_FROM: "derived-from";
+    readonly DOCUMENTATION: "documentation";
+    readonly JUSTIFICATION: "justification";
+    readonly PREDECESSOR: "predecessor";
+    readonly SUCCESSOR: "successor";
+};
+export type RelatedArtifactType = (typeof RELATED_ARTIFACT_TYPE)[keyof typeof RELATED_ARTIFACT_TYPE];
+export declare const relatedArtifactTypeSchema: z.ZodEnum<["citation", "composed-of", "depends-on", "derived-from", "documentation", "justification", "predecessor", "successor"]>;
+export declare const REPOSITORY_TYPE: {
+    readonly DIRECTLINK: "directlink";
+    readonly LOGIN: "login";
+    readonly OAUTH: "oauth";
+    readonly OPENAPI: "openapi";
+    readonly OTHER: "other";
+};
+export type RepositoryType = (typeof REPOSITORY_TYPE)[keyof typeof REPOSITORY_TYPE];
+export declare const repositoryTypeSchema: z.ZodEnum<["directlink", "login", "oauth", "openapi", "other"]>;
+export declare const REQUEST_INTENT: {
+    readonly DIRECTIVE: "directive";
+    readonly FILLER_ORDER: "filler-order";
+    readonly INSTANCE_ORDER: "instance-order";
+    readonly OPTION: "option";
+    readonly ORDER: "order";
+    readonly ORIGINAL_ORDER: "original-order";
+    readonly PLAN: "plan";
+    readonly PROPOSAL: "proposal";
+    readonly REFLEX_ORDER: "reflex-order";
+};
+export type RequestIntent = (typeof REQUEST_INTENT)[keyof typeof REQUEST_INTENT];
+export declare const requestIntentSchema: z.ZodEnum<["directive", "filler-order", "instance-order", "option", "order", "original-order", "plan", "proposal", "reflex-order"]>;
+export declare const REQUEST_PRIORITY: {
+    readonly ASAP: "asap";
+    readonly ROUTINE: "routine";
+    readonly STAT: "stat";
+    readonly URGENT: "urgent";
+};
+export type RequestPriority = (typeof REQUEST_PRIORITY)[keyof typeof REQUEST_PRIORITY];
+export declare const requestPrioritySchema: z.ZodEnum<["asap", "routine", "stat", "urgent"]>;
+export declare const REQUEST_RESOURCE_TYPE: {
+    readonly APPOINTMENT: "Appointment";
+    readonly APPOINTMENTRESPONSE: "AppointmentResponse";
+    readonly CAREPLAN: "CarePlan";
+    readonly CLAIM: "Claim";
+    readonly COMMUNICATIONREQUEST: "CommunicationRequest";
+    readonly CONTRACT: "Contract";
+    readonly DEVICEREQUEST: "DeviceRequest";
+    readonly ENROLLMENTREQUEST: "EnrollmentRequest";
+    readonly IMMUNIZATIONRECOMMENDATION: "ImmunizationRecommendation";
+    readonly MEDICATIONREQUEST: "MedicationRequest";
+    readonly NUTRITIONORDER: "NutritionOrder";
+    readonly SERVICEREQUEST: "ServiceRequest";
+    readonly SUPPLYREQUEST: "SupplyRequest";
+    readonly TASK: "Task";
+    readonly VISIONPRESCRIPTION: "VisionPrescription";
+};
+export type RequestResourceType = (typeof REQUEST_RESOURCE_TYPE)[keyof typeof REQUEST_RESOURCE_TYPE];
+export declare const requestResourceTypeSchema: z.ZodEnum<["Appointment", "AppointmentResponse", "CarePlan", "Claim", "CommunicationRequest", "Contract", "DeviceRequest", "EnrollmentRequest", "ImmunizationRecommendation", "MedicationRequest", "NutritionOrder", "ServiceRequest", "SupplyRequest", "Task", "VisionPrescription"]>;
+export declare const REQUEST_STATUS: {
+    readonly ACTIVE: "active";
+    readonly COMPLETED: "completed";
+    readonly DRAFT: "draft";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly ON_HOLD: "on-hold";
+    readonly REVOKED: "revoked";
+    readonly UNKNOWN: "unknown";
+};
+export type RequestStatus = (typeof REQUEST_STATUS)[keyof typeof REQUEST_STATUS];
+export declare const requestStatusSchema: z.ZodEnum<["active", "completed", "draft", "entered-in-error", "on-hold", "revoked", "unknown"]>;
+export declare const RESEARCH_ELEMENT_TYPE: {
+    readonly EXPOSURE: "exposure";
+    readonly OUTCOME: "outcome";
+    readonly POPULATION: "population";
+};
+export type ResearchElementType = (typeof RESEARCH_ELEMENT_TYPE)[keyof typeof RESEARCH_ELEMENT_TYPE];
+export declare const researchElementTypeSchema: z.ZodEnum<["exposure", "outcome", "population"]>;
+export declare const RESEARCH_STUDY_PRIMARY_PURPOSE_TYPE: {
+    readonly BASIC_SCIENCE: "basic-science";
+    readonly DEVICE_FEASIBILITY: "device-feasibility";
+    readonly DIAGNOSTIC: "diagnostic";
+    readonly HEALTH_SERVICES_RESEARCH: "health-services-research";
+    readonly PREVENTION: "prevention";
+    readonly SCREENING: "screening";
+    readonly SUPPORTIVE_CARE: "supportive-care";
+    readonly TREATMENT: "treatment";
+};
+export type ResearchStudyPrimaryPurposeType = (typeof RESEARCH_STUDY_PRIMARY_PURPOSE_TYPE)[keyof typeof RESEARCH_STUDY_PRIMARY_PURPOSE_TYPE];
+export declare const researchStudyPrimaryPurposeTypeSchema: z.ZodEnum<["basic-science", "device-feasibility", "diagnostic", "health-services-research", "prevention", "screening", "supportive-care", "treatment"]>;
+export declare const RESEARCH_STUDY_STATUS: {
+    readonly ACTIVE: "active";
+    readonly ADMINISTRATIVELY_COMPLETED: "administratively-completed";
+    readonly APPROVED: "approved";
+    readonly CLOSED_TO_ACCRUAL: "closed-to-accrual";
+    readonly CLOSED_TO_ACCRUAL_AND_INTERVENTION: "closed-to-accrual-and-intervention";
+    readonly COMPLETED: "completed";
+    readonly DISAPPROVED: "disapproved";
+    readonly IN_REVIEW: "in-review";
+    readonly TEMPORARILY_CLOSED_TO_ACCRUAL: "temporarily-closed-to-accrual";
+    readonly TEMPORARILY_CLOSED_TO_ACCRUAL_AND_INTERVENTION: "temporarily-closed-to-accrual-and-intervention";
+    readonly WITHDRAWN: "withdrawn";
+};
+export type ResearchStudyStatus = (typeof RESEARCH_STUDY_STATUS)[keyof typeof RESEARCH_STUDY_STATUS];
+export declare const researchStudyStatusSchema: z.ZodEnum<["active", "administratively-completed", "approved", "closed-to-accrual", "closed-to-accrual-and-intervention", "completed", "disapproved", "in-review", "temporarily-closed-to-accrual", "temporarily-closed-to-accrual-and-intervention", "withdrawn"]>;
+export declare const RESEARCH_SUBJECT_STATUS: {
+    readonly CANDIDATE: "candidate";
+    readonly ELIGIBLE: "eligible";
+    readonly FOLLOW_UP: "follow-up";
+    readonly INELIGIBLE: "ineligible";
+    readonly NOT_REGISTERED: "not-registered";
+    readonly OFF_STUDY: "off-study";
+    readonly ON_STUDY: "on-study";
+    readonly ON_STUDY_INTERVENTION: "on-study-intervention";
+    readonly ON_STUDY_OBSERVATION: "on-study-observation";
+    readonly PENDING_ON_STUDY: "pending-on-study";
+    readonly POTENTIAL_CANDIDATE: "potential-candidate";
+    readonly SCREENING: "screening";
+    readonly WITHDRAWN: "withdrawn";
+};
+export type ResearchSubjectStatus = (typeof RESEARCH_SUBJECT_STATUS)[keyof typeof RESEARCH_SUBJECT_STATUS];
+export declare const researchSubjectStatusSchema: z.ZodEnum<["candidate", "eligible", "follow-up", "ineligible", "not-registered", "off-study", "on-study", "on-study-intervention", "on-study-observation", "pending-on-study", "potential-candidate", "screening", "withdrawn"]>;
+export declare const RESOURCE_TYPE: {
+    readonly ACCOUNT: "Account";
+    readonly ACTIVITYDEFINITION: "ActivityDefinition";
+    readonly ADVERSEEVENT: "AdverseEvent";
+    readonly ALLERGYINTOLERANCE: "AllergyIntolerance";
+    readonly APPOINTMENT: "Appointment";
+    readonly APPOINTMENTRESPONSE: "AppointmentResponse";
+    readonly AUDITEVENT: "AuditEvent";
+    readonly BASIC: "Basic";
+    readonly BINARY: "Binary";
+    readonly BIOLOGICALLYDERIVEDPRODUCT: "BiologicallyDerivedProduct";
+    readonly BODYSTRUCTURE: "BodyStructure";
+    readonly BUNDLE: "Bundle";
+    readonly CAPABILITYSTATEMENT: "CapabilityStatement";
+    readonly CAREPLAN: "CarePlan";
+    readonly CARETEAM: "CareTeam";
+    readonly CATALOGENTRY: "CatalogEntry";
+    readonly CHARGEITEM: "ChargeItem";
+    readonly CHARGEITEMDEFINITION: "ChargeItemDefinition";
+    readonly CLAIM: "Claim";
+    readonly CLAIMRESPONSE: "ClaimResponse";
+    readonly CLINICALIMPRESSION: "ClinicalImpression";
+    readonly CODESYSTEM: "CodeSystem";
+    readonly COMMUNICATION: "Communication";
+    readonly COMMUNICATIONREQUEST: "CommunicationRequest";
+    readonly COMPARTMENTDEFINITION: "CompartmentDefinition";
+    readonly COMPOSITION: "Composition";
+    readonly CONCEPTMAP: "ConceptMap";
+    readonly CONDITION: "Condition";
+    readonly CONSENT: "Consent";
+    readonly CONTRACT: "Contract";
+    readonly COVERAGE: "Coverage";
+    readonly COVERAGEELIGIBILITYREQUEST: "CoverageEligibilityRequest";
+    readonly COVERAGEELIGIBILITYRESPONSE: "CoverageEligibilityResponse";
+    readonly DETECTEDISSUE: "DetectedIssue";
+    readonly DEVICE: "Device";
+    readonly DEVICEDEFINITION: "DeviceDefinition";
+    readonly DEVICEMETRIC: "DeviceMetric";
+    readonly DEVICEREQUEST: "DeviceRequest";
+    readonly DEVICEUSESTATEMENT: "DeviceUseStatement";
+    readonly DIAGNOSTICREPORT: "DiagnosticReport";
+    readonly DOCUMENTMANIFEST: "DocumentManifest";
+    readonly DOCUMENTREFERENCE: "DocumentReference";
+    readonly DOMAINRESOURCE: "DomainResource";
+    readonly EFFECTEVIDENCESYNTHESIS: "EffectEvidenceSynthesis";
+    readonly ENCOUNTER: "Encounter";
+    readonly ENDPOINT: "Endpoint";
+    readonly ENROLLMENTREQUEST: "EnrollmentRequest";
+    readonly ENROLLMENTRESPONSE: "EnrollmentResponse";
+    readonly EPISODEOFCARE: "EpisodeOfCare";
+    readonly EVENTDEFINITION: "EventDefinition";
+    readonly EVIDENCE: "Evidence";
+    readonly EVIDENCEVARIABLE: "EvidenceVariable";
+    readonly EXAMPLESCENARIO: "ExampleScenario";
+    readonly EXPLANATIONOFBENEFIT: "ExplanationOfBenefit";
+    readonly FAMILYMEMBERHISTORY: "FamilyMemberHistory";
+    readonly FLAG: "Flag";
+    readonly GOAL: "Goal";
+    readonly GRAPHDEFINITION: "GraphDefinition";
+    readonly GROUP: "Group";
+    readonly GUIDANCERESPONSE: "GuidanceResponse";
+    readonly HEALTHCARESERVICE: "HealthcareService";
+    readonly IMAGINGSTUDY: "ImagingStudy";
+    readonly IMMUNIZATION: "Immunization";
+    readonly IMMUNIZATIONEVALUATION: "ImmunizationEvaluation";
+    readonly IMMUNIZATIONRECOMMENDATION: "ImmunizationRecommendation";
+    readonly IMPLEMENTATIONGUIDE: "ImplementationGuide";
+    readonly INSURANCEPLAN: "InsurancePlan";
+    readonly INVOICE: "Invoice";
+    readonly LIBRARY: "Library";
+    readonly LINKAGE: "Linkage";
+    readonly LIST: "List";
+    readonly LOCATION: "Location";
+    readonly MEASURE: "Measure";
+    readonly MEASUREREPORT: "MeasureReport";
+    readonly MEDIA: "Media";
+    readonly MEDICATION: "Medication";
+    readonly MEDICATIONADMINISTRATION: "MedicationAdministration";
+    readonly MEDICATIONDISPENSE: "MedicationDispense";
+    readonly MEDICATIONKNOWLEDGE: "MedicationKnowledge";
+    readonly MEDICATIONREQUEST: "MedicationRequest";
+    readonly MEDICATIONSTATEMENT: "MedicationStatement";
+    readonly MEDICINALPRODUCT: "MedicinalProduct";
+    readonly MEDICINALPRODUCTAUTHORIZATION: "MedicinalProductAuthorization";
+    readonly MEDICINALPRODUCTCONTRAINDICATION: "MedicinalProductContraindication";
+    readonly MEDICINALPRODUCTINDICATION: "MedicinalProductIndication";
+    readonly MEDICINALPRODUCTINGREDIENT: "MedicinalProductIngredient";
+    readonly MEDICINALPRODUCTINTERACTION: "MedicinalProductInteraction";
+    readonly MEDICINALPRODUCTMANUFACTURED: "MedicinalProductManufactured";
+    readonly MEDICINALPRODUCTPACKAGED: "MedicinalProductPackaged";
+    readonly MEDICINALPRODUCTPHARMACEUTICAL: "MedicinalProductPharmaceutical";
+    readonly MEDICINALPRODUCTUNDESIRABLEEFFECT: "MedicinalProductUndesirableEffect";
+    readonly MESSAGEDEFINITION: "MessageDefinition";
+    readonly MESSAGEHEADER: "MessageHeader";
+    readonly MOLECULARSEQUENCE: "MolecularSequence";
+    readonly NAMINGSYSTEM: "NamingSystem";
+    readonly NUTRITIONORDER: "NutritionOrder";
+    readonly OBSERVATION: "Observation";
+    readonly OBSERVATIONDEFINITION: "ObservationDefinition";
+    readonly OPERATIONDEFINITION: "OperationDefinition";
+    readonly OPERATIONOUTCOME: "OperationOutcome";
+    readonly ORGANIZATION: "Organization";
+    readonly ORGANIZATIONAFFILIATION: "OrganizationAffiliation";
+    readonly PARAMETERS: "Parameters";
+    readonly PATIENT: "Patient";
+    readonly PAYMENTNOTICE: "PaymentNotice";
+    readonly PAYMENTRECONCILIATION: "PaymentReconciliation";
+    readonly PERSON: "Person";
+    readonly PLANDEFINITION: "PlanDefinition";
+    readonly PRACTITIONER: "Practitioner";
+    readonly PRACTITIONERROLE: "PractitionerRole";
+    readonly PROCEDURE: "Procedure";
+    readonly PROVENANCE: "Provenance";
+    readonly QUESTIONNAIRE: "Questionnaire";
+    readonly QUESTIONNAIRERESPONSE: "QuestionnaireResponse";
+    readonly RELATEDPERSON: "RelatedPerson";
+    readonly REQUESTGROUP: "RequestGroup";
+    readonly RESEARCHDEFINITION: "ResearchDefinition";
+    readonly RESEARCHELEMENTDEFINITION: "ResearchElementDefinition";
+    readonly RESEARCHSTUDY: "ResearchStudy";
+    readonly RESEARCHSUBJECT: "ResearchSubject";
+    readonly RESOURCE: "Resource";
+    readonly RISKASSESSMENT: "RiskAssessment";
+    readonly RISKEVIDENCESYNTHESIS: "RiskEvidenceSynthesis";
+    readonly SCHEDULE: "Schedule";
+    readonly SEARCHPARAMETER: "SearchParameter";
+    readonly SERVICEREQUEST: "ServiceRequest";
+    readonly SLOT: "Slot";
+    readonly SPECIMEN: "Specimen";
+    readonly SPECIMENDEFINITION: "SpecimenDefinition";
+    readonly STRUCTUREDEFINITION: "StructureDefinition";
+    readonly STRUCTUREMAP: "StructureMap";
+    readonly SUBSCRIPTION: "Subscription";
+    readonly SUBSTANCE: "Substance";
+    readonly SUBSTANCENUCLEICACID: "SubstanceNucleicAcid";
+    readonly SUBSTANCEPOLYMER: "SubstancePolymer";
+    readonly SUBSTANCEPROTEIN: "SubstanceProtein";
+    readonly SUBSTANCEREFERENCEINFORMATION: "SubstanceReferenceInformation";
+    readonly SUBSTANCESOURCEMATERIAL: "SubstanceSourceMaterial";
+    readonly SUBSTANCESPECIFICATION: "SubstanceSpecification";
+    readonly SUPPLYDELIVERY: "SupplyDelivery";
+    readonly SUPPLYREQUEST: "SupplyRequest";
+    readonly TASK: "Task";
+    readonly TERMINOLOGYCAPABILITIES: "TerminologyCapabilities";
+    readonly TESTREPORT: "TestReport";
+    readonly TESTSCRIPT: "TestScript";
+    readonly VALUESET: "ValueSet";
+    readonly VERIFICATIONRESULT: "VerificationResult";
+    readonly VISIONPRESCRIPTION: "VisionPrescription";
+};
+export type ResourceType = (typeof RESOURCE_TYPE)[keyof typeof RESOURCE_TYPE];
+export declare const resourceTypeSchema: z.ZodEnum<["Account", "ActivityDefinition", "AdverseEvent", "AllergyIntolerance", "Appointment", "AppointmentResponse", "AuditEvent", "Basic", "Binary", "BiologicallyDerivedProduct", "BodyStructure", "Bundle", "CapabilityStatement", "CarePlan", "CareTeam", "CatalogEntry", "ChargeItem", "ChargeItemDefinition", "Claim", "ClaimResponse", "ClinicalImpression", "CodeSystem", "Communication", "CommunicationRequest", "CompartmentDefinition", "Composition", "ConceptMap", "Condition", "Consent", "Contract", "Coverage", "CoverageEligibilityRequest", "CoverageEligibilityResponse", "DetectedIssue", "Device", "DeviceDefinition", "DeviceMetric", "DeviceRequest", "DeviceUseStatement", "DiagnosticReport", "DocumentManifest", "DocumentReference", "DomainResource", "EffectEvidenceSynthesis", "Encounter", "Endpoint", "EnrollmentRequest", "EnrollmentResponse", "EpisodeOfCare", "EventDefinition", "Evidence", "EvidenceVariable", "ExampleScenario", "ExplanationOfBenefit", "FamilyMemberHistory", "Flag", "Goal", "GraphDefinition", "Group", "GuidanceResponse", "HealthcareService", "ImagingStudy", "Immunization", "ImmunizationEvaluation", "ImmunizationRecommendation", "ImplementationGuide", "InsurancePlan", "Invoice", "Library", "Linkage", "List", "Location", "Measure", "MeasureReport", "Media", "Medication", "MedicationAdministration", "MedicationDispense", "MedicationKnowledge", "MedicationRequest", "MedicationStatement", "MedicinalProduct", "MedicinalProductAuthorization", "MedicinalProductContraindication", "MedicinalProductIndication", "MedicinalProductIngredient", "MedicinalProductInteraction", "MedicinalProductManufactured", "MedicinalProductPackaged", "MedicinalProductPharmaceutical", "MedicinalProductUndesirableEffect", "MessageDefinition", "MessageHeader", "MolecularSequence", "NamingSystem", "NutritionOrder", "Observation", "ObservationDefinition", "OperationDefinition", "OperationOutcome", "Organization", "OrganizationAffiliation", "Parameters", "Patient", "PaymentNotice", "PaymentReconciliation", "Person", "PlanDefinition", "Practitioner", "PractitionerRole", "Procedure", "Provenance", "Questionnaire", "QuestionnaireResponse", "RelatedPerson", "RequestGroup", "ResearchDefinition", "ResearchElementDefinition", "ResearchStudy", "ResearchSubject", "Resource", "RiskAssessment", "RiskEvidenceSynthesis", "Schedule", "SearchParameter", "ServiceRequest", "Slot", "Specimen", "SpecimenDefinition", "StructureDefinition", "StructureMap", "Subscription", "Substance", "SubstanceNucleicAcid", "SubstancePolymer", "SubstanceProtein", "SubstanceReferenceInformation", "SubstanceSourceMaterial", "SubstanceSpecification", "SupplyDelivery", "SupplyRequest", "Task", "TerminologyCapabilities", "TestReport", "TestScript", "ValueSet", "VerificationResult", "VisionPrescription"]>;
+export declare const RESOURCE_VERSION_POLICY: {
+    readonly NO_VERSION: "no-version";
+    readonly VERSIONED: "versioned";
+    readonly VERSIONED_UPDATE: "versioned-update";
+};
+export type ResourceVersionPolicy = (typeof RESOURCE_VERSION_POLICY)[keyof typeof RESOURCE_VERSION_POLICY];
+export declare const resourceVersionPolicySchema: z.ZodEnum<["no-version", "versioned", "versioned-update"]>;
+export declare const RESPONSE_TYPE: {
+    readonly FATAL_ERROR: "fatal-error";
+    readonly OK: "ok";
+    readonly TRANSIENT_ERROR: "transient-error";
+};
+export type ResponseType = (typeof RESPONSE_TYPE)[keyof typeof RESPONSE_TYPE];
+export declare const responseTypeSchema: z.ZodEnum<["fatal-error", "ok", "transient-error"]>;
+export declare const RESTFUL_CAPABILITY_MODE: {
+    readonly CLIENT: "client";
+    readonly SERVER: "server";
+};
+export type RestfulCapabilityMode = (typeof RESTFUL_CAPABILITY_MODE)[keyof typeof RESTFUL_CAPABILITY_MODE];
+export declare const restfulCapabilityModeSchema: z.ZodEnum<["client", "server"]>;
+export declare const RESTFUL_SECURITY_SERVICE: {
+    readonly BASIC: "Basic";
+    readonly CERTIFICATES: "Certificates";
+    readonly KERBEROS: "Kerberos";
+    readonly NTLM: "NTLM";
+    readonly OAUTH: "OAuth";
+    readonly SMART_ON_FHIR: "SMART-on-FHIR";
+};
+export type RestfulSecurityService = (typeof RESTFUL_SECURITY_SERVICE)[keyof typeof RESTFUL_SECURITY_SERVICE];
+export declare const restfulSecurityServiceSchema: z.ZodEnum<["Basic", "Certificates", "Kerberos", "NTLM", "OAuth", "SMART-on-FHIR"]>;
+export declare const RISK_ESTIMATE_TYPE: {
+    readonly COUNT: "count";
+    readonly DERIVEDPROPORTION: "derivedProportion";
+    readonly DESCRIPTIVE: "descriptive";
+    readonly MEAN: "mean";
+    readonly MEDIAN: "median";
+    readonly PROPORTION: "proportion";
+};
+export type RiskEstimateType = (typeof RISK_ESTIMATE_TYPE)[keyof typeof RISK_ESTIMATE_TYPE];
+export declare const riskEstimateTypeSchema: z.ZodEnum<["count", "derivedProportion", "descriptive", "mean", "median", "proportion"]>;
+export declare const S_P_D_X_LICENSE: {
+    readonly _0BSD: "0BSD";
+    readonly AAL: "AAL";
+    readonly ADSL: "ADSL";
+    readonly AFL_1_1: "AFL-1.1";
+    readonly AFL_1_2: "AFL-1.2";
+    readonly AFL_2_0: "AFL-2.0";
+    readonly AFL_2_1: "AFL-2.1";
+    readonly AFL_3_0: "AFL-3.0";
+    readonly AGPL_1_0_ONLY: "AGPL-1.0-only";
+    readonly AGPL_1_0_OR_LATER: "AGPL-1.0-or-later";
+    readonly AGPL_3_0_ONLY: "AGPL-3.0-only";
+    readonly AGPL_3_0_OR_LATER: "AGPL-3.0-or-later";
+    readonly AMDPLPA: "AMDPLPA";
+    readonly AML: "AML";
+    readonly AMPAS: "AMPAS";
+    readonly ANTLR_PD: "ANTLR-PD";
+    readonly APAFML: "APAFML";
+    readonly APL_1_0: "APL-1.0";
+    readonly APSL_1_0: "APSL-1.0";
+    readonly APSL_1_1: "APSL-1.1";
+    readonly APSL_1_2: "APSL-1.2";
+    readonly APSL_2_0: "APSL-2.0";
+    readonly ABSTYLES: "Abstyles";
+    readonly ADOBE_2006: "Adobe-2006";
+    readonly ADOBE_GLYPH: "Adobe-Glyph";
+    readonly AFMPARSE: "Afmparse";
+    readonly ALADDIN: "Aladdin";
+    readonly APACHE_1_0: "Apache-1.0";
+    readonly APACHE_1_1: "Apache-1.1";
+    readonly APACHE_2_0: "Apache-2.0";
+    readonly ARTISTIC_1_0: "Artistic-1.0";
+    readonly ARTISTIC_1_0_PERL: "Artistic-1.0-Perl";
+    readonly ARTISTIC_1_0_CL8: "Artistic-1.0-cl8";
+    readonly ARTISTIC_2_0: "Artistic-2.0";
+    readonly BSD_1_CLAUSE: "BSD-1-Clause";
+    readonly BSD_2_CLAUSE: "BSD-2-Clause";
+    readonly BSD_2_CLAUSE_FREEBSD: "BSD-2-Clause-FreeBSD";
+    readonly BSD_2_CLAUSE_NETBSD: "BSD-2-Clause-NetBSD";
+    readonly BSD_2_CLAUSE_PATENT: "BSD-2-Clause-Patent";
+    readonly BSD_3_CLAUSE: "BSD-3-Clause";
+    readonly BSD_3_CLAUSE_ATTRIBUTION: "BSD-3-Clause-Attribution";
+    readonly BSD_3_CLAUSE_CLEAR: "BSD-3-Clause-Clear";
+    readonly BSD_3_CLAUSE_LBNL: "BSD-3-Clause-LBNL";
+    readonly BSD_3_CLAUSE_NO_NUCLEAR_LICENSE: "BSD-3-Clause-No-Nuclear-License";
+    readonly BSD_3_CLAUSE_NO_NUCLEAR_LICENSE_2014: "BSD-3-Clause-No-Nuclear-License-2014";
+    readonly BSD_3_CLAUSE_NO_NUCLEAR_WARRANTY: "BSD-3-Clause-No-Nuclear-Warranty";
+    readonly BSD_4_CLAUSE: "BSD-4-Clause";
+    readonly BSD_4_CLAUSE_UC: "BSD-4-Clause-UC";
+    readonly BSD_PROTECTION: "BSD-Protection";
+    readonly BSD_SOURCE_CODE: "BSD-Source-Code";
+    readonly BSL_1_0: "BSL-1.0";
+    readonly BAHYPH: "Bahyph";
+    readonly BARR: "Barr";
+    readonly BEERWARE: "Beerware";
+    readonly BITTORRENT_1_0: "BitTorrent-1.0";
+    readonly BITTORRENT_1_1: "BitTorrent-1.1";
+    readonly BORCEUX: "Borceux";
+    readonly CATOSL_1_1: "CATOSL-1.1";
+    readonly CC_BY_1_0: "CC-BY-1.0";
+    readonly CC_BY_2_0: "CC-BY-2.0";
+    readonly CC_BY_2_5: "CC-BY-2.5";
+    readonly CC_BY_3_0: "CC-BY-3.0";
+    readonly CC_BY_4_0: "CC-BY-4.0";
+    readonly CC_BY_NC_1_0: "CC-BY-NC-1.0";
+    readonly CC_BY_NC_2_0: "CC-BY-NC-2.0";
+    readonly CC_BY_NC_2_5: "CC-BY-NC-2.5";
+    readonly CC_BY_NC_3_0: "CC-BY-NC-3.0";
+    readonly CC_BY_NC_4_0: "CC-BY-NC-4.0";
+    readonly CC_BY_NC_ND_1_0: "CC-BY-NC-ND-1.0";
+    readonly CC_BY_NC_ND_2_0: "CC-BY-NC-ND-2.0";
+    readonly CC_BY_NC_ND_2_5: "CC-BY-NC-ND-2.5";
+    readonly CC_BY_NC_ND_3_0: "CC-BY-NC-ND-3.0";
+    readonly CC_BY_NC_ND_4_0: "CC-BY-NC-ND-4.0";
+    readonly CC_BY_NC_SA_1_0: "CC-BY-NC-SA-1.0";
+    readonly CC_BY_NC_SA_2_0: "CC-BY-NC-SA-2.0";
+    readonly CC_BY_NC_SA_2_5: "CC-BY-NC-SA-2.5";
+    readonly CC_BY_NC_SA_3_0: "CC-BY-NC-SA-3.0";
+    readonly CC_BY_NC_SA_4_0: "CC-BY-NC-SA-4.0";
+    readonly CC_BY_ND_1_0: "CC-BY-ND-1.0";
+    readonly CC_BY_ND_2_0: "CC-BY-ND-2.0";
+    readonly CC_BY_ND_2_5: "CC-BY-ND-2.5";
+    readonly CC_BY_ND_3_0: "CC-BY-ND-3.0";
+    readonly CC_BY_ND_4_0: "CC-BY-ND-4.0";
+    readonly CC_BY_SA_1_0: "CC-BY-SA-1.0";
+    readonly CC_BY_SA_2_0: "CC-BY-SA-2.0";
+    readonly CC_BY_SA_2_5: "CC-BY-SA-2.5";
+    readonly CC_BY_SA_3_0: "CC-BY-SA-3.0";
+    readonly CC_BY_SA_4_0: "CC-BY-SA-4.0";
+    readonly CC0_1_0: "CC0-1.0";
+    readonly CDDL_1_0: "CDDL-1.0";
+    readonly CDDL_1_1: "CDDL-1.1";
+    readonly CDLA_PERMISSIVE_1_0: "CDLA-Permissive-1.0";
+    readonly CDLA_SHARING_1_0: "CDLA-Sharing-1.0";
+    readonly CECILL_1_0: "CECILL-1.0";
+    readonly CECILL_1_1: "CECILL-1.1";
+    readonly CECILL_2_0: "CECILL-2.0";
+    readonly CECILL_2_1: "CECILL-2.1";
+    readonly CECILL_B: "CECILL-B";
+    readonly CECILL_C: "CECILL-C";
+    readonly CNRI_JYTHON: "CNRI-Jython";
+    readonly CNRI_PYTHON: "CNRI-Python";
+    readonly CNRI_PYTHON_GPL_COMPATIBLE: "CNRI-Python-GPL-Compatible";
+    readonly CPAL_1_0: "CPAL-1.0";
+    readonly CPL_1_0: "CPL-1.0";
+    readonly CPOL_1_02: "CPOL-1.02";
+    readonly CUA_OPL_1_0: "CUA-OPL-1.0";
+    readonly CALDERA: "Caldera";
+    readonly CLARTISTIC: "ClArtistic";
+    readonly CONDOR_1_1: "Condor-1.1";
+    readonly CROSSWORD: "Crossword";
+    readonly CRYSTALSTACKER: "CrystalStacker";
+    readonly CUBE: "Cube";
+    readonly D_FSL_1_0: "D-FSL-1.0";
+    readonly DOC: "DOC";
+    readonly DSDP: "DSDP";
+    readonly DOTSEQN: "Dotseqn";
+    readonly ECL_1_0: "ECL-1.0";
+    readonly ECL_2_0: "ECL-2.0";
+    readonly EFL_1_0: "EFL-1.0";
+    readonly EFL_2_0: "EFL-2.0";
+    readonly EPL_1_0: "EPL-1.0";
+    readonly EPL_2_0: "EPL-2.0";
+    readonly EUDATAGRID: "EUDatagrid";
+    readonly EUPL_1_0: "EUPL-1.0";
+    readonly EUPL_1_1: "EUPL-1.1";
+    readonly EUPL_1_2: "EUPL-1.2";
+    readonly ENTESSA: "Entessa";
+    readonly ERLPL_1_1: "ErlPL-1.1";
+    readonly EUROSYM: "Eurosym";
+    readonly FSFAP: "FSFAP";
+    readonly FSFUL: "FSFUL";
+    readonly FSFULLR: "FSFULLR";
+    readonly FTL: "FTL";
+    readonly FAIR: "Fair";
+    readonly FRAMEWORX_1_0: "Frameworx-1.0";
+    readonly FREEIMAGE: "FreeImage";
+    readonly GFDL_1_1_ONLY: "GFDL-1.1-only";
+    readonly GFDL_1_1_OR_LATER: "GFDL-1.1-or-later";
+    readonly GFDL_1_2_ONLY: "GFDL-1.2-only";
+    readonly GFDL_1_2_OR_LATER: "GFDL-1.2-or-later";
+    readonly GFDL_1_3_ONLY: "GFDL-1.3-only";
+    readonly GFDL_1_3_OR_LATER: "GFDL-1.3-or-later";
+    readonly GL2PS: "GL2PS";
+    readonly GPL_1_0_ONLY: "GPL-1.0-only";
+    readonly GPL_1_0_OR_LATER: "GPL-1.0-or-later";
+    readonly GPL_2_0_ONLY: "GPL-2.0-only";
+    readonly GPL_2_0_OR_LATER: "GPL-2.0-or-later";
+    readonly GPL_3_0_ONLY: "GPL-3.0-only";
+    readonly GPL_3_0_OR_LATER: "GPL-3.0-or-later";
+    readonly GIFTWARE: "Giftware";
+    readonly GLIDE: "Glide";
+    readonly GLULXE: "Glulxe";
+    readonly HPND: "HPND";
+    readonly HASKELLREPORT: "HaskellReport";
+    readonly IBM_PIBS: "IBM-pibs";
+    readonly ICU: "ICU";
+    readonly IJG: "IJG";
+    readonly IPA: "IPA";
+    readonly IPL_1_0: "IPL-1.0";
+    readonly ISC: "ISC";
+    readonly IMAGEMAGICK: "ImageMagick";
+    readonly IMLIB2: "Imlib2";
+    readonly INFO_ZIP: "Info-ZIP";
+    readonly INTEL: "Intel";
+    readonly INTEL_ACPI: "Intel-ACPI";
+    readonly INTERBASE_1_0: "Interbase-1.0";
+    readonly JSON: "JSON";
+    readonly JASPER_2_0: "JasPer-2.0";
+    readonly LAL_1_2: "LAL-1.2";
+    readonly LAL_1_3: "LAL-1.3";
+    readonly LGPL_2_0_ONLY: "LGPL-2.0-only";
+    readonly LGPL_2_0_OR_LATER: "LGPL-2.0-or-later";
+    readonly LGPL_2_1_ONLY: "LGPL-2.1-only";
+    readonly LGPL_2_1_OR_LATER: "LGPL-2.1-or-later";
+    readonly LGPL_3_0_ONLY: "LGPL-3.0-only";
+    readonly LGPL_3_0_OR_LATER: "LGPL-3.0-or-later";
+    readonly LGPLLR: "LGPLLR";
+    readonly LPL_1_0: "LPL-1.0";
+    readonly LPL_1_02: "LPL-1.02";
+    readonly LPPL_1_0: "LPPL-1.0";
+    readonly LPPL_1_1: "LPPL-1.1";
+    readonly LPPL_1_2: "LPPL-1.2";
+    readonly LPPL_1_3A: "LPPL-1.3a";
+    readonly LPPL_1_3C: "LPPL-1.3c";
+    readonly LATEX2E: "Latex2e";
+    readonly LEPTONICA: "Leptonica";
+    readonly LILIQ_P_1_1: "LiLiQ-P-1.1";
+    readonly LILIQ_R_1_1: "LiLiQ-R-1.1";
+    readonly LILIQ_RPLUS_1_1: "LiLiQ-Rplus-1.1";
+    readonly LIBPNG: "Libpng";
+    readonly LINUX_OPENIB: "Linux-OpenIB";
+    readonly MIT: "MIT";
+    readonly MIT_0: "MIT-0";
+    readonly MIT_CMU: "MIT-CMU";
+    readonly MIT_ADVERTISING: "MIT-advertising";
+    readonly MIT_ENNA: "MIT-enna";
+    readonly MIT_FEH: "MIT-feh";
+    readonly MITNFA: "MITNFA";
+    readonly MPL_1_0: "MPL-1.0";
+    readonly MPL_1_1: "MPL-1.1";
+    readonly MPL_2_0: "MPL-2.0";
+    readonly MPL_2_0_NO_COPYLEFT_EXCEPTION: "MPL-2.0-no-copyleft-exception";
+    readonly MS_PL: "MS-PL";
+    readonly MS_RL: "MS-RL";
+    readonly MTLL: "MTLL";
+    readonly MAKEINDEX: "MakeIndex";
+    readonly MIROS: "MirOS";
+    readonly MOTOSOTO: "Motosoto";
+    readonly MULTICS: "Multics";
+    readonly MUP: "Mup";
+    readonly NASA_1_3: "NASA-1.3";
+    readonly NBPL_1_0: "NBPL-1.0";
+    readonly NCSA: "NCSA";
+    readonly NGPL: "NGPL";
+    readonly NLOD_1_0: "NLOD-1.0";
+    readonly NLPL: "NLPL";
+    readonly NOSL: "NOSL";
+    readonly NPL_1_0: "NPL-1.0";
+    readonly NPL_1_1: "NPL-1.1";
+    readonly NPOSL_3_0: "NPOSL-3.0";
+    readonly NRL: "NRL";
+    readonly NTP: "NTP";
+    readonly NAUMEN: "Naumen";
+    readonly NET_SNMP: "Net-SNMP";
+    readonly NETCDF: "NetCDF";
+    readonly NEWSLETR: "Newsletr";
+    readonly NOKIA: "Nokia";
+    readonly NOWEB: "Noweb";
+    readonly OCCT_PL: "OCCT-PL";
+    readonly OCLC_2_0: "OCLC-2.0";
+    readonly ODBL_1_0: "ODbL-1.0";
+    readonly OFL_1_0: "OFL-1.0";
+    readonly OFL_1_1: "OFL-1.1";
+    readonly OGTSL: "OGTSL";
+    readonly OLDAP_1_1: "OLDAP-1.1";
+    readonly OLDAP_1_2: "OLDAP-1.2";
+    readonly OLDAP_1_3: "OLDAP-1.3";
+    readonly OLDAP_1_4: "OLDAP-1.4";
+    readonly OLDAP_2_0: "OLDAP-2.0";
+    readonly OLDAP_2_0_1: "OLDAP-2.0.1";
+    readonly OLDAP_2_1: "OLDAP-2.1";
+    readonly OLDAP_2_2: "OLDAP-2.2";
+    readonly OLDAP_2_2_1: "OLDAP-2.2.1";
+    readonly OLDAP_2_2_2: "OLDAP-2.2.2";
+    readonly OLDAP_2_3: "OLDAP-2.3";
+    readonly OLDAP_2_4: "OLDAP-2.4";
+    readonly OLDAP_2_5: "OLDAP-2.5";
+    readonly OLDAP_2_6: "OLDAP-2.6";
+    readonly OLDAP_2_7: "OLDAP-2.7";
+    readonly OLDAP_2_8: "OLDAP-2.8";
+    readonly OML: "OML";
+    readonly OPL_1_0: "OPL-1.0";
+    readonly OSET_PL_2_1: "OSET-PL-2.1";
+    readonly OSL_1_0: "OSL-1.0";
+    readonly OSL_1_1: "OSL-1.1";
+    readonly OSL_2_0: "OSL-2.0";
+    readonly OSL_2_1: "OSL-2.1";
+    readonly OSL_3_0: "OSL-3.0";
+    readonly OPENSSL: "OpenSSL";
+    readonly PDDL_1_0: "PDDL-1.0";
+    readonly PHP_3_0: "PHP-3.0";
+    readonly PHP_3_01: "PHP-3.01";
+    readonly PLEXUS: "Plexus";
+    readonly POSTGRESQL: "PostgreSQL";
+    readonly PYTHON_2_0: "Python-2.0";
+    readonly QPL_1_0: "QPL-1.0";
+    readonly QHULL: "Qhull";
+    readonly RHECOS_1_1: "RHeCos-1.1";
+    readonly RPL_1_1: "RPL-1.1";
+    readonly RPL_1_5: "RPL-1.5";
+    readonly RPSL_1_0: "RPSL-1.0";
+    readonly RSA_MD: "RSA-MD";
+    readonly RSCPL: "RSCPL";
+    readonly RDISC: "Rdisc";
+    readonly RUBY: "Ruby";
+    readonly SAX_PD: "SAX-PD";
+    readonly SCEA: "SCEA";
+    readonly SGI_B_1_0: "SGI-B-1.0";
+    readonly SGI_B_1_1: "SGI-B-1.1";
+    readonly SGI_B_2_0: "SGI-B-2.0";
+    readonly SISSL: "SISSL";
+    readonly SISSL_1_2: "SISSL-1.2";
+    readonly SMLNJ: "SMLNJ";
+    readonly SMPPL: "SMPPL";
+    readonly SNIA: "SNIA";
+    readonly SPL_1_0: "SPL-1.0";
+    readonly SWL: "SWL";
+    readonly SAXPATH: "Saxpath";
+    readonly SENDMAIL: "Sendmail";
+    readonly SIMPL_2_0: "SimPL-2.0";
+    readonly SLEEPYCAT: "Sleepycat";
+    readonly SPENCER_86: "Spencer-86";
+    readonly SPENCER_94: "Spencer-94";
+    readonly SPENCER_99: "Spencer-99";
+    readonly SUGARCRM_1_1_3: "SugarCRM-1.1.3";
+    readonly TCL: "TCL";
+    readonly TCP_WRAPPERS: "TCP-wrappers";
+    readonly TMATE: "TMate";
+    readonly TORQUE_1_1: "TORQUE-1.1";
+    readonly TOSL: "TOSL";
+    readonly UPL_1_0: "UPL-1.0";
+    readonly UNICODE_DFS_2015: "Unicode-DFS-2015";
+    readonly UNICODE_DFS_2016: "Unicode-DFS-2016";
+    readonly UNICODE_TOU: "Unicode-TOU";
+    readonly UNLICENSE: "Unlicense";
+    readonly VOSTROM: "VOSTROM";
+    readonly VSL_1_0: "VSL-1.0";
+    readonly VIM: "Vim";
+    readonly W3C: "W3C";
+    readonly W3C_19980720: "W3C-19980720";
+    readonly W3C_20150513: "W3C-20150513";
+    readonly WTFPL: "WTFPL";
+    readonly WATCOM_1_0: "Watcom-1.0";
+    readonly WSUIPA: "Wsuipa";
+    readonly X11: "X11";
+    readonly XFREE86_1_1: "XFree86-1.1";
+    readonly XSKAT: "XSkat";
+    readonly XEROX: "Xerox";
+    readonly XNET: "Xnet";
+    readonly YPL_1_0: "YPL-1.0";
+    readonly YPL_1_1: "YPL-1.1";
+    readonly ZPL_1_1: "ZPL-1.1";
+    readonly ZPL_2_0: "ZPL-2.0";
+    readonly ZPL_2_1: "ZPL-2.1";
+    readonly ZED: "Zed";
+    readonly ZEND_2_0: "Zend-2.0";
+    readonly ZIMBRA_1_3: "Zimbra-1.3";
+    readonly ZIMBRA_1_4: "Zimbra-1.4";
+    readonly ZLIB: "Zlib";
+    readonly BZIP2_1_0_5: "bzip2-1.0.5";
+    readonly BZIP2_1_0_6: "bzip2-1.0.6";
+    readonly CURL: "curl";
+    readonly DIFFMARK: "diffmark";
+    readonly DVIPDFM: "dvipdfm";
+    readonly EGENIX: "eGenix";
+    readonly GSOAP_1_3B: "gSOAP-1.3b";
+    readonly GNUPLOT: "gnuplot";
+    readonly IMATIX: "iMatix";
+    readonly LIBTIFF: "libtiff";
+    readonly MPICH2: "mpich2";
+    readonly NOT_OPEN_SOURCE: "not-open-source";
+    readonly PSFRAG: "psfrag";
+    readonly PSUTILS: "psutils";
+    readonly XINETD: "xinetd";
+    readonly XPP: "xpp";
+    readonly ZLIB_ACKNOWLEDGEMENT: "zlib-acknowledgement";
+};
+export type SPDXLicense = (typeof S_P_D_X_LICENSE)[keyof typeof S_P_D_X_LICENSE];
+export declare const sPDXLicenseSchema: z.ZodEnum<["0BSD", "AAL", "ADSL", "AFL-1.1", "AFL-1.2", "AFL-2.0", "AFL-2.1", "AFL-3.0", "AGPL-1.0-only", "AGPL-1.0-or-later", "AGPL-3.0-only", "AGPL-3.0-or-later", "AMDPLPA", "AML", "AMPAS", "ANTLR-PD", "APAFML", "APL-1.0", "APSL-1.0", "APSL-1.1", "APSL-1.2", "APSL-2.0", "Abstyles", "Adobe-2006", "Adobe-Glyph", "Afmparse", "Aladdin", "Apache-1.0", "Apache-1.1", "Apache-2.0", "Artistic-1.0", "Artistic-1.0-Perl", "Artistic-1.0-cl8", "Artistic-2.0", "BSD-1-Clause", "BSD-2-Clause", "BSD-2-Clause-FreeBSD", "BSD-2-Clause-NetBSD", "BSD-2-Clause-Patent", "BSD-3-Clause", "BSD-3-Clause-Attribution", "BSD-3-Clause-Clear", "BSD-3-Clause-LBNL", "BSD-3-Clause-No-Nuclear-License", "BSD-3-Clause-No-Nuclear-License-2014", "BSD-3-Clause-No-Nuclear-Warranty", "BSD-4-Clause", "BSD-4-Clause-UC", "BSD-Protection", "BSD-Source-Code", "BSL-1.0", "Bahyph", "Barr", "Beerware", "BitTorrent-1.0", "BitTorrent-1.1", "Borceux", "CATOSL-1.1", "CC-BY-1.0", "CC-BY-2.0", "CC-BY-2.5", "CC-BY-3.0", "CC-BY-4.0", "CC-BY-NC-1.0", "CC-BY-NC-2.0", "CC-BY-NC-2.5", "CC-BY-NC-3.0", "CC-BY-NC-4.0", "CC-BY-NC-ND-1.0", "CC-BY-NC-ND-2.0", "CC-BY-NC-ND-2.5", "CC-BY-NC-ND-3.0", "CC-BY-NC-ND-4.0", "CC-BY-NC-SA-1.0", "CC-BY-NC-SA-2.0", "CC-BY-NC-SA-2.5", "CC-BY-NC-SA-3.0", "CC-BY-NC-SA-4.0", "CC-BY-ND-1.0", "CC-BY-ND-2.0", "CC-BY-ND-2.5", "CC-BY-ND-3.0", "CC-BY-ND-4.0", "CC-BY-SA-1.0", "CC-BY-SA-2.0", "CC-BY-SA-2.5", "CC-BY-SA-3.0", "CC-BY-SA-4.0", "CC0-1.0", "CDDL-1.0", "CDDL-1.1", "CDLA-Permissive-1.0", "CDLA-Sharing-1.0", "CECILL-1.0", "CECILL-1.1", "CECILL-2.0", "CECILL-2.1", "CECILL-B", "CECILL-C", "CNRI-Jython", "CNRI-Python", "CNRI-Python-GPL-Compatible", "CPAL-1.0", "CPL-1.0", "CPOL-1.02", "CUA-OPL-1.0", "Caldera", "ClArtistic", "Condor-1.1", "Crossword", "CrystalStacker", "Cube", "D-FSL-1.0", "DOC", "DSDP", "Dotseqn", "ECL-1.0", "ECL-2.0", "EFL-1.0", "EFL-2.0", "EPL-1.0", "EPL-2.0", "EUDatagrid", "EUPL-1.0", "EUPL-1.1", "EUPL-1.2", "Entessa", "ErlPL-1.1", "Eurosym", "FSFAP", "FSFUL", "FSFULLR", "FTL", "Fair", "Frameworx-1.0", "FreeImage", "GFDL-1.1-only", "GFDL-1.1-or-later", "GFDL-1.2-only", "GFDL-1.2-or-later", "GFDL-1.3-only", "GFDL-1.3-or-later", "GL2PS", "GPL-1.0-only", "GPL-1.0-or-later", "GPL-2.0-only", "GPL-2.0-or-later", "GPL-3.0-only", "GPL-3.0-or-later", "Giftware", "Glide", "Glulxe", "HPND", "HaskellReport", "IBM-pibs", "ICU", "IJG", "IPA", "IPL-1.0", "ISC", "ImageMagick", "Imlib2", "Info-ZIP", "Intel", "Intel-ACPI", "Interbase-1.0", "JSON", "JasPer-2.0", "LAL-1.2", "LAL-1.3", "LGPL-2.0-only", "LGPL-2.0-or-later", "LGPL-2.1-only", "LGPL-2.1-or-later", "LGPL-3.0-only", "LGPL-3.0-or-later", "LGPLLR", "LPL-1.0", "LPL-1.02", "LPPL-1.0", "LPPL-1.1", "LPPL-1.2", "LPPL-1.3a", "LPPL-1.3c", "Latex2e", "Leptonica", "LiLiQ-P-1.1", "LiLiQ-R-1.1", "LiLiQ-Rplus-1.1", "Libpng", "Linux-OpenIB", "MIT", "MIT-0", "MIT-CMU", "MIT-advertising", "MIT-enna", "MIT-feh", "MITNFA", "MPL-1.0", "MPL-1.1", "MPL-2.0", "MPL-2.0-no-copyleft-exception", "MS-PL", "MS-RL", "MTLL", "MakeIndex", "MirOS", "Motosoto", "Multics", "Mup", "NASA-1.3", "NBPL-1.0", "NCSA", "NGPL", "NLOD-1.0", "NLPL", "NOSL", "NPL-1.0", "NPL-1.1", "NPOSL-3.0", "NRL", "NTP", "Naumen", "Net-SNMP", "NetCDF", "Newsletr", "Nokia", "Noweb", "OCCT-PL", "OCLC-2.0", "ODbL-1.0", "OFL-1.0", "OFL-1.1", "OGTSL", "OLDAP-1.1", "OLDAP-1.2", "OLDAP-1.3", "OLDAP-1.4", "OLDAP-2.0", "OLDAP-2.0.1", "OLDAP-2.1", "OLDAP-2.2", "OLDAP-2.2.1", "OLDAP-2.2.2", "OLDAP-2.3", "OLDAP-2.4", "OLDAP-2.5", "OLDAP-2.6", "OLDAP-2.7", "OLDAP-2.8", "OML", "OPL-1.0", "OSET-PL-2.1", "OSL-1.0", "OSL-1.1", "OSL-2.0", "OSL-2.1", "OSL-3.0", "OpenSSL", "PDDL-1.0", "PHP-3.0", "PHP-3.01", "Plexus", "PostgreSQL", "Python-2.0", "QPL-1.0", "Qhull", "RHeCos-1.1", "RPL-1.1", "RPL-1.5", "RPSL-1.0", "RSA-MD", "RSCPL", "Rdisc", "Ruby", "SAX-PD", "SCEA", "SGI-B-1.0", "SGI-B-1.1", "SGI-B-2.0", "SISSL", "SISSL-1.2", "SMLNJ", "SMPPL", "SNIA", "SPL-1.0", "SWL", "Saxpath", "Sendmail", "SimPL-2.0", "Sleepycat", "Spencer-86", "Spencer-94", "Spencer-99", "SugarCRM-1.1.3", "TCL", "TCP-wrappers", "TMate", "TORQUE-1.1", "TOSL", "UPL-1.0", "Unicode-DFS-2015", "Unicode-DFS-2016", "Unicode-TOU", "Unlicense", "VOSTROM", "VSL-1.0", "Vim", "W3C", "W3C-19980720", "W3C-20150513", "WTFPL", "Watcom-1.0", "Wsuipa", "X11", "XFree86-1.1", "XSkat", "Xerox", "Xnet", "YPL-1.0", "YPL-1.1", "ZPL-1.1", "ZPL-2.0", "ZPL-2.1", "Zed", "Zend-2.0", "Zimbra-1.3", "Zimbra-1.4", "Zlib", "bzip2-1.0.5", "bzip2-1.0.6", "curl", "diffmark", "dvipdfm", "eGenix", "gSOAP-1.3b", "gnuplot", "iMatix", "libtiff", "mpich2", "not-open-source", "psfrag", "psutils", "xinetd", "xpp", "zlib-acknowledgement"]>;
+export declare const SEARCH_COMPARATOR: {
+    readonly AP: "ap";
+    readonly EB: "eb";
+    readonly EQ: "eq";
+    readonly GE: "ge";
+    readonly GT: "gt";
+    readonly LE: "le";
+    readonly LT: "lt";
+    readonly NE: "ne";
+    readonly SA: "sa";
+};
+export type SearchComparator = (typeof SEARCH_COMPARATOR)[keyof typeof SEARCH_COMPARATOR];
+export declare const searchComparatorSchema: z.ZodEnum<["ap", "eb", "eq", "ge", "gt", "le", "lt", "ne", "sa"]>;
+export declare const SEARCH_ENTRY_MODE: {
+    readonly INCLUDE: "include";
+    readonly MATCH: "match";
+    readonly OUTCOME: "outcome";
+};
+export type SearchEntryMode = (typeof SEARCH_ENTRY_MODE)[keyof typeof SEARCH_ENTRY_MODE];
+export declare const searchEntryModeSchema: z.ZodEnum<["include", "match", "outcome"]>;
+export declare const SEARCH_MODIFIER_CODE: {
+    readonly ABOVE: "above";
+    readonly BELOW: "below";
+    readonly CONTAINS: "contains";
+    readonly EXACT: "exact";
+    readonly IDENTIFIER: "identifier";
+    readonly IN: "in";
+    readonly MISSING: "missing";
+    readonly NOT: "not";
+    readonly NOT_IN: "not-in";
+    readonly OFTYPE: "ofType";
+    readonly TEXT: "text";
+    readonly TYPE: "type";
+};
+export type SearchModifierCode = (typeof SEARCH_MODIFIER_CODE)[keyof typeof SEARCH_MODIFIER_CODE];
+export declare const searchModifierCodeSchema: z.ZodEnum<["above", "below", "contains", "exact", "identifier", "in", "missing", "not", "not-in", "ofType", "text", "type"]>;
+export declare const SEARCH_PARAM_TYPE: {
+    readonly COMPOSITE: "composite";
+    readonly DATE: "date";
+    readonly NUMBER: "number";
+    readonly QUANTITY: "quantity";
+    readonly REFERENCE: "reference";
+    readonly SPECIAL: "special";
+    readonly STRING: "string";
+    readonly TOKEN: "token";
+    readonly URI: "uri";
+};
+export type SearchParamType = (typeof SEARCH_PARAM_TYPE)[keyof typeof SEARCH_PARAM_TYPE];
+export declare const searchParamTypeSchema: z.ZodEnum<["composite", "date", "number", "quantity", "reference", "special", "string", "token", "uri"]>;
+export declare const SEQUENCE_TYPE: {
+    readonly AA: "aa";
+    readonly DNA: "dna";
+    readonly RNA: "rna";
+};
+export type SequenceType = (typeof SEQUENCE_TYPE)[keyof typeof SEQUENCE_TYPE];
+export declare const sequenceTypeSchema: z.ZodEnum<["aa", "dna", "rna"]>;
+export declare const SLICING_RULES: {
+    readonly CLOSED: "closed";
+    readonly OPEN: "open";
+    readonly OPENATEND: "openAtEnd";
+};
+export type SlicingRules = (typeof SLICING_RULES)[keyof typeof SLICING_RULES];
+export declare const slicingRulesSchema: z.ZodEnum<["closed", "open", "openAtEnd"]>;
+export declare const SLOT_STATUS: {
+    readonly BUSY: "busy";
+    readonly BUSY_TENTATIVE: "busy-tentative";
+    readonly BUSY_UNAVAILABLE: "busy-unavailable";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly FREE: "free";
+};
+export type SlotStatus = (typeof SLOT_STATUS)[keyof typeof SLOT_STATUS];
+export declare const slotStatusSchema: z.ZodEnum<["busy", "busy-tentative", "busy-unavailable", "entered-in-error", "free"]>;
+export declare const SORT_DIRECTION: {
+    readonly ASCENDING: "ascending";
+    readonly DESCENDING: "descending";
+};
+export type SortDirection = (typeof SORT_DIRECTION)[keyof typeof SORT_DIRECTION];
+export declare const sortDirectionSchema: z.ZodEnum<["ascending", "descending"]>;
+export declare const SPECIMEN_CONTAINED_PREFERENCE: {
+    readonly ALTERNATE: "alternate";
+    readonly PREFERRED: "preferred";
+};
+export type SpecimenContainedPreference = (typeof SPECIMEN_CONTAINED_PREFERENCE)[keyof typeof SPECIMEN_CONTAINED_PREFERENCE];
+export declare const specimenContainedPreferenceSchema: z.ZodEnum<["alternate", "preferred"]>;
+export declare const SPECIMEN_STATUS: {
+    readonly AVAILABLE: "available";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly UNAVAILABLE: "unavailable";
+    readonly UNSATISFACTORY: "unsatisfactory";
+};
+export type SpecimenStatus = (typeof SPECIMEN_STATUS)[keyof typeof SPECIMEN_STATUS];
+export declare const specimenStatusSchema: z.ZodEnum<["available", "entered-in-error", "unavailable", "unsatisfactory"]>;
+export declare const STATUS: {
+    readonly ATTESTED: "attested";
+    readonly IN_PROCESS: "in-process";
+    readonly REQ_REVALID: "req-revalid";
+    readonly REVAL_FAIL: "reval-fail";
+    readonly VAL_FAIL: "val-fail";
+    readonly VALIDATED: "validated";
+};
+export type Status = (typeof STATUS)[keyof typeof STATUS];
+export declare const statusSchema: z.ZodEnum<["attested", "in-process", "req-revalid", "reval-fail", "val-fail", "validated"]>;
+export declare const STRAND_TYPE: {
+    readonly CRICK: "crick";
+    readonly WATSON: "watson";
+};
+export type StrandType = (typeof STRAND_TYPE)[keyof typeof STRAND_TYPE];
+export declare const strandTypeSchema: z.ZodEnum<["crick", "watson"]>;
+export declare const STRUCTURE_DEFINITION_KIND: {
+    readonly COMPLEX_TYPE: "complex-type";
+    readonly LOGICAL: "logical";
+    readonly PRIMITIVE_TYPE: "primitive-type";
+    readonly RESOURCE: "resource";
+};
+export type StructureDefinitionKind = (typeof STRUCTURE_DEFINITION_KIND)[keyof typeof STRUCTURE_DEFINITION_KIND];
+export declare const structureDefinitionKindSchema: z.ZodEnum<["complex-type", "logical", "primitive-type", "resource"]>;
+export declare const STRUCTURE_MAP_CONTEXT_TYPE: {
+    readonly TYPE: "type";
+    readonly VARIABLE: "variable";
+};
+export type StructureMapContextType = (typeof STRUCTURE_MAP_CONTEXT_TYPE)[keyof typeof STRUCTURE_MAP_CONTEXT_TYPE];
+export declare const structureMapContextTypeSchema: z.ZodEnum<["type", "variable"]>;
+export declare const STRUCTURE_MAP_GROUP_TYPE_MODE: {
+    readonly NONE: "none";
+    readonly TYPE_AND_TYPES: "type-and-types";
+    readonly TYPES: "types";
+};
+export type StructureMapGroupTypeMode = (typeof STRUCTURE_MAP_GROUP_TYPE_MODE)[keyof typeof STRUCTURE_MAP_GROUP_TYPE_MODE];
+export declare const structureMapGroupTypeModeSchema: z.ZodEnum<["none", "type-and-types", "types"]>;
+export declare const STRUCTURE_MAP_INPUT_MODE: {
+    readonly SOURCE: "source";
+    readonly TARGET: "target";
+};
+export type StructureMapInputMode = (typeof STRUCTURE_MAP_INPUT_MODE)[keyof typeof STRUCTURE_MAP_INPUT_MODE];
+export declare const structureMapInputModeSchema: z.ZodEnum<["source", "target"]>;
+export declare const STRUCTURE_MAP_MODEL_MODE: {
+    readonly PRODUCED: "produced";
+    readonly QUERIED: "queried";
+    readonly SOURCE: "source";
+    readonly TARGET: "target";
+};
+export type StructureMapModelMode = (typeof STRUCTURE_MAP_MODEL_MODE)[keyof typeof STRUCTURE_MAP_MODEL_MODE];
+export declare const structureMapModelModeSchema: z.ZodEnum<["produced", "queried", "source", "target"]>;
+export declare const STRUCTURE_MAP_SOURCE_LIST_MODE: {
+    readonly FIRST: "first";
+    readonly LAST: "last";
+    readonly NOT_FIRST: "not_first";
+    readonly NOT_LAST: "not_last";
+    readonly ONLY_ONE: "only_one";
+};
+export type StructureMapSourceListMode = (typeof STRUCTURE_MAP_SOURCE_LIST_MODE)[keyof typeof STRUCTURE_MAP_SOURCE_LIST_MODE];
+export declare const structureMapSourceListModeSchema: z.ZodEnum<["first", "last", "not_first", "not_last", "only_one"]>;
+export declare const STRUCTURE_MAP_TARGET_LIST_MODE: {
+    readonly COLLATE: "collate";
+    readonly FIRST: "first";
+    readonly LAST: "last";
+    readonly SHARE: "share";
+};
+export type StructureMapTargetListMode = (typeof STRUCTURE_MAP_TARGET_LIST_MODE)[keyof typeof STRUCTURE_MAP_TARGET_LIST_MODE];
+export declare const structureMapTargetListModeSchema: z.ZodEnum<["collate", "first", "last", "share"]>;
+export declare const STRUCTURE_MAP_TRANSFORM: {
+    readonly APPEND: "append";
+    readonly C: "c";
+    readonly CAST: "cast";
+    readonly CC: "cc";
+    readonly COPY: "copy";
+    readonly CP: "cp";
+    readonly CREATE: "create";
+    readonly DATEOP: "dateOp";
+    readonly ESCAPE: "escape";
+    readonly EVALUATE: "evaluate";
+    readonly ID: "id";
+    readonly POINTER: "pointer";
+    readonly QTY: "qty";
+    readonly REFERENCE: "reference";
+    readonly TRANSLATE: "translate";
+    readonly TRUNCATE: "truncate";
+    readonly UUID: "uuid";
+};
+export type StructureMapTransform = (typeof STRUCTURE_MAP_TRANSFORM)[keyof typeof STRUCTURE_MAP_TRANSFORM];
+export declare const structureMapTransformSchema: z.ZodEnum<["append", "c", "cast", "cc", "copy", "cp", "create", "dateOp", "escape", "evaluate", "id", "pointer", "qty", "reference", "translate", "truncate", "uuid"]>;
+export declare const STUDY_TYPE: {
+    readonly CCT: "CCT";
+    readonly RCT: "RCT";
+    readonly CASE_CONTROL: "case-control";
+    readonly CASE_REPORT: "case-report";
+    readonly COHORT: "cohort";
+    readonly MIXED: "mixed";
+    readonly SERIES: "series";
+};
+export type StudyType = (typeof STUDY_TYPE)[keyof typeof STUDY_TYPE];
+export declare const studyTypeSchema: z.ZodEnum<["CCT", "RCT", "case-control", "case-report", "cohort", "mixed", "series"]>;
+export declare const SUBJECT_TYPE: {
+    readonly DEVICE: "Device";
+    readonly LOCATION: "Location";
+    readonly ORGANIZATION: "Organization";
+    readonly PATIENT: "Patient";
+    readonly PRACTITIONER: "Practitioner";
+};
+export type SubjectType = (typeof SUBJECT_TYPE)[keyof typeof SUBJECT_TYPE];
+export declare const subjectTypeSchema: z.ZodEnum<["Device", "Location", "Organization", "Patient", "Practitioner"]>;
+export declare const SUBSCRIBER_RELATIONSHIP_CODES: {
+    readonly CHILD: "child";
+    readonly COMMON: "common";
+    readonly INJURED: "injured";
+    readonly OTHER: "other";
+    readonly PARENT: "parent";
+    readonly SELF: "self";
+    readonly SPOUSE: "spouse";
+};
+export type SubscriberRelationshipCodes = (typeof SUBSCRIBER_RELATIONSHIP_CODES)[keyof typeof SUBSCRIBER_RELATIONSHIP_CODES];
+export declare const subscriberRelationshipCodesSchema: z.ZodEnum<["child", "common", "injured", "other", "parent", "self", "spouse"]>;
+export declare const SUBSCRIPTION_CHANNEL_TYPE: {
+    readonly EMAIL: "email";
+    readonly MESSAGE: "message";
+    readonly REST_HOOK: "rest-hook";
+    readonly SMS: "sms";
+    readonly WEBSOCKET: "websocket";
+};
+export type SubscriptionChannelType = (typeof SUBSCRIPTION_CHANNEL_TYPE)[keyof typeof SUBSCRIPTION_CHANNEL_TYPE];
+export declare const subscriptionChannelTypeSchema: z.ZodEnum<["email", "message", "rest-hook", "sms", "websocket"]>;
+export declare const SUBSCRIPTION_STATUS: {
+    readonly ACTIVE: "active";
+    readonly ERROR: "error";
+    readonly OFF: "off";
+    readonly REQUESTED: "requested";
+};
+export type SubscriptionStatus = (typeof SUBSCRIPTION_STATUS)[keyof typeof SUBSCRIPTION_STATUS];
+export declare const subscriptionStatusSchema: z.ZodEnum<["active", "error", "off", "requested"]>;
+export declare const SUBSTANCE_CATEGORY_CODES: {
+    readonly ALLERGEN: "allergen";
+    readonly BIOLOGICAL: "biological";
+    readonly BODY: "body";
+    readonly CHEMICAL: "chemical";
+    readonly DRUG: "drug";
+    readonly FOOD: "food";
+    readonly MATERIAL: "material";
+};
+export type SubstanceCategoryCodes = (typeof SUBSTANCE_CATEGORY_CODES)[keyof typeof SUBSTANCE_CATEGORY_CODES];
+export declare const substanceCategoryCodesSchema: z.ZodEnum<["allergen", "biological", "body", "chemical", "drug", "food", "material"]>;
+export declare const SUPPLY_DELIVERY_STATUS: {
+    readonly ABANDONED: "abandoned";
+    readonly COMPLETED: "completed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly IN_PROGRESS: "in-progress";
+};
+export type SupplyDeliveryStatus = (typeof SUPPLY_DELIVERY_STATUS)[keyof typeof SUPPLY_DELIVERY_STATUS];
+export declare const supplyDeliveryStatusSchema: z.ZodEnum<["abandoned", "completed", "entered-in-error", "in-progress"]>;
+export declare const SUPPLY_ITEM_TYPE: {
+    readonly DEVICE: "device";
+    readonly MEDICATION: "medication";
+};
+export type SupplyItemType = (typeof SUPPLY_ITEM_TYPE)[keyof typeof SUPPLY_ITEM_TYPE];
+export declare const supplyItemTypeSchema: z.ZodEnum<["device", "medication"]>;
+export declare const SUPPLY_REQUEST_STATUS: {
+    readonly ACTIVE: "active";
+    readonly CANCELLED: "cancelled";
+    readonly COMPLETED: "completed";
+    readonly DRAFT: "draft";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly SUSPENDED: "suspended";
+    readonly UNKNOWN: "unknown";
+};
+export type SupplyRequestStatus = (typeof SUPPLY_REQUEST_STATUS)[keyof typeof SUPPLY_REQUEST_STATUS];
+export declare const supplyRequestStatusSchema: z.ZodEnum<["active", "cancelled", "completed", "draft", "entered-in-error", "suspended", "unknown"]>;
+export declare const SYNTHESIS_TYPE: {
+    readonly IPD_MA: "IPD-MA";
+    readonly CLASSIFICATION: "classification";
+    readonly COMBINED_NMA: "combined-NMA";
+    readonly INDIRECT_NMA: "indirect-NMA";
+    readonly RANGE: "range";
+    readonly STD_MA: "std-MA";
+};
+export type SynthesisType = (typeof SYNTHESIS_TYPE)[keyof typeof SYNTHESIS_TYPE];
+export declare const synthesisTypeSchema: z.ZodEnum<["IPD-MA", "classification", "combined-NMA", "indirect-NMA", "range", "std-MA"]>;
+export declare const SYSTEM_RESTFUL_INTERACTION: {
+    readonly BATCH: "batch";
+    readonly HISTORY_SYSTEM: "history-system";
+    readonly SEARCH_SYSTEM: "search-system";
+    readonly TRANSACTION: "transaction";
+};
+export type SystemRestfulInteraction = (typeof SYSTEM_RESTFUL_INTERACTION)[keyof typeof SYSTEM_RESTFUL_INTERACTION];
+export declare const systemRestfulInteractionSchema: z.ZodEnum<["batch", "history-system", "search-system", "transaction"]>;
+export declare const TASK_INTENT: {
+    readonly FILLER_ORDER: "filler-order";
+    readonly INSTANCE_ORDER: "instance-order";
+    readonly OPTION: "option";
+    readonly ORDER: "order";
+    readonly ORIGINAL_ORDER: "original-order";
+    readonly PLAN: "plan";
+    readonly PROPOSAL: "proposal";
+    readonly REFLEX_ORDER: "reflex-order";
+    readonly UNKNOWN: "unknown";
+};
+export type TaskIntent = (typeof TASK_INTENT)[keyof typeof TASK_INTENT];
+export declare const taskIntentSchema: z.ZodEnum<["filler-order", "instance-order", "option", "order", "original-order", "plan", "proposal", "reflex-order", "unknown"]>;
+export declare const TASK_STATUS: {
+    readonly ACCEPTED: "accepted";
+    readonly CANCELLED: "cancelled";
+    readonly COMPLETED: "completed";
+    readonly DRAFT: "draft";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly FAILED: "failed";
+    readonly IN_PROGRESS: "in-progress";
+    readonly ON_HOLD: "on-hold";
+    readonly READY: "ready";
+    readonly RECEIVED: "received";
+    readonly REJECTED: "rejected";
+    readonly REQUESTED: "requested";
+};
+export type TaskStatus = (typeof TASK_STATUS)[keyof typeof TASK_STATUS];
+export declare const taskStatusSchema: z.ZodEnum<["accepted", "cancelled", "completed", "draft", "entered-in-error", "failed", "in-progress", "on-hold", "ready", "received", "rejected", "requested"]>;
+export declare const TEST_REPORT_ACTION_RESULT: {
+    readonly ERROR: "error";
+    readonly FAIL: "fail";
+    readonly PASS: "pass";
+    readonly SKIP: "skip";
+    readonly WARNING: "warning";
+};
+export type TestReportActionResult = (typeof TEST_REPORT_ACTION_RESULT)[keyof typeof TEST_REPORT_ACTION_RESULT];
+export declare const testReportActionResultSchema: z.ZodEnum<["error", "fail", "pass", "skip", "warning"]>;
+export declare const TEST_REPORT_PARTICIPANT_TYPE: {
+    readonly CLIENT: "client";
+    readonly SERVER: "server";
+    readonly TEST_ENGINE: "test-engine";
+};
+export type TestReportParticipantType = (typeof TEST_REPORT_PARTICIPANT_TYPE)[keyof typeof TEST_REPORT_PARTICIPANT_TYPE];
+export declare const testReportParticipantTypeSchema: z.ZodEnum<["client", "server", "test-engine"]>;
+export declare const TEST_REPORT_RESULT: {
+    readonly FAIL: "fail";
+    readonly PASS: "pass";
+    readonly PENDING: "pending";
+};
+export type TestReportResult = (typeof TEST_REPORT_RESULT)[keyof typeof TEST_REPORT_RESULT];
+export declare const testReportResultSchema: z.ZodEnum<["fail", "pass", "pending"]>;
+export declare const TEST_REPORT_STATUS: {
+    readonly COMPLETED: "completed";
+    readonly ENTERED_IN_ERROR: "entered-in-error";
+    readonly IN_PROGRESS: "in-progress";
+    readonly STOPPED: "stopped";
+    readonly WAITING: "waiting";
+};
+export type TestReportStatus = (typeof TEST_REPORT_STATUS)[keyof typeof TEST_REPORT_STATUS];
+export declare const testReportStatusSchema: z.ZodEnum<["completed", "entered-in-error", "in-progress", "stopped", "waiting"]>;
+export declare const TEST_SCRIPT_OPERATION_CODE: {
+    readonly APPLY: "apply";
+    readonly BATCH: "batch";
+    readonly CAPABILITIES: "capabilities";
+    readonly CLOSURE: "closure";
+    readonly CONFORMS: "conforms";
+    readonly CREATE: "create";
+    readonly DATA_REQUIREMENTS: "data-requirements";
+    readonly DELETE: "delete";
+    readonly DELETECONDMULTIPLE: "deleteCondMultiple";
+    readonly DELETECONDSINGLE: "deleteCondSingle";
+    readonly DOCUMENT: "document";
+    readonly EVALUATE: "evaluate";
+    readonly EVALUATE_MEASURE: "evaluate-measure";
+    readonly EVERYTHING: "everything";
+    readonly EXPAND: "expand";
+    readonly FIND: "find";
+    readonly FIND_MATCHES: "find-matches";
+    readonly GRAPHQL: "graphql";
+    readonly HISTORY: "history";
+    readonly IMPLEMENTS: "implements";
+    readonly LASTN: "lastn";
+    readonly LOOKUP: "lookup";
+    readonly MATCH: "match";
+    readonly META: "meta";
+    readonly META_ADD: "meta-add";
+    readonly META_DELETE: "meta-delete";
+    readonly PATCH: "patch";
+    readonly POPULATE: "populate";
+    readonly POPULATEHTML: "populatehtml";
+    readonly POPULATELINK: "populatelink";
+    readonly PROCESS_MESSAGE: "process-message";
+    readonly QUESTIONNAIRE: "questionnaire";
+    readonly READ: "read";
+    readonly SEARCH: "search";
+    readonly STATS: "stats";
+    readonly SUBSET: "subset";
+    readonly SUBSUMES: "subsumes";
+    readonly TRANSACTION: "transaction";
+    readonly TRANSFORM: "transform";
+    readonly TRANSLATE: "translate";
+    readonly UPDATE: "update";
+    readonly UPDATECREATE: "updateCreate";
+    readonly VALIDATE: "validate";
+    readonly VALIDATE_CODE: "validate-code";
+    readonly VREAD: "vread";
+};
+export type TestScriptOperationCode = (typeof TEST_SCRIPT_OPERATION_CODE)[keyof typeof TEST_SCRIPT_OPERATION_CODE];
+export declare const testScriptOperationCodeSchema: z.ZodEnum<["apply", "batch", "capabilities", "closure", "conforms", "create", "data-requirements", "delete", "deleteCondMultiple", "deleteCondSingle", "document", "evaluate", "evaluate-measure", "everything", "expand", "find", "find-matches", "graphql", "history", "implements", "lastn", "lookup", "match", "meta", "meta-add", "meta-delete", "patch", "populate", "populatehtml", "populatelink", "process-message", "questionnaire", "read", "search", "stats", "subset", "subsumes", "transaction", "transform", "translate", "update", "updateCreate", "validate", "validate-code", "vread"]>;
+export declare const TEST_SCRIPT_PROFILE_DESTINATION_TYPE: {
+    readonly FHIR_SDC_FORMMANAGER: "FHIR-SDC-FormManager";
+    readonly FHIR_SDC_FORMPROCESSOR: "FHIR-SDC-FormProcessor";
+    readonly FHIR_SDC_FORMRECEIVER: "FHIR-SDC-FormReceiver";
+    readonly FHIR_SERVER: "FHIR-Server";
+};
+export type TestScriptProfileDestinationType = (typeof TEST_SCRIPT_PROFILE_DESTINATION_TYPE)[keyof typeof TEST_SCRIPT_PROFILE_DESTINATION_TYPE];
+export declare const testScriptProfileDestinationTypeSchema: z.ZodEnum<["FHIR-SDC-FormManager", "FHIR-SDC-FormProcessor", "FHIR-SDC-FormReceiver", "FHIR-Server"]>;
+export declare const TEST_SCRIPT_PROFILE_ORIGIN_TYPE: {
+    readonly FHIR_CLIENT: "FHIR-Client";
+    readonly FHIR_SDC_FORMFILLER: "FHIR-SDC-FormFiller";
+};
+export type TestScriptProfileOriginType = (typeof TEST_SCRIPT_PROFILE_ORIGIN_TYPE)[keyof typeof TEST_SCRIPT_PROFILE_ORIGIN_TYPE];
+export declare const testScriptProfileOriginTypeSchema: z.ZodEnum<["FHIR-Client", "FHIR-SDC-FormFiller"]>;
+export declare const TEST_SCRIPT_REQUEST_METHOD_CODE: {
+    readonly DELETE: "delete";
+    readonly GET: "get";
+    readonly HEAD: "head";
+    readonly OPTIONS: "options";
+    readonly PATCH: "patch";
+    readonly POST: "post";
+    readonly PUT: "put";
+};
+export type TestScriptRequestMethodCode = (typeof TEST_SCRIPT_REQUEST_METHOD_CODE)[keyof typeof TEST_SCRIPT_REQUEST_METHOD_CODE];
+export declare const testScriptRequestMethodCodeSchema: z.ZodEnum<["delete", "get", "head", "options", "patch", "post", "put"]>;
+export declare const TRIGGER_TYPE: {
+    readonly DATA_ACCESS_ENDED: "data-access-ended";
+    readonly DATA_ACCESSED: "data-accessed";
+    readonly DATA_ADDED: "data-added";
+    readonly DATA_CHANGED: "data-changed";
+    readonly DATA_MODIFIED: "data-modified";
+    readonly DATA_REMOVED: "data-removed";
+    readonly NAMED_EVENT: "named-event";
+    readonly PERIODIC: "periodic";
+};
+export type TriggerType = (typeof TRIGGER_TYPE)[keyof typeof TRIGGER_TYPE];
+export declare const triggerTypeSchema: z.ZodEnum<["data-access-ended", "data-accessed", "data-added", "data-changed", "data-modified", "data-removed", "named-event", "periodic"]>;
+export declare const TYPE_DERIVATION_RULE: {
+    readonly CONSTRAINT: "constraint";
+    readonly SPECIALIZATION: "specialization";
+};
+export type TypeDerivationRule = (typeof TYPE_DERIVATION_RULE)[keyof typeof TYPE_DERIVATION_RULE];
+export declare const typeDerivationRuleSchema: z.ZodEnum<["constraint", "specialization"]>;
+export declare const TYPE_RESTFUL_INTERACTION: {
+    readonly CREATE: "create";
+    readonly DELETE: "delete";
+    readonly HISTORY_INSTANCE: "history-instance";
+    readonly HISTORY_TYPE: "history-type";
+    readonly PATCH: "patch";
+    readonly READ: "read";
+    readonly SEARCH_TYPE: "search-type";
+    readonly UPDATE: "update";
+    readonly VREAD: "vread";
+};
+export type TypeRestfulInteraction = (typeof TYPE_RESTFUL_INTERACTION)[keyof typeof TYPE_RESTFUL_INTERACTION];
+export declare const typeRestfulInteractionSchema: z.ZodEnum<["create", "delete", "history-instance", "history-type", "patch", "read", "search-type", "update", "vread"]>;
+export declare const U_D_I_ENTRY_TYPE: {
+    readonly BARCODE: "barcode";
+    readonly CARD: "card";
+    readonly MANUAL: "manual";
+    readonly RFID: "rfid";
+    readonly SELF_REPORTED: "self-reported";
+    readonly UNKNOWN: "unknown";
+};
+export type UDIEntryType = (typeof U_D_I_ENTRY_TYPE)[keyof typeof U_D_I_ENTRY_TYPE];
+export declare const uDIEntryTypeSchema: z.ZodEnum<["barcode", "card", "manual", "rfid", "self-reported", "unknown"]>;
+export declare const UNITS_OF_TIME: {
+    readonly A: "a";
+    readonly D: "d";
+    readonly H: "h";
+    readonly MIN: "min";
+    readonly MO: "mo";
+    readonly S: "s";
+    readonly WK: "wk";
+};
+export type UnitsOfTime = (typeof UNITS_OF_TIME)[keyof typeof UNITS_OF_TIME];
+export declare const unitsOfTimeSchema: z.ZodEnum<["a", "d", "h", "min", "mo", "s", "wk"]>;
+export declare const USAGE_CONTEXT_TYPE: {
+    readonly AGE: "age";
+    readonly FOCUS: "focus";
+    readonly GENDER: "gender";
+    readonly PROGRAM: "program";
+    readonly SPECIES: "species";
+    readonly TASK: "task";
+    readonly USER: "user";
+    readonly VENUE: "venue";
+    readonly WORKFLOW: "workflow";
+};
+export type UsageContextType = (typeof USAGE_CONTEXT_TYPE)[keyof typeof USAGE_CONTEXT_TYPE];
+export declare const usageContextTypeSchema: z.ZodEnum<["age", "focus", "gender", "program", "species", "task", "user", "venue", "workflow"]>;
+export declare const USE: {
+    readonly CLAIM: "claim";
+    readonly PREAUTHORIZATION: "preauthorization";
+    readonly PREDETERMINATION: "predetermination";
+};
+export type Use = (typeof USE)[keyof typeof USE];
+export declare const useSchema: z.ZodEnum<["claim", "preauthorization", "predetermination"]>;
+export declare const V20493: {
+    readonly AUT: "AUT";
+    readonly CFU: "CFU";
+    readonly CLOT: "CLOT";
+    readonly CON: "CON";
+    readonly COOL: "COOL";
+    readonly FROZ: "FROZ";
+    readonly HEM: "HEM";
+    readonly LIVE: "LIVE";
+    readonly ROOM: "ROOM";
+    readonly SNR: "SNR";
+};
+export type V20493 = (typeof V20493)[keyof typeof V20493];
+export declare const v20493Schema: z.ZodEnum<["AUT", "CFU", "CLOT", "CON", "COOL", "FROZ", "HEM", "LIVE", "ROOM", "SNR"]>;
+export declare const V20916: {
+    readonly F: "F";
+    readonly FNA: "FNA";
+    readonly NF: "NF";
+    readonly NG: "NG";
+};
+export type V20916 = (typeof V20916)[keyof typeof V20916];
+export declare const v20916Schema: z.ZodEnum<["F", "FNA", "NF", "NG"]>;
+export declare const V3_CONFIDENTIALITY_CLASSIFICATION: {
+    readonly L: "L";
+    readonly M: "M";
+    readonly N: "N";
+    readonly R: "R";
+    readonly U: "U";
+    readonly V: "V";
+};
+export type V3ConfidentialityClassification = (typeof V3_CONFIDENTIALITY_CLASSIFICATION)[keyof typeof V3_CONFIDENTIALITY_CLASSIFICATION];
+export declare const v3ConfidentialityClassificationSchema: z.ZodEnum<["L", "M", "N", "R", "U", "V"]>;
+export declare const VISION_BASE: {
+    readonly DOWN: "down";
+    readonly IN: "in";
+    readonly OUT: "out";
+    readonly UP: "up";
+};
+export type VisionBase = (typeof VISION_BASE)[keyof typeof VISION_BASE];
+export declare const visionBaseSchema: z.ZodEnum<["down", "in", "out", "up"]>;
+export declare const VISION_EYES: {
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+};
+export type VisionEyes = (typeof VISION_EYES)[keyof typeof VISION_EYES];
+export declare const visionEyesSchema: z.ZodEnum<["left", "right"]>;
+export declare const X_PATH_USAGE_TYPE: {
+    readonly DISTANCE: "distance";
+    readonly NEARBY: "nearby";
+    readonly NORMAL: "normal";
+    readonly OTHER: "other";
+    readonly PHONETIC: "phonetic";
+};
+export type XPathUsageType = (typeof X_PATH_USAGE_TYPE)[keyof typeof X_PATH_USAGE_TYPE];
+export declare const xPathUsageTypeSchema: z.ZodEnum<["distance", "nearby", "normal", "other", "phonetic"]>;