@nsshunt/stsfhirclient 1.0.77 → 1.0.79

package/types/fhir-ts/CoverageEligibilityRequest_Event.d.ts

@@ -0,0 +1,41 @@
+import { CodeableConcept } from "./CodeableConcept";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Period } from "./Period";
+export interface CoverageEligibilityRequest_Event {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description A coded event such as when a service is expected or a card printed.
+     * @short Specific event
+     */
+    type: CodeableConcept;
+    /**
+     * @choice This is part of the when[x] choice.
+     * @oneOf whenDateTime, whenPeriod
+     */
+    whenDateTime?: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the when[x] choice.
+     * @oneOf whenDateTime, whenPeriod
+     */
+    whenPeriod?: Period;
+}
+//# sourceMappingURL=CoverageEligibilityRequest_Event.d.ts.map

package/types/fhir-ts/CoverageEligibilityRequest_Event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoverageEligibilityRequest_Event.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CoverageEligibilityRequest_Event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,MAAM,WAAW,gCAAgC;IAC/C;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,IAAI,EAAE,eAAe,CAAC;IACtB;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACrC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/types/fhir-ts/CoverageEligibilityRequest_Insurance.d.ts

@@ -0,0 +1,42 @@
+import { Coverage } from "./Coverage";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Reference } from "./Reference";
+export interface CoverageEligibilityRequest_Insurance {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description A flag to indicate that this Coverage is to be used for evaluation of this request when set to true.
+     * @comment A patient may (will) have multiple insurance policies which provide reimburement for healthcare services and products. For example a person may also be covered by their spouse's policy and both appear in the list (and may be from the same insurer). This flag will be set to true for only one of the listed policies and that policy will be used for evaluating this request. Other requests would be created to request evaluation against the other listed policies.
+     * @short Applicable coverage
+     */
+    focal?: FhirPrimitive<boolean>;
+    /**
+     * @description Reference to the insurance card level information contained in the Coverage resource. The coverage issuing insurer will use these details to locate the patient's actual coverage within the insurer's information system.
+     * @short Insurance information
+     */
+    coverage: Reference<Coverage>;
+    /**
+     * @description A business agreement number established between the provider and the insurer for special business processing purposes.
+     * @short Additional provider contract number
+     */
+    businessArrangement?: FhirPrimitive<string>;
+}
+//# sourceMappingURL=CoverageEligibilityRequest_Insurance.d.ts.map

package/types/fhir-ts/CoverageEligibilityRequest_Insurance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoverageEligibilityRequest_Insurance.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CoverageEligibilityRequest_Insurance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,MAAM,WAAW,oCAAoC;IACnD;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;;OAIG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC/B;;;OAGG;IACH,QAAQ,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IAC9B;;;OAGG;IACH,mBAAmB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC7C"}

package/types/fhir-ts/CoverageEligibilityRequest_Item.d.ts

@@ -0,0 +1,86 @@
+import { CodeableConcept } from "./CodeableConcept";
+import { CoverageEligibilityRequest_Item_Diagnosis } from "./CoverageEligibilityRequest_Item_Diagnosis";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Location } from "./Location";
+import { Money } from "./Money";
+import { Organization } from "./Organization";
+import { Practitioner } from "./Practitioner";
+import { PractitionerRole } from "./PractitionerRole";
+import { Quantity } from "./Quantity";
+import { Reference } from "./Reference";
+import { Resource } from "./Resource";
+export interface CoverageEligibilityRequest_Item {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description Exceptions, special conditions and supporting information applicable for this service or product line.
+     * @short Applicable exception or supporting information
+     */
+    supportingInfoSequence?: FhirPrimitive<number>[];
+    /**
+     * @description Code to identify the general type of benefits under which products and services are provided.
+     * @comment Examples include Medical Care, Periodontics, Renal Dialysis, Vision Coverage.
+     * @short Benefit classification
+     */
+    category?: CodeableConcept;
+    /**
+     * @description This contains the product, service, drug or other billing code for the item.
+     * @comment Code to indicate the Professional Service or Product supplied (e.g. CTP, HCPCS, USCLS, ICD10, NCPDP, DIN, RxNorm, ACHI, CCI).
+     * @short Billing, service, product, or drug code
+     */
+    productOrService?: CodeableConcept;
+    /**
+     * @description Item typification or modifiers codes to convey additional context for the product or service.
+     * @comment For example in Oral whether the treatment is cosmetic or associated with TMJ, or for Medical whether the treatment was outside the clinic or out of office hours.
+     * @short Product or service billing modifiers
+     */
+    modifier?: CodeableConcept[];
+    /**
+     * @description The practitioner who is responsible for the product or service to be rendered to the patient.
+     * @short Perfoming practitioner
+     */
+    provider?: Reference<Practitioner | PractitionerRole>;
+    /**
+     * @description The number of repetitions of a service or product.
+     * @short Count of products or services
+     */
+    quantity?: Quantity;
+    /**
+     * @description The amount charged to the patient by the provider for a single unit.
+     * @short Fee, charge or cost per item
+     */
+    unitPrice?: Money;
+    /**
+     * @description Facility where the services will be provided.
+     * @short Servicing facility
+     */
+    facility?: Reference<Location | Organization>;
+    /**
+     * @backbone Nested BackboneElement: diagnosis [0..1]
+     */
+    diagnosis?: CoverageEligibilityRequest_Item_Diagnosis;
+    /**
+     * @description The planproposalorder describing the proposed service in detail.
+     * @short Product or service details
+     */
+    detail?: Reference<Resource>[];
+}
+//# sourceMappingURL=CoverageEligibilityRequest_Item.d.ts.map

package/types/fhir-ts/CoverageEligibilityRequest_Item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoverageEligibilityRequest_Item.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CoverageEligibilityRequest_Item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,yCAAyC,EAAE,MAAM,6CAA6C,CAAC;AACxG,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGtC,MAAM,WAAW,+BAA+B;IAC9C;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,sBAAsB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;IACjD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,eAAe,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC,YAAY,GAAG,gBAAgB,CAAC,CAAC;IACtD;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB;;;OAGG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC,QAAQ,GAAG,YAAY,CAAC,CAAC;IAC9C;;OAEG;IACH,SAAS,CAAC,EAAE,yCAAyC,CAAC;IACtD;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;CAChC"}

package/types/fhir-ts/CoverageEligibilityRequest_Item_Diagnosis.d.ts

@@ -0,0 +1,35 @@
+import { CodeableConcept } from "./CodeableConcept";
+import { Extension } from "./Extension";
+import { Reference } from "./Reference";
+export interface CoverageEligibilityRequest_Item_Diagnosis {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @choice This is part of the diagnosis[x] choice.
+     * @oneOf diagnosisCodeableConcept, diagnosisReference
+     */
+    diagnosisCodeableConcept?: CodeableConcept;
+    /**
+     * @choice This is part of the diagnosis[x] choice.
+     * @oneOf diagnosisCodeableConcept, diagnosisReference
+     */
+    diagnosisReference?: Reference;
+}
+//# sourceMappingURL=CoverageEligibilityRequest_Item_Diagnosis.d.ts.map

package/types/fhir-ts/CoverageEligibilityRequest_Item_Diagnosis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoverageEligibilityRequest_Item_Diagnosis.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CoverageEligibilityRequest_Item_Diagnosis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,MAAM,WAAW,yCAAyC;IACxD;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,wBAAwB,CAAC,EAAE,eAAe,CAAC;IAC3C;;;OAGG;IACH,kBAAkB,CAAC,EAAE,SAAS,CAAC;CAChC"}

package/types/fhir-ts/CoverageEligibilityRequest_SupportingInfo.d.ts

@@ -0,0 +1,42 @@
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Reference } from "./Reference";
+import { Resource } from "./Resource";
+export interface CoverageEligibilityRequest_SupportingInfo {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description A number to uniquely identify supporting information entries.
+     * @short Information instance identifier
+     */
+    sequence: FhirPrimitive<number>;
+    /**
+     * @description Additional data or information such as resources, documents, images etc. including references to the data or the actual inclusion of the data.
+     * @comment Could be used to provide references to other resources, document. For example could contain a PDF in an Attachment of the Police Report for an Accident.
+     * @short Data to be provided
+     */
+    information: Reference<Resource>;
+    /**
+     * @description The supporting materials are applicable for all detail items, productservce categories and specific billing codes.
+     * @short Applies to all items
+     */
+    appliesToAll?: FhirPrimitive<boolean>;
+}
+//# sourceMappingURL=CoverageEligibilityRequest_SupportingInfo.d.ts.map

package/types/fhir-ts/CoverageEligibilityRequest_SupportingInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoverageEligibilityRequest_SupportingInfo.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CoverageEligibilityRequest_SupportingInfo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGtC,MAAM,WAAW,yCAAyC;IACxD;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAChC;;;;OAIG;IACH,WAAW,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IACjC;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACvC"}

package/types/fhir-ts/CoverageEligibilityResponse.d.ts

@@ -0,0 +1,159 @@
+import { CodeableConcept } from "./CodeableConcept";
+import { CoverageEligibilityRequest } from "./CoverageEligibilityRequest";
+import { CoverageEligibilityResponse_Error } from "./CoverageEligibilityResponse_Error";
+import { CoverageEligibilityResponse_Event } from "./CoverageEligibilityResponse_Event";
+import { CoverageEligibilityResponse_Insurance } from "./CoverageEligibilityResponse_Insurance";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Identifier } from "./Identifier";
+import { Meta } from "./Meta";
+import { Narrative } from "./Narrative";
+import { Organization } from "./Organization";
+import { Patient } from "./Patient";
+import { Period } from "./Period";
+import { Practitioner } from "./Practitioner";
+import { PractitionerRole } from "./PractitionerRole";
+import { Reference } from "./Reference";
+import { Resource } from "./Resource";
+export interface CoverageEligibilityResponse {
+    /**
+     * @description The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.
+     * @comment Within the context of the FHIR RESTful interactions, the resource has an id except for cases like the create and conditional update. Otherwise, the use of the resouce id depends on the given use case.
+     * @short Logical id of this artifact
+     */
+    id?: string;
+    /**
+     * @description The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.
+     * @short Metadata about the resource
+     */
+    meta?: Meta;
+    /**
+     * @description A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content. Often, this is a reference to an implementation guide that defines the special rules along with other profiles etc.
+     * @comment Asserting this rule set restricts the content to be only understood by a limited set of trading partners. This inherently limits the usefulness of the data in the long term. However, the existing health eco-system is highly fractured, and not yet ready to define, collect, and exchange data in a generally computable sense. Wherever possible, implementers andor specification writers should avoid using this element. Often, when used, the URL is a reference to an implementation guide that defines these special rules as part of its narrative along with other profiles, value sets, etc.
+     * @short A set of rules under which this content was created
+     */
+    implicitRules?: FhirPrimitive<string>;
+    /**
+     * @description The base language in which the resource is written.
+     * @comment Language is provided to support indexing and accessibility (typically, services such as text to speech use the language tag). The html language tag in the narrative applies  to the narrative. The language tag on the resource may be used to specify the language of other presentations generated from the data in the resource. Not all the content has to be in the base language. The Resource.language should not be assumed to apply to the narrative automatically. If a language is specified, it should it also be specified on the div element in the html (see rules in HTML5 for information about the relationship between xml:lang and the html lang attribute).
+     * @short Language of the resource content
+     */
+    language?: FhirPrimitive<string>;
+    /**
+     * @description A human-readable narrative that contains a summary of the resource and can be used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it "clinically safe" for a human to just read the narrative. Resource definitions may define what content should be represented in the narrative to ensure clinical safety.
+     * @comment Contained resources do not have a narrative. Resources that are not contained SHOULD have a narrative. In some cases, a resource may only have text with little or no additional discrete data (as long as all minOccurs=1 elements are satisfied).  This may be necessary for data from legacy systems where information is captured as a "text blob" or where text is additionally entered raw or narrated and encoded information is added later.
+     * @short Text summary of the resource, for human interpretation
+     */
+    text?: Narrative;
+    /**
+     * @description These resources do not have an independent existence apart from the resource that contains them - they cannot be identified independently, nor can they have their own independent transaction scope. This is allowed to be a Parameters resource if and only if it is referenced by a resource that provides contextmeaning.
+     * @comment This should never be done when the content can be identified properly, as once identification is lost, it is extremely difficult (and context dependent) to restore it again. Contained resources may have profiles and tags in their meta elements, but SHALL NOT have security labels.
+     * @short Contained, inline Resources
+     */
+    contained?: Resource[];
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the resource. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the resource and that modifies the understanding of the element that contains it andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description A unique identifier assigned to this coverage eligiblity request.
+     * @short Business Identifier for coverage eligiblity request
+     */
+    identifier?: Identifier[];
+    /**
+     * @description The status of the resource instance.
+     * @comment This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.
+     * @short active | cancelled | draft | entered-in-error
+     */
+    status: FhirPrimitive<string>;
+    /**
+     * @description Code to specify whether requesting: prior authorization requirements for some service categories or billing codes; benefits for coverages specified or discovered; discovery and return of coverages for the patient; andor validation that the specified coverage is in-force at the dateperiod specified or 'now' if not specified.
+     * @short auth-requirements | benefits | discovery | validation
+     */
+    purpose: FhirPrimitive<string>[];
+    /**
+     * @description The party who is the beneficiary of the supplied coverage and for whom eligibility is sought.
+     * @short Intended recipient of products and services
+     */
+    patient: Reference<Patient>;
+    /**
+     * @backbone Nested BackboneElement: event [0..*]
+     */
+    event?: CoverageEligibilityResponse_Event[];
+    /**
+     * @choice This is part of the serviced[x] choice.
+     * @oneOf servicedDate, servicedPeriod
+     */
+    servicedDate?: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the serviced[x] choice.
+     * @oneOf servicedDate, servicedPeriod
+     */
+    servicedPeriod?: Period;
+    /**
+     * @description The date this resource was created.
+     * @short Response creation date
+     */
+    created: FhirPrimitive<string>;
+    /**
+     * @description The provider which is responsible for the request.
+     * @comment This party is responsible for the claim but not necessarily professionally responsible for the provision of the individual products and services listed below. This field is the Billing Provider, for example, a facility, provider group, lab or practitioner.
+     * @short Party responsible for the request
+     */
+    requestor?: Reference<Practitioner | PractitionerRole | Organization>;
+    /**
+     * @description Reference to the original request resource.
+     * @short Eligibility request reference
+     */
+    request: Reference<CoverageEligibilityRequest>;
+    /**
+     * @description The outcome of the request processing.
+     * @comment The resource may be used to indicate that: the request has been held (queued) for processing; that it has been processed and errors found (error); that no errors were found and that some of the adjudication has been undertaken (partial) or that all of the adjudication has been undertaken (complete).
+     * @short queued | complete | error | partial
+     */
+    outcome: FhirPrimitive<string>;
+    /**
+     * @description A human readable description of the status of the adjudication.
+     * @short Disposition Message
+     */
+    disposition?: FhirPrimitive<string>;
+    /**
+     * @description The Insurer who issued the coverage in question and is the author of the response.
+     * @short Coverage issuer
+     */
+    insurer: Reference<Organization>;
+    /**
+     * @backbone Nested BackboneElement: insurance [0..*]
+     */
+    insurance?: CoverageEligibilityResponse_Insurance[];
+    /**
+     * @description A reference from the Insurer to which these services pertain to be used on further communication and as proof that the request occurred.
+     * @short Preauthorization reference
+     */
+    preAuthRef?: FhirPrimitive<string>;
+    /**
+     * @description A code for the form to be used for printing the content.
+     * @comment May be needed to identify specific jurisdictional forms.
+     * @short Printed form identifier
+     */
+    form?: CodeableConcept;
+    /**
+     * @backbone Nested BackboneElement: error [0..*]
+     */
+    error?: CoverageEligibilityResponse_Error[];
+    /**
+     * @const Auto-injected fixed value: CoverageEligibilityResponse
+     */
+    resourceType: "CoverageEligibilityResponse";
+}
+//# sourceMappingURL=CoverageEligibilityResponse.d.ts.map

package/types/fhir-ts/CoverageEligibilityResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoverageEligibilityResponse.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CoverageEligibilityResponse.ts"],"names":[],"mappings":"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"}

package/types/fhir-ts/CoverageEligibilityResponse_Error.d.ts

@@ -0,0 +1,36 @@
+import { CodeableConcept } from "./CodeableConcept";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface CoverageEligibilityResponse_Error {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description An error code,from a specified code system, which details why the eligibility check could not be performed.
+     * @short Error code detailing processing issues
+     */
+    code: CodeableConcept;
+    /**
+     * @description A [simple subset of FHIRPath](fhirpath.html#simple) limited to element names, repetition indicators and the default child accessor that identifies one of the elements in the resource that caused this issue to be raised.
+     * @comment The root of the FHIRPath is the resource or bundle that generated OperationOutcome.  Each FHIRPath SHALL resolve to a single node.
+     * @short FHIRPath of element(s) related to issue
+     */
+    expression?: FhirPrimitive<string>[];
+}
+//# sourceMappingURL=CoverageEligibilityResponse_Error.d.ts.map

package/types/fhir-ts/CoverageEligibilityResponse_Error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoverageEligibilityResponse_Error.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CoverageEligibilityResponse_Error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,WAAW,iCAAiC;IAChD;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,IAAI,EAAE,eAAe,CAAC;IACtB;;;;OAIG;IACH,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;CACtC"}

package/types/fhir-ts/CoverageEligibilityResponse_Event.d.ts

@@ -0,0 +1,41 @@
+import { CodeableConcept } from "./CodeableConcept";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Period } from "./Period";
+export interface CoverageEligibilityResponse_Event {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description A coded event such as when a service is expected or a card printed.
+     * @short Specific event
+     */
+    type: CodeableConcept;
+    /**
+     * @choice This is part of the when[x] choice.
+     * @oneOf whenDateTime, whenPeriod
+     */
+    whenDateTime?: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the when[x] choice.
+     * @oneOf whenDateTime, whenPeriod
+     */
+    whenPeriod?: Period;
+}
+//# sourceMappingURL=CoverageEligibilityResponse_Event.d.ts.map

package/types/fhir-ts/CoverageEligibilityResponse_Event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoverageEligibilityResponse_Event.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CoverageEligibilityResponse_Event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,MAAM,WAAW,iCAAiC;IAChD;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,IAAI,EAAE,eAAe,CAAC;IACtB;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACrC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/types/fhir-ts/CoverageEligibilityResponse_Insurance.d.ts

@@ -0,0 +1,47 @@
+import { Coverage } from "./Coverage";
+import { CoverageEligibilityResponse_Insurance_Item } from "./CoverageEligibilityResponse_Insurance_Item";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Period } from "./Period";
+import { Reference } from "./Reference";
+export interface CoverageEligibilityResponse_Insurance {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element and that modifies the understanding of the element in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description Reference to the insurance card level information contained in the Coverage resource. The coverage issuing insurer will use these details to locate the patient's actual coverage within the insurer's information system.
+     * @short Insurance information
+     */
+    coverage: Reference<Coverage>;
+    /**
+     * @description Flag indicating if the coverage provided is inforce currently if no service date(s) specified or for the whole duration of the service dates.
+     * @short Coverage inforce indicator
+     */
+    inforce?: FhirPrimitive<boolean>;
+    /**
+     * @description The term of the benefits documented in this response.
+     * @short When the benefits are applicable
+     */
+    benefitPeriod?: Period;
+    /**
+     * @backbone Nested BackboneElement: item [0..1]
+     */
+    item?: CoverageEligibilityResponse_Insurance_Item;
+}
+//# sourceMappingURL=CoverageEligibilityResponse_Insurance.d.ts.map

package/types/fhir-ts/CoverageEligibilityResponse_Insurance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoverageEligibilityResponse_Insurance.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CoverageEligibilityResponse_Insurance.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,0CAA0C,EAAE,MAAM,8CAA8C,CAAC;AAC1G,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,MAAM,WAAW,qCAAqC;IACpD;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,QAAQ,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IAC9B;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACjC;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,IAAI,CAAC,EAAE,0CAA0C,CAAC;CACnD"}