@nsshunt/stsfhirclient 1.0.76 → 1.0.78

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

@@ -0,0 +1,114 @@
+import { Annotation } from "./Annotation";
+import { CodeableConcept } from "./CodeableConcept";
+import { Evidence } from "./Evidence";
+import { EvidenceVariable } from "./EvidenceVariable";
+import { EvidenceVariable_Characteristic_DefinitionByCombination } from "./EvidenceVariable_Characteristic_DefinitionByCombination";
+import { EvidenceVariable_Characteristic_DefinitionByTypeAndValue } from "./EvidenceVariable_Characteristic_DefinitionByTypeAndValue";
+import { EvidenceVariable_Characteristic_TimeFromEvent } from "./EvidenceVariable_Characteristic_TimeFromEvent";
+import { Expression } from "./Expression";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Group } from "./Group";
+import { Quantity } from "./Quantity";
+import { Range } from "./Range";
+import { Reference } from "./Reference";
+export interface EvidenceVariable_Characteristic {
+    /**
+     * @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 Label used for when a characteristic refers to another characteristic.
+     * @short Label for internal linking
+     */
+    linkId?: FhirPrimitive<string>;
+    /**
+     * @description A short, natural language description of the characteristic that could be used to communicate the criteria to an end-user.
+     * @short Natural language description of the characteristic
+     */
+    description?: FhirPrimitive<string>;
+    /**
+     * @description A human-readable string to clarify or explain concepts about the characteristic.
+     * @short Used for footnotes or explanatory notes
+     */
+    note?: Annotation[];
+    /**
+     * @description When true, this characteristic is an exclusion criterion. In other words, not matching this characteristic definition is equivalent to meeting this criterion.
+     * @short Whether the characteristic is an inclusion criterion or exclusion criterion
+     */
+    exclude?: FhirPrimitive<boolean>;
+    /**
+     * @description Defines the characteristic using a Reference.
+     * @short Defines the characteristic (without using type and value) by a Reference
+     */
+    definitionReference?: Reference<EvidenceVariable | Group | Evidence>;
+    /**
+     * @description Defines the characteristic using Canonical.
+     * @short Defines the characteristic (without using type and value) by a Canonical
+     */
+    definitionCanonical?: FhirPrimitive<string>;
+    /**
+     * @description Defines the characteristic using CodeableConcept.
+     * @short Defines the characteristic (without using type and value) by a CodeableConcept
+     */
+    definitionCodeableConcept?: CodeableConcept;
+    /**
+     * @description Defines the characteristic using Expression.
+     * @comment When another element provides a definition of the characteristic, the definitionExpression content SHALL match the definition (only adding technical concepts necessary for implementation) without changing the meaning.
+     * @short Defines the characteristic (without using type and value) by an expression
+     */
+    definitionExpression?: Expression;
+    /**
+     * @description Defines the characteristic using id.
+     * @short Defines the characteristic (without using type and value) by an id
+     */
+    definitionId?: FhirPrimitive<string>;
+    /**
+     * @backbone Nested BackboneElement: definitionByTypeAndValue [0..1]
+     */
+    definitionByTypeAndValue?: EvidenceVariable_Characteristic_DefinitionByTypeAndValue;
+    /**
+     * @backbone Nested BackboneElement: definitionByCombination [0..1]
+     */
+    definitionByCombination?: EvidenceVariable_Characteristic_DefinitionByCombination;
+    /**
+     * @choice This is part of the instances[x] choice.
+     * @oneOf instancesQuantity, instancesRange
+     */
+    instancesQuantity?: Quantity;
+    /**
+     * @choice This is part of the instances[x] choice.
+     * @oneOf instancesQuantity, instancesRange
+     */
+    instancesRange?: Range;
+    /**
+     * @choice This is part of the duration[x] choice.
+     * @oneOf durationQuantity, durationRange
+     */
+    durationQuantity?: Quantity;
+    /**
+     * @choice This is part of the duration[x] choice.
+     * @oneOf durationQuantity, durationRange
+     */
+    durationRange?: Range;
+    /**
+     * @backbone Nested BackboneElement: timeFromEvent [0..1]
+     */
+    timeFromEvent?: EvidenceVariable_Characteristic_TimeFromEvent;
+}
+//# sourceMappingURL=EvidenceVariable_Characteristic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EvidenceVariable_Characteristic.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/EvidenceVariable_Characteristic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,uDAAuD,EAAE,MAAM,2DAA2D,CAAC;AACpI,OAAO,EAAE,wDAAwD,EAAE,MAAM,4DAA4D,CAAC;AACtI,OAAO,EAAE,6CAA6C,EAAE,MAAM,iDAAiD,CAAC;AAChH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,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,MAAM,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC/B;;;OAGG;IACH,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC;IACpB;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACjC;;;OAGG;IACH,mBAAmB,CAAC,EAAE,SAAS,CAAC,gBAAgB,GAAG,KAAK,GAAG,QAAQ,CAAC,CAAC;IACrE;;;OAGG;IACH,mBAAmB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5C;;;OAGG;IACH,yBAAyB,CAAC,EAAE,eAAe,CAAC;IAC5C;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,UAAU,CAAC;IAClC;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACrC;;OAEG;IACH,wBAAwB,CAAC,EAAE,wDAAwD,CAAC;IACpF;;OAEG;IACH,uBAAuB,CAAC,EAAE,uDAAuD,CAAC;IAClF;;;OAGG;IACH,iBAAiB,CAAC,EAAE,QAAQ,CAAC;IAC7B;;;OAGG;IACH,cAAc,CAAC,EAAE,KAAK,CAAC;IACvB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,QAAQ,CAAC;IAC5B;;;OAGG;IACH,aAAa,CAAC,EAAE,KAAK,CAAC;IACtB;;OAEG;IACH,aAAa,CAAC,EAAE,6CAA6C,CAAC;CAC/D"}

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

@@ -0,0 +1,39 @@
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface EvidenceVariable_Characteristic_DefinitionByCombination {
+    /**
+     * @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 Used to specify if two or more characteristics are combined with OR or AND.
+     * @short all-of | any-of | at-least | at-most | statistical | net-effect | dataset
+     */
+    code: FhirPrimitive<string>;
+    /**
+     * @description Provides the value of "n" when "at-least" or "at-most" codes are used.
+     * @short Provides the value of "n" when "at-least" or "at-most" codes are used
+     */
+    threshold?: FhirPrimitive<number>;
+    /**
+     * @description A defining factor of the characteristic.
+     * @short A defining factor of the characteristic
+     */
+    characteristic: any[];
+}
+//# sourceMappingURL=EvidenceVariable_Characteristic_DefinitionByCombination.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EvidenceVariable_Characteristic_DefinitionByCombination.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/EvidenceVariable_Characteristic_DefinitionByCombination.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIhD,MAAM,WAAW,uDAAuD;IACtE;;;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,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B;;;OAGG;IACH,SAAS,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAClC;;;OAGG;IACH,cAAc,EAAE,GAAG,EAAE,CAAC;CACvB"}

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

@@ -0,0 +1,80 @@
+import { CodeableConcept } from "./CodeableConcept";
+import { Device } from "./Device";
+import { DeviceMetric } from "./DeviceMetric";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Quantity } from "./Quantity";
+import { Range } from "./Range";
+import { Reference } from "./Reference";
+export interface EvidenceVariable_Characteristic_DefinitionByTypeAndValue {
+    /**
+     * @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 Used to express the type of characteristic.
+     * @short Expresses the type of characteristic
+     */
+    type: CodeableConcept;
+    /**
+     * @description Method for how the characteristic value was determined.
+     * @short Method for how the characteristic value was determined
+     */
+    method?: CodeableConcept[];
+    /**
+     * @description Device used for determining characteristic.
+     * @short Device used for determining characteristic
+     */
+    device?: Reference<Device | DeviceMetric>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCodeableConcept, valueBoolean, valueQuantity, valueRange, valueReference, valueId
+     */
+    valueCodeableConcept?: CodeableConcept;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCodeableConcept, valueBoolean, valueQuantity, valueRange, valueReference, valueId
+     */
+    valueBoolean?: FhirPrimitive<boolean>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCodeableConcept, valueBoolean, valueQuantity, valueRange, valueReference, valueId
+     */
+    valueQuantity?: Quantity;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCodeableConcept, valueBoolean, valueQuantity, valueRange, valueReference, valueId
+     */
+    valueRange?: Range;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCodeableConcept, valueBoolean, valueQuantity, valueRange, valueReference, valueId
+     */
+    valueReference?: Reference;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCodeableConcept, valueBoolean, valueQuantity, valueRange, valueReference, valueId
+     */
+    valueId?: FhirPrimitive<string>;
+    /**
+     * @description Defines the reference point for comparison when valueQuantity or valueRange is not compared to zero.
+     * @short Reference point for valueQuantity or valueRange
+     */
+    offset?: CodeableConcept;
+}
+//# sourceMappingURL=EvidenceVariable_Characteristic_DefinitionByTypeAndValue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EvidenceVariable_Characteristic_DefinitionByTypeAndValue.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/EvidenceVariable_Characteristic_DefinitionByTypeAndValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,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,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,MAAM,WAAW,wDAAwD;IACvE;;;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,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;IAC3B;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,YAAY,CAAC,CAAC;IAC1C;;;OAGG;IACH,oBAAoB,CAAC,EAAE,eAAe,CAAC;IACvC;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACtC;;;OAGG;IACH,aAAa,CAAC,EAAE,QAAQ,CAAC;IACzB;;;OAGG;IACH,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB;;;OAGG;IACH,cAAc,CAAC,EAAE,SAAS,CAAC;IAC3B;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAChC;;;OAGG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B"}

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

@@ -0,0 +1,69 @@
+import { Annotation } from "./Annotation";
+import { CodeableConcept } from "./CodeableConcept";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Quantity } from "./Quantity";
+import { Range } from "./Range";
+import { Reference } from "./Reference";
+export interface EvidenceVariable_Characteristic_TimeFromEvent {
+    /**
+     * @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 Human readable description.
+     * @short Human readable description
+     */
+    description?: FhirPrimitive<string>;
+    /**
+     * @description A human-readable string to clarify or explain concepts about the timeFromEvent.
+     * @short Used for footnotes or explanatory notes
+     */
+    note?: Annotation[];
+    /**
+     * @choice This is part of the event[x] choice.
+     * @oneOf eventCodeableConcept, eventReference, eventDateTime, eventId
+     */
+    eventCodeableConcept?: CodeableConcept;
+    /**
+     * @choice This is part of the event[x] choice.
+     * @oneOf eventCodeableConcept, eventReference, eventDateTime, eventId
+     */
+    eventReference?: Reference;
+    /**
+     * @choice This is part of the event[x] choice.
+     * @oneOf eventCodeableConcept, eventReference, eventDateTime, eventId
+     */
+    eventDateTime?: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the event[x] choice.
+     * @oneOf eventCodeableConcept, eventReference, eventDateTime, eventId
+     */
+    eventId?: FhirPrimitive<string>;
+    /**
+     * @description Used to express the observation at a defined amount of time before or after the event.
+     * @short Used to express the observation at a defined amount of time before or after the event
+     */
+    quantity?: Quantity;
+    /**
+     * @description Used to express the observation within a period before andor after the event.
+     * @short Used to express the observation within a period before andor after the event
+     */
+    range?: Range;
+}
+//# sourceMappingURL=EvidenceVariable_Characteristic_TimeFromEvent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EvidenceVariable_Characteristic_TimeFromEvent.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/EvidenceVariable_Characteristic_TimeFromEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,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,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,MAAM,WAAW,6CAA6C;IAC5D;;;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,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC;IACpB;;;OAGG;IACH,oBAAoB,CAAC,EAAE,eAAe,CAAC;IACvC;;;OAGG;IACH,cAAc,CAAC,EAAE,SAAS,CAAC;IAC3B;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;CACf"}

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

@@ -0,0 +1,56 @@
+import { Annotation } from "./Annotation";
+import { CodeableConcept } from "./CodeableConcept";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface Evidence_Certainty {
+    /**
+     * @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 Textual description of certainty.
+     * @short Textual description of certainty
+     */
+    description?: FhirPrimitive<string>;
+    /**
+     * @description Footnotes andor explanatory notes.
+     * @short Footnotes andor explanatory notes
+     */
+    note?: Annotation[];
+    /**
+     * @description Aspect of certainty being rated.
+     * @short Aspect of certainty being rated
+     */
+    type?: CodeableConcept;
+    /**
+     * @description Assessment or judgement of the aspect.
+     * @short Assessment or judgement of the aspect
+     */
+    rating?: CodeableConcept;
+    /**
+     * @description Individual or group who did the rating.
+     * @short Individual or group who did the rating
+     */
+    rater?: FhirPrimitive<string>;
+    /**
+     * @description A domain or subdomain of certainty.
+     * @short A domain or subdomain of certainty
+     */
+    subcomponent?: any[];
+}
+//# sourceMappingURL=Evidence_Certainty.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Evidence_Certainty.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/Evidence_Certainty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIhD,MAAM,WAAW,kBAAkB;IACjC;;;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,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC;IACpB;;;OAGG;IACH,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB;;;OAGG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB;;;OAGG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9B;;;OAGG;IACH,YAAY,CAAC,EAAE,GAAG,EAAE,CAAC;CACtB"}

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

@@ -0,0 +1,80 @@
+import { Annotation } from "./Annotation";
+import { CodeableConcept } from "./CodeableConcept";
+import { Evidence_Statistic_AttributeEstimate } from "./Evidence_Statistic_AttributeEstimate";
+import { Evidence_Statistic_ModelCharacteristic } from "./Evidence_Statistic_ModelCharacteristic";
+import { Evidence_Statistic_SampleSize } from "./Evidence_Statistic_SampleSize";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Quantity } from "./Quantity";
+export interface Evidence_Statistic {
+    /**
+     * @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 description of the content value of the statistic.
+     * @short Description of content
+     */
+    description?: FhirPrimitive<string>;
+    /**
+     * @description Footnotes andor explanatory notes.
+     * @short Footnotes andor explanatory notes
+     */
+    note?: Annotation[];
+    /**
+     * @description Type of statistic, e.g., relative risk.
+     * @short Type of statistic, e.g., relative risk
+     */
+    statisticType?: CodeableConcept;
+    /**
+     * @description When the measured variable is handled categorically, the category element is used to define which category the statistic is reporting.
+     * @comment Simple strings can be used for descriptive purposes. Exact matching to EvidenceVariable.category.name for the Evidence.variableDefinition[variableRole=measuredVariable].observed=Reference(EvidenceVariable) could facilitate validation within datasets.
+     * @short Associated category for categorical variable
+     */
+    category?: CodeableConcept;
+    /**
+     * @description Statistic value.
+     * @short Statistic value
+     */
+    quantity?: Quantity;
+    /**
+     * @description The number of events associated with the statistic, where the unit of analysis is different from numberAffected, sampleSize.knownDataCount and sampleSize.numberOfParticipants.
+     * @comment When the number of events is the statistic, use Evidence.statistic.quantity and set Evidence.statistic.type.coding.code=C25463 and Evidence.statistic.type.coding.display=Count. When the statistic is an Event Rate (where individual participants may have 2 or more events), use Evidence.statistic.numberOfEvents to record the total number of events rather than the number of participants with events.
+     * @short The number of events associated with the statistic
+     */
+    numberOfEvents?: FhirPrimitive<number>;
+    /**
+     * @description The number of participants affected where the unit of analysis is the same as sampleSize.knownDataCount and sampleSize.numberOfParticipants.
+     * @comment When the number affected is the statistic, use Evidence.statistic.quantity and set Evidence.statistic.type.coding.code=C25463 and Evidence.statistic.type.coding.display=Count. When the statistic is a Proportion, use Evidence.statistic.numberAffected and enter an integer as the value. When the statistic is an Event Rate (where individual participants may have 2 or more events), use Evidence.statistic.numberAffected to record the number of participants with events rather than the total number of events.
+     * @short The number of participants affected
+     */
+    numberAffected?: FhirPrimitive<number>;
+    /**
+     * @backbone Nested BackboneElement: sampleSize [0..1]
+     */
+    sampleSize?: Evidence_Statistic_SampleSize;
+    /**
+     * @backbone Nested BackboneElement: attributeEstimate [0..1]
+     */
+    attributeEstimate?: Evidence_Statistic_AttributeEstimate;
+    /**
+     * @backbone Nested BackboneElement: modelCharacteristic [0..1]
+     */
+    modelCharacteristic?: Evidence_Statistic_ModelCharacteristic;
+}
+//# sourceMappingURL=Evidence_Statistic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Evidence_Statistic.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/Evidence_Statistic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,oCAAoC,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,sCAAsC,EAAE,MAAM,0CAA0C,CAAC;AAClG,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGtC,MAAM,WAAW,kBAAkB;IACjC;;;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,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC;IACpB;;;OAGG;IACH,aAAa,CAAC,EAAE,eAAe,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB;;;;OAIG;IACH,cAAc,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACvC;;;;OAIG;IACH,cAAc,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACvC;;OAEG;IACH,UAAU,CAAC,EAAE,6BAA6B,CAAC;IAC3C;;OAEG;IACH,iBAAiB,CAAC,EAAE,oCAAoC,CAAC;IACzD;;OAEG;IACH,mBAAmB,CAAC,EAAE,sCAAsC,CAAC;CAC9D"}

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

@@ -0,0 +1,65 @@
+import { Annotation } from "./Annotation";
+import { CodeableConcept } from "./CodeableConcept";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Quantity } from "./Quantity";
+import { Range } from "./Range";
+export interface Evidence_Statistic_AttributeEstimate {
+    /**
+     * @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 Human-readable summary of the estimate.
+     * @short Textual description of the attribute estimate
+     */
+    description?: FhirPrimitive<string>;
+    /**
+     * @description Footnote or explanatory note about the estimate.
+     * @short Footnote or explanatory note about the estimate
+     */
+    note?: Annotation[];
+    /**
+     * @description The type of attribute estimate, e.g., confidence interval or p value.
+     * @short The type of attribute estimate, e.g., confidence interval or p value
+     */
+    type?: CodeableConcept;
+    /**
+     * @description The singular quantity of the attribute estimate, for attribute estimates represented as single values; also used to report unit of measure.
+     * @comment Often the p value
+     * @short The singular quantity of the attribute estimate, for attribute estimates represented as single values; also used to report unit of measure
+     */
+    quantity?: Quantity;
+    /**
+     * @description Use 95 for a 95% confidence interval.
+     * @short Level of confidence interval, e.g., 0.95 for 95% confidence interval
+     */
+    level?: FhirPrimitive<number>;
+    /**
+     * @description Lower bound of confidence interval.
+     * @short Lower and upper bound values of the attribute estimate
+     */
+    range?: Range;
+    /**
+     * @description A nested attribute estimate; which is the attribute estimate of an attribute estimate.
+     * @comment A nested attribute estimate; which is the attribute estimate of an attribute estimate
+     * @short A nested attribute estimate; which is the attribute estimate of an attribute estimate
+     */
+    attributeEstimate?: any[];
+}
+//# sourceMappingURL=Evidence_Statistic_AttributeEstimate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Evidence_Statistic_AttributeEstimate.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/Evidence_Statistic_AttributeEstimate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,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,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAIhC,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;;;OAGG;IACH,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC;IACpB;;;OAGG;IACH,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB;;;OAGG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9B;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IACd;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,GAAG,EAAE,CAAC;CAC3B"}

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

@@ -0,0 +1,45 @@
+import { CodeableConcept } from "./CodeableConcept";
+import { Evidence_Statistic_ModelCharacteristic_Variable } from "./Evidence_Statistic_ModelCharacteristic_Variable";
+import { Extension } from "./Extension";
+import { Quantity } from "./Quantity";
+export interface Evidence_Statistic_ModelCharacteristic {
+    /**
+     * @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 Description of a component of the method to generate the statistic.
+     * @short Model specification
+     */
+    code: CodeableConcept;
+    /**
+     * @description Further specification of the quantified value of the component of the method to generate the statistic.
+     * @short Numerical value to complete model specification
+     */
+    value?: Quantity;
+    /**
+     * @backbone Nested BackboneElement: variable [0..1]
+     */
+    variable?: Evidence_Statistic_ModelCharacteristic_Variable;
+    /**
+     * @description An attribute of the statistic used as a model characteristic.
+     * @short An attribute of the statistic used as a model characteristic
+     */
+    attributeEstimate?: any[];
+}
+//# sourceMappingURL=Evidence_Statistic_ModelCharacteristic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Evidence_Statistic_ModelCharacteristic.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/Evidence_Statistic_ModelCharacteristic.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,+CAA+C,EAAE,MAAM,mDAAmD,CAAC;AACpH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAItC,MAAM,WAAW,sCAAsC;IACrD;;;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,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB;;OAEG;IACH,QAAQ,CAAC,EAAE,+CAA+C,CAAC;IAC3D;;;OAGG;IACH,iBAAiB,CAAC,EAAE,GAAG,EAAE,CAAC;CAC3B"}