@nsshunt/stsfhirclient 1.0.77 → 1.0.78

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

@@ -0,0 +1,69 @@
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { ValueSet_Expansion_Contains } from "./ValueSet_Expansion_Contains";
+import { ValueSet_Expansion_Parameter } from "./ValueSet_Expansion_Parameter";
+import { ValueSet_Expansion_Property } from "./ValueSet_Expansion_Property";
+export interface ValueSet_Expansion {
+    /**
+     * @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 identifier that uniquely identifies this expansion of the valueset, based on a unique combination of the provided parameters, the system default parameters, and the underlying system code system versions etc. Systems may re-use the same identifier as long as those factors remain the same, and the expansion is the same, but are not required to do so. This is a business identifier.
+     * @comment Typically, this uri is a UUID (e.g. urn:uuid:8230ff20-c97a-4167-a59d-dc2cb9df16dd).
+     * @short Identifies the value set expansion (business identifier)
+     */
+    identifier?: FhirPrimitive<string>;
+    /**
+     * @description As per paging Search results, the next URLs are opaque to the client, have no dictated structure, and only the server understands them.
+     * @comment Clients SHOULD use the next link, if present, to page through expansion results in preference to using the offset and count parameters. Due to the optional nature of the next link, its absence does not necessarily indicate that it is the last page of results. Instead, as the offset and count parameters SHALL be populated when paging, clients can reliably use the countoffset parameters to determine whether the whole expansion is returned.
+     * @short Opaque urls for paging through expansion results
+     */
+    next?: FhirPrimitive<string>;
+    /**
+     * @description The time at which the expansion was produced by the expanding system.
+     * @comment This SHOULD be a fully populated instant, but in some circumstances, value sets are expanded by hand, and the expansion is published without that precision.
+     * @short Time ValueSet expansion happened
+     */
+    timestamp: FhirPrimitive<string>;
+    /**
+     * @description The total number of concepts in the expansion. If the number of concept nodes in this resource is less than the stated number, then the server can return more using the offset parameter.
+     * @comment Paging only applies to flat expansions.
+     * @short Total number of codes in the expansion
+     */
+    total?: FhirPrimitive<number>;
+    /**
+     * @description If paging is being used, the offset at which this resource starts.  I.e. this resource is a partial view into the expansion. If paging is not being used, this element SHALL NOT be present.
+     * @comment Paging only applies to flat expansions. If a filter is applied, the count is the number of concepts that matched the filter, not the number of concepts in an unfiltered view of the expansion.
+     * @short Offset at which this resource starts
+     */
+    offset?: FhirPrimitive<number>;
+    /**
+     * @backbone Nested BackboneElement: parameter [0..1]
+     */
+    parameter?: ValueSet_Expansion_Parameter;
+    /**
+     * @backbone Nested BackboneElement: property [0..1]
+     */
+    property?: ValueSet_Expansion_Property;
+    /**
+     * @backbone Nested BackboneElement: contains [0..1]
+     */
+    contains?: ValueSet_Expansion_Contains;
+}
+//# sourceMappingURL=ValueSet_Expansion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ValueSet_Expansion.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/ValueSet_Expansion.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAG5E,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;;;;OAIG;IACH,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC;;;;OAIG;IACH,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC7B;;;;OAIG;IACH,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACjC;;;;OAIG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9B;;;;OAIG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC/B;;OAEG;IACH,SAAS,CAAC,EAAE,4BAA4B,CAAC;IACzC;;OAEG;IACH,QAAQ,CAAC,EAAE,2BAA2B,CAAC;IACvC;;OAEG;IACH,QAAQ,CAAC,EAAE,2BAA2B,CAAC;CACxC"}

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

@@ -0,0 +1,74 @@
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { ValueSet_Expansion_Contains_Property } from "./ValueSet_Expansion_Contains_Property";
+export interface ValueSet_Expansion_Contains {
+    /**
+     * @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 absolute URI which is the code system in which the code for this item in the expansion is defined.
+     * @short System value for the code
+     */
+    system?: FhirPrimitive<string>;
+    /**
+     * @description If true, this entry is included in the expansion for navigational purposes, and the user cannot select the code directly as a proper value.
+     * @comment This should not be understood to exclude its use for searching (e.g. by subsumption testing). The client should know whether it is appropriate for the user to select an abstract code or not.
+     * @short If user cannot select this entry
+     */
+    abstract?: FhirPrimitive<boolean>;
+    /**
+     * @description If the concept is inactive in the code system that defines it. Inactive codes are those that are no longer to be used, but are maintained by the code system for understanding legacy data. It might not be known or specified whether a concept is inactive (and it may depend on the context of use).
+     * @comment This should only have a value if the concept is inactive.
+     * @short If concept is inactive in the code system
+     */
+    inactive?: FhirPrimitive<boolean>;
+    /**
+     * @description The version of the code system from this code was taken. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged.
+     * @comment The exact value of the version string is specified by the system from which the code is derived.
+     * @short Version in which this codedisplay is defined
+     */
+    version?: FhirPrimitive<string>;
+    /**
+     * @description The code for this item in the expansion hierarchy. If this code is missing the entry in the hierarchy is a place holder (abstract) and does not represent a valid code in the value set.
+     * @short Code - if blank, this is not a selectable code
+     */
+    code?: FhirPrimitive<string>;
+    /**
+     * @description The recommended display for this item in the expansion.
+     * @short User display for the concept
+     */
+    display?: FhirPrimitive<string>;
+    /**
+     * @description Additional representations for this item - other languages, aliases, specialized purposes, used for particular purposes, etc. These are relevant when the conditions of the expansion do not fix to a single correct representation.
+     * @comment The designations provided must be based on the value set and code system definitions.
+     * @short Additional representations for this item
+     */
+    designation?: any[];
+    /**
+     * @backbone Nested BackboneElement: property [0..1]
+     */
+    property?: ValueSet_Expansion_Contains_Property;
+    /**
+     * @description Other codes and entries contained under this entry in the hierarchy.
+     * @comment If the expansion uses this element, there is  no implication about the logical relationship between them, and the  structure cannot be used for logical inferencing. The structure  exists to provide navigational assistance for helping human users to  locate codes in the expansion.
+     * @short Codes contained under this entry
+     */
+    contains?: any[];
+}
+//# sourceMappingURL=ValueSet_Expansion_Contains.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ValueSet_Expansion_Contains.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/ValueSet_Expansion_Contains.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,oCAAoC,EAAE,MAAM,wCAAwC,CAAC;AAI9F,MAAM,WAAW,2BAA2B;IAC1C;;;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;;;;OAIG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAClC;;;;OAIG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAChC;;;OAGG;IACH,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC7B;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAChC;;;;OAIG;IACH,WAAW,CAAC,EAAE,GAAG,EAAE,CAAC;IACpB;;OAEG;IACH,QAAQ,CAAC,EAAE,oCAAoC,CAAC;IAChD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC;CAClB"}

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

@@ -0,0 +1,70 @@
+import { Coding } from "./Coding";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { ValueSet_Expansion_Contains_Property_SubProperty } from "./ValueSet_Expansion_Contains_Property_SubProperty";
+export interface ValueSet_Expansion_Contains_Property {
+    /**
+     * @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 code that is a reference to ValueSet.expansion.property.code.
+     * @short Reference to ValueSet.expansion.property.code
+     */
+    code: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueCode?: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueCoding?: Coding;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueString?: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueInteger?: FhirPrimitive<number>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueBoolean?: FhirPrimitive<boolean>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueDateTime?: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueDecimal?: FhirPrimitive<number>;
+    /**
+     * @backbone Nested BackboneElement: subProperty [0..1]
+     */
+    subProperty?: ValueSet_Expansion_Contains_Property_SubProperty;
+}
+//# sourceMappingURL=ValueSet_Expansion_Contains_Property.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ValueSet_Expansion_Contains_Property.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/ValueSet_Expansion_Contains_Property.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,gDAAgD,EAAE,MAAM,oDAAoD,CAAC;AAGtH,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,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B;;;OAGG;IACH,SAAS,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAClC;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACrC;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACtC;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACrC;;OAEG;IACH,WAAW,CAAC,EAAE,gDAAgD,CAAC;CAChE"}

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

@@ -0,0 +1,65 @@
+import { Coding } from "./Coding";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface ValueSet_Expansion_Contains_Property_SubProperty {
+    /**
+     * @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 code that is a reference to ValueSet.expansion.property.code.
+     * @short Reference to ValueSet.expansion.property.code
+     */
+    code: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueCode?: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueCoding?: Coding;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueString?: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueInteger?: FhirPrimitive<number>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueBoolean?: FhirPrimitive<boolean>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueDateTime?: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueCode, valueCoding, valueString, valueInteger, valueBoolean, valueDateTime, valueDecimal
+     */
+    valueDecimal?: FhirPrimitive<number>;
+}
+//# sourceMappingURL=ValueSet_Expansion_Contains_Property_SubProperty.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ValueSet_Expansion_Contains_Property_SubProperty.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/ValueSet_Expansion_Contains_Property_SubProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,WAAW,gDAAgD;IAC/D;;;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,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACrC;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACtC;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACtC"}

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

@@ -0,0 +1,65 @@
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface ValueSet_Expansion_Parameter {
+    /**
+     * @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 Name of the input parameter to the $expand operation; may be a server-assigned name for additional default or other server-supplied parameters used to control the expansion process.
+     * @comment The names are assigned at the discretion of the server.
+     * @short Name as assigned by the client or server
+     */
+    name: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueString, valueBoolean, valueInteger, valueDecimal, valueUri, valueCode, valueDateTime
+     */
+    valueString?: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueString, valueBoolean, valueInteger, valueDecimal, valueUri, valueCode, valueDateTime
+     */
+    valueBoolean?: FhirPrimitive<boolean>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueString, valueBoolean, valueInteger, valueDecimal, valueUri, valueCode, valueDateTime
+     */
+    valueInteger?: FhirPrimitive<number>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueString, valueBoolean, valueInteger, valueDecimal, valueUri, valueCode, valueDateTime
+     */
+    valueDecimal?: FhirPrimitive<number>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueString, valueBoolean, valueInteger, valueDecimal, valueUri, valueCode, valueDateTime
+     */
+    valueUri?: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueString, valueBoolean, valueInteger, valueDecimal, valueUri, valueCode, valueDateTime
+     */
+    valueCode?: FhirPrimitive<string>;
+    /**
+     * @choice This is part of the value[x] choice.
+     * @oneOf valueString, valueBoolean, valueInteger, valueDecimal, valueUri, valueCode, valueDateTime
+     */
+    valueDateTime?: FhirPrimitive<string>;
+}
+//# sourceMappingURL=ValueSet_Expansion_Parameter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ValueSet_Expansion_Parameter.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/ValueSet_Expansion_Parameter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,WAAW,4BAA4B;IAC3C;;;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,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B;;;OAGG;IACH,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACtC;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACrC;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACrC;;;OAGG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACjC;;;OAGG;IACH,SAAS,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAClC;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACvC"}

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

@@ -0,0 +1,34 @@
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface ValueSet_Expansion_Property {
+    /**
+     * @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 code that is used to identify the property. The code is used in ValueSet.expansion.contains.property.code.
+     * @short Identifies the property on the concepts, and when referred to in operations
+     */
+    code: FhirPrimitive<string>;
+    /**
+     * @description Reference to the formal meaning of the property. One possible source of meaning is the [Concept Properties](codesystem-concept-properties.html) code system.
+     * @short Formal identifier for the property
+     */
+    uri?: FhirPrimitive<string>;
+}
+//# sourceMappingURL=ValueSet_Expansion_Property.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ValueSet_Expansion_Property.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/ValueSet_Expansion_Property.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,WAAW,2BAA2B;IAC1C;;;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,GAAG,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC7B"}

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

@@ -0,0 +1,34 @@
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface ValueSet_Scope {
+    /**
+     * @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 Criteria describing which concepts or codes should be included and why.
+     * @short Criteria describing which concepts or codes should be included and why
+     */
+    inclusionCriteria?: FhirPrimitive<string>;
+    /**
+     * @description Criteria describing which concepts or codes should be excluded and why.
+     * @short Criteria describing which concepts or codes should be excluded and why
+     */
+    exclusionCriteria?: FhirPrimitive<string>;
+}
+//# sourceMappingURL=ValueSet_Scope.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ValueSet_Scope.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/ValueSet_Scope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,WAAW,cAAc;IAC7B;;;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,iBAAiB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC1C;;;OAGG;IACH,iBAAiB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC3C"}

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

@@ -0,0 +1,134 @@
+import { CodeableConcept } from "./CodeableConcept";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Meta } from "./Meta";
+import { Narrative } from "./Narrative";
+import { Reference } from "./Reference";
+import { Resource } from "./Resource";
+import { Timing } from "./Timing";
+import { VerificationResult_Attestation } from "./VerificationResult_Attestation";
+import { VerificationResult_PrimarySource } from "./VerificationResult_PrimarySource";
+import { VerificationResult_Validator } from "./VerificationResult_Validator";
+export interface VerificationResult {
+    /**
+     * @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 resource that was validated.
+     * @short A resource that was validated
+     */
+    target?: Reference<Resource>[];
+    /**
+     * @description The fhirpath location(s) within the resource that was validated.
+     * @short The fhirpath location(s) within the resource that was validated
+     */
+    targetLocation?: FhirPrimitive<string>[];
+    /**
+     * @description The frequency with which the target must be validated (none; initial; periodic).
+     * @short none | initial | periodic
+     */
+    need?: CodeableConcept;
+    /**
+     * @description The validation status of the target (attested; validated; in process; requires revalidation; validation failed; revalidation failed).
+     * @short attested | validated | in-process | req-revalid | val-fail | reval-fail | entered-in-error
+     */
+    status: FhirPrimitive<string>;
+    /**
+     * @description When the validation status was updated.
+     * @short When the validation status was updated
+     */
+    statusDate?: FhirPrimitive<string>;
+    /**
+     * @description What the target is validated against (nothing; primary source; multiple sources).
+     * @short nothing | primary | multiple
+     */
+    validationType?: CodeableConcept;
+    /**
+     * @description The primary process by which the target is validated (edit check; value set; primary source; multiple sources; standalone; in context).
+     * @short The primary process by which the target is validated (edit check; value set; primary source; multiple sources; standalone; in context)
+     */
+    validationProcess?: CodeableConcept[];
+    /**
+     * @description Frequency of revalidation.
+     * @short Frequency of revalidation
+     */
+    frequency?: Timing;
+    /**
+     * @description The datetime validation was last completed (including failed validations).
+     * @short The datetime validation was last completed (including failed validations)
+     */
+    lastPerformed?: FhirPrimitive<string>;
+    /**
+     * @description The date when target is next validated, if appropriate.
+     * @short The date when target is next validated, if appropriate
+     */
+    nextScheduled?: FhirPrimitive<string>;
+    /**
+     * @description The result if validation fails (fatal; warning; record only; none).
+     * @short fatal | warn | rec-only | none
+     */
+    failureAction?: CodeableConcept;
+    /**
+     * @backbone Nested BackboneElement: primarySource [0..*]
+     */
+    primarySource?: VerificationResult_PrimarySource[];
+    /**
+     * @backbone Nested BackboneElement: attestation [0..1]
+     */
+    attestation?: VerificationResult_Attestation;
+    /**
+     * @backbone Nested BackboneElement: validator [0..*]
+     */
+    validator?: VerificationResult_Validator[];
+    /**
+     * @const Auto-injected fixed value: VerificationResult
+     */
+    resourceType: "VerificationResult";
+}
+//# sourceMappingURL=VerificationResult.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VerificationResult.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/VerificationResult.ts"],"names":[],"mappings":"AACA,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,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC;AAClF,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAC;AACtF,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAG9E,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACjC;;;;OAIG;IACH,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB;;;;OAIG;IACH,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IACvB;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;IAC/B;;;OAGG;IACH,cAAc,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;IACzC;;;OAGG;IACH,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB;;;OAGG;IACH,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9B;;;OAGG;IACH,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC;;;OAGG;IACH,cAAc,CAAC,EAAE,eAAe,CAAC;IACjC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,eAAe,EAAE,CAAC;IACtC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC;;;OAGG;IACH,aAAa,CAAC,EAAE,eAAe,CAAC;IAChC;;OAEG;IACH,aAAa,CAAC,EAAE,gCAAgC,EAAE,CAAC;IACnD;;OAEG;IACH,WAAW,CAAC,EAAE,8BAA8B,CAAC;IAC7C;;OAEG;IACH,SAAS,CAAC,EAAE,4BAA4B,EAAE,CAAC;IAC3C;;OAEG;IACH,YAAY,EAAE,oBAAoB,CAAC;CACpC"}